linux - script - shell unix




Comment puis-je connaître le nom du fichier de script dans un script Bash? (14)

Comment puis-je déterminer le nom du fichier de script Bash dans le script lui-même?

Comme si mon script se runme.sh dans le fichier runme.sh , comment le ferais-je pour afficher le message "Vous exécutez runme.sh" sans le coder en dur?


Étant donné que certains commentaires ont demandé le nom de fichier sans extension, voici un exemple pour y parvenir:

FileName=${0##*/}
FileNameWithoutExtension=${FileName%.*}

Prendre plaisir!


Avec bash> = 3 les travaux suivants:

$ ./s
0 is: ./s
BASH_SOURCE is: ./s
$ . ./s
0 is: bash
BASH_SOURCE is: ./s

$ cat s
#!/bin/bash

printf '$0 is: %s\n$BASH_SOURCE is: %s\n' "$0" "$BASH_SOURCE"

En bash vous pouvez obtenir le nom du fichier de script en utilisant $0 . En général, $1 , $2 etc. doivent accéder aux arguments CLI. De même $0 est d'accéder au nom qui déclenche le script (nom du fichier de script).

#!/bin/bash
echo "You are running $0"
...
...

Si vous appelez le script avec le chemin /path/to/script.sh alors $0 donnera aussi le nom du fichier avec path. Dans ce cas, vous devez utiliser $(basename $0) pour obtenir uniquement le nom du fichier de script.


Info merci à Bill Hernandez. J'ai ajouté quelques préférences que j'adopte.

#!/bin/bash
function Usage(){
    echo " Usage: show_parameters [ arg1 ][ arg2 ]"
}
[[ ${#2} -eq 0 ]] && Usage || {
    echo
    echo "# arguments called with ---->  ${@}     "
    echo "# \$1 ----------------------->  $1       "
    echo "# \$2 ----------------------->  $2       "
    echo "# path to me --------------->  ${0}     " | sed "s/$USER/\$USER/g"
    echo "# parent path -------------->  ${0%/*}  " | sed "s/$USER/\$USER/g"
    echo "# my name ------------------>  ${0##*/} "
    echo
}

À votre santé


Pour répondre à Chris Conway , sur Linux (au moins), vous feriez ceci:

echo $(basename $(readlink -nf $0))

readlink affiche la valeur d'un lien symbolique. Si ce n'est pas un lien symbolique, il imprime le nom du fichier. -n lui dit de ne pas imprimer une nouvelle ligne. -f lui dit de suivre complètement le lien (si un lien symbolique était un lien vers un autre lien, cela résoudrait aussi celui-ci).


Quelque chose comme ça?

export LC_ALL=en_US.UTF-8
#!/bin/bash
#!/bin/sh

#----------------------------------------------------------------------
start_trash(){
ver="htrash.sh v0.0.4"
$TRASH_DIR  # url to trash $MY_USER
$TRASH_SIZE # Show Trash Folder Size

echo "Would you like to empty Trash  [y/n]?"
read ans
if [ $ans = y -o $ans = Y -o $ans = yes -o $ans = Yes -o $ans = YES ]
then
echo "'yes'"
cd $TRASH_DIR && $EMPTY_TRASH
fi
if [ $ans = n -o $ans = N -o $ans = no -o $ans = No -o $ans = NO ]
then
echo "'no'"
fi
 return $TRUE
} 
#-----------------------------------------------------------------------

start_help(){
echo "HELP COMMANDS-----------------------------"
echo "htest www                 open a homepage "
echo "htest trash               empty trash     "
 return $TRUE
} #end Help
#-----------------------------------------------#

homepage=""

return $TRUE
} #end cpdebtemp

# -Case start
# if no command line arg given
# set val to Unknown
if [ -z $1 ]
then
  val="*** Unknown  ***"
elif [ -n $1 ]
then
# otherwise make first arg as val
  val=$1
fi
# use case statement to make decision for rental
case $val in
   "trash") start_trash ;;
   "help") start_help ;;
   "www") firefox $homepage ;;
   *) echo "Sorry, I can not get a $val   for you!";;
esac
# Case stop

Si le nom du script contient des espaces, une méthode plus robuste consiste à utiliser "$0" ou "$(basename "$0")" - ou sur MacOS: "$(basename \"$0\")" . Cela empêche le nom d'être altéré ou interprété de quelque façon que ce soit. En règle générale, il est recommandé de toujours citer les noms de variables dans le shell.


Si vous le voulez sans le chemin, vous utiliserez ${0##*/}


echo "Vous exécutez $ 0"


si votre invocation shell script comme

/home/mike/runme.sh

$ 0 est le nom complet

 /home/mike/runme.sh

basename $ 0 obtiendra le nom du fichier de base

 runme.sh

et vous devez mettre ce nom de base dans une variable comme

filename=$(basename $0)

et ajoutez votre texte supplémentaire

echo "You are running $filename"

donc tes scripts aiment

/home/mike/runme.sh
#!/bin/bash 
filename=$(basename $0)
echo "You are running $filename"

$BASH_SOURCE donne la réponse correcte lors de l'approvisionnement du script.

Cela inclut cependant le chemin pour obtenir le nom de fichier des scripts uniquement, utilisez:

$(basename $BASH_SOURCE) 

# ------------- SCRIPT ------------- #

#!/bin/bash

echo
echo "# arguments called with ---->  ${@}     "
echo "# \$1 ---------------------->  $1       "
echo "# \$2 ---------------------->  $2       "
echo "# path to me --------------->  ${0}     "
echo "# parent path -------------->  ${0%/*}  "
echo "# my name ------------------>  ${0##*/} "
echo
exit

# ------------- CALLED ------------- #

# Notice on the next line, the first argument is called within double, 
# and single quotes, since it contains two words

$  /misc/shell_scripts/check_root/show_parms.sh "'hello there'" "'william'"

# ------------- RESULTS ------------- #

# arguments called with --->  'hello there' 'william'
# $1 ---------------------->  'hello there'
# $2 ---------------------->  'william'
# path to me -------------->  /misc/shell_scripts/check_root/show_parms.sh
# parent path ------------->  /misc/shell_scripts/check_root
# my name ----------------->  show_parms.sh

# ------------- END ------------- #

echo "$(basename "`test -L ${BASH_SOURCE[0]} \
                   && readlink ${BASH_SOURCE[0]} \
                   || echo ${BASH_SOURCE[0]}`")"

me=`basename "$0"`

Pour lire un lien symbolique, qui n'est généralement pas ce que vous voulez (vous ne voulez généralement pas confondre l'utilisateur de cette façon), essayez:

me="$(basename "$(test -L "$0" && readlink "$0" || echo "$0")")"

OMI, cela produira des résultats confus. "J'ai couru foo.sh, mais ça veut dire que je cours bar.sh!? Doit être un bug!" En outre, l'un des objectifs d'avoir des liens symboliques nommés différemment est de fournir différentes fonctionnalités basées sur le nom que l'on appelle (pensez à gzip et gunzip sur certaines plates-formes).







scripting