9.1. Variables internes

Variablesintégrées

variables affectant le comportement des scripts bash

$BASH

le chemin vers le binaire Bash lui-même

bash$ echo $BASH /bin/bash

$BASH_ENV

une variable d'environnement pointant vers le fichier de démarrage de Bash pour être lue lorsqu'un script est invoqué

$BASH_VERSINFO[n]

un tableau array à six éléments contenant des informations sur la version installée de Bash. Ceci est similaire à $BASH_VERSION, ci-dessous, mais un peu plus détaillé.

# Infor sur la version de Bash: for n in 0 1 2 3 4 5 do echo "BASH_VERSINFO[$n] = ${BASH_VERSINFO[$n]}" done # BASH_VERSINFO[0] = 2 # No majeur de version. # BASH_VERSINFO[1] = 05 # No mineur de version. # BASH_VERSINFO[2] = 8 # Niveau de correctifs. # BASH_VERSINFO[3] = 1 # Version construite. # BASH_VERSINFO[4] = release # Etat de la release. # BASH_VERSINFO[5] = i386-redhat-linux-gnu # Architecture # (identique à $MACHTYPE).

$BASH_VERSION

la version du Bash installé sur le système

bash$ echo $BASH_VERSION 2.04.12(1)-release

tcsh% echo $BASH_VERSION BASH_VERSION: Undefined variable.

Vérifier $BASH_VERSION est une bonne méthode pour déterminer quel shell est en cours d'exécution. $SHELL ne donne pas nécessairement la bonne réponse.

$DIRSTACK

la valeur du dessus de la pile de répertoires (affectée par pushd et popd)

Cette variable intégrée correspond à la commande dirs, néanmoins dirs affiche le contenu entier de la pile de répertoires.

$EDITOR

l'éditeur par défaut invoqué par un script, habituellement vi ou emacs.

$EUID

Numéro d'identifiant << effectif >> de l'utilisateur

Numéro d'identification quelque soit l'identité que l'utilisateur actuel assume, peut-être suite à un su.

$EUID n'est pas nécessairement le même que $UID.

$FUNCNAME

nom de la fonction en cours

xyz23 () { echo "$FUNCNAME en cours d'exécution." # xyz23 en cours d'exécution. } xyz23 echo "FUNCNAME = $FUNCNAME" # FUNCNAME = # Valeur null en dehors d'une fonction.

$GLOBIGNORE

Une liste de modèles de noms de fichiers à exclure de la correspondance lors d'un remplacement.

$GROUPS

groupes auxquels appartient l'utilisateur

C'est une liste (tableau) des numéros d'identifiant de groupes pour l'utilisateur actuel, comme enregistré dans /etc/passwd.

root# echo $GROUPS 0 root# echo ${GROUPS[1]} 1 root# echo ${GROUPS[5]} 6

$HOME

répertoire personnel de l'utilisateur, habituellement /home/utilisateur (voir Exemple 9-13)

$HOSTNAME

La commande hostname définit le nom du système au démarrage en utilisant un script de démarrage. Néanmoins, la fonction gethostname() initialise la variable interne Bash $HOSTNAME. Voir aussi Exemple 9-13.

$HOSTTYPE

type de l'hôte

Comme $MACHTYPE, identifie le matériel du système.

bash$ echo $HOSTTYPE i686

$IFS

séparateur du champ de saisie

Ceci vaut par défaut un espace blanc (espace, tabulation et retour de chariot), mais peut être changé, par exemple pour analyser un fichier de données séparées par des virgules. Notez que $* utilise le premier caractère contenu dans $IFS. Voir Exemple 5-1.

bash$ echo $IFS | cat -vte $ bash$ bash -c 'set w x y z; IFS=":-;"; echo "$*"' w:x:y:z

$IFS ne gère pas les espaces blancs de la même façon que les autres caractères. Exemple 9-1. $IFS et espaces blancs #!/bin/bash # $IFS traite les espaces blancs différemment des autres caractères. sortie_des_arguments_un_par_ligne() { for arg do echo "[$arg]" done } echo; echo "IFS=\" \"" echo "-------" IFS=" " var=" a b c " sortie_des_arguments_un_par_ligne $var # sortie_des_arguments_un_par_ligne `echo " a b c "` # # [a] # [b] # [c] echo; echo "IFS=:" echo "-----" IFS=: var=":a::b:c:::" # Identique à ci-dessus, mais substitue ":" à " ". sortie_des_arguments_un_par_ligne $var # # [] # [a] # [] # [b] # [c] # [] # [] # [] # La même chose arrive avec le séparateur de champs "FS" dans awk. # Merci, Stephane Chazelas. echo exit 0

(Merci, S. C., pour cette clarification et ces exemples.)

$IGNOREEOF

ignore EOF: combien de fins de fichier (control-D) le shell va ignorer avant de déconnecter.

$LC_COLLATE

Souvent intégré dans les fichiers .bashrc ou /etc/profile, cette variable contrôle l'ordre d'examen dans l'expansion des noms de fichiers et les correspondances de modèles. Si elle est mal gérée, LC_COLLATE peut apporter des résultats inattendus dans le remplacement de noms de fichiers.

A partir de la version 2.05 de Bash, le remplacement de noms de fichiers ne tient plus compte des lettres en minuscules et en majuscules dans une suite de caractères entre crochets. Par exemple, ls [A-M]* correspondrait à la fois à Fichier1.txt et à fichier1.txt. Pour annuler le comportement personnalisé de la correspondance par crochets, initialisez LC_COLLATE à C par un export LC_COLLATE=C dans /etc/profile et/ou ~/.bashrc.

$LC_CTYPE

Cette variable interne contrôle l'interprétation des caractères pour le remplacement et la correspondance de modèles.

$LINENO

Cette variable est le numéro de ligne du script shell dans lequel cette variable apparaît. Elle n'a une signification que dans le script où elle apparait et est surtout utilisée pour les phases de déboguage.

# *** DEBUT BLOC DEBUG *** dernier_argument_command=$_ # Le sauver. echo "A la ligne numéro $LINENO, la variable \"v1\" = $v1" echo "Dernier argument de la ligne exécutée = $dernier_argument_command" # *** FIN BLOC DEBUG ***

$MACHTYPE

type de machine

Identifie le matériel du système.

bash$ echo $MACHTYPE i686

$OLDPWD

ancien répertoire courant (<< OLD-print-working-directory >>, ancien répertoire où vous étiez)

$OSTYPE

type de système d'exploitation

bash$ echo $OSTYPE linux

$PATH

chemin vers les binaires, habituellement /usr/bin/, /usr/X11R6/bin/, /usr/local/bin, etc.

Lorsqu'une commande est donnée, le shell recherche automatiquement les exécutables dans les répertoires listés dans le chemin. Le chemin est stocké dans la variable d'environnement, $PATH, une liste des répertoires, séparés par le symbôle ":". Normalement, le système stocke la définition de $PATH dans /etc/profile et/ou ~/.bashrc (voir Chapitre 27).

bash$ echo $PATH /bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/sbin:/usr/sbin

PATH=${PATH}:/opt/bin ajoute le répertoire /opt/bin au chemin actuel. Dans un script, il peut être avantageux d'ajouter temporairement un répertoire au chemin de cette façon. Lorsque le script se termine, ceci restaure le $PATH original (un processus fils, tel qu'un script, ne peut pas changer l'environnement du processus père, le shell).

Le << répertoire >> courant, ./, est habituellement omis de $PATH pour des raisons de sécurité.

$PIPESTATUS

Code de sortie de la dernière commande exécutée via un tube. De façon étonnante, ceci ne donne pas le même résultat que le code de sortie de la dernière commande exécutée.

bash$ echo $PIPESTATUS 0 bash$ ls -al | bogus_command bash: bogus_command: command not found bash$ echo $PIPESTATUS 141 bash$ ls -al | bogus_command bash: bogus_command: command not found bash$ echo $? 127

La variable $PIPESTATUS peut contenir une valeur 0 erronée dans un shell de connexion. tcsh% bash bash$ who | grep nobody | sort bash$ echo ${PIPESTATUS[*]} 0 Les lignes ci-dessus contenues dans un script produiraient le résultat attendu, 0 1 0. Merci, Wayne Pollock pour avoir partagé ceci en apportant l'exemple ci-dessus.

$PPID

Le $PPID d'un processus est l'identifiant du processus (pid) père. [1]

Comparez ceci avec la commande pidof.

$PS1

Ceci est l'invite principale, vue sur la ligne de commande.

$PS2

La deuxième invite, vue lorsqu'une saisie supplémentaire est attendue. Elle s'affiche comme << > >>.

$PS3

La troisième invite, affichée lors d'une boucle select (voir Exemple 10-29).

$PS4

La quatrième invite, affichée au début de chaque ligne d'affichage lorsqu'un script a été appelé avec l'option -x. Elle affiche un << + >>.

$PWD

répertoire courant (répertoire où vous êtes actuellement)

Ceci est analogue à la commande intégrée pwd.

#!/bin/bash E_MAUVAIS_REPERTOIRE=73 clear # Efface l'écran. RepertoireCible=/home/bozo/projects/GreatAmericanNovel cd $RepertoireCible echo "Suppression de tous les fichiers de $RepertoireCible." if [ "$PWD" != "$RepertoireCible" ] then # Empêcher la suppression d'un mauvais répertoire par accident. echo "Mauvais répertoire!" echo "Dans $PWD, plutôt que $RepertoireCible!" echo "Je quitte!" exit $E_MAUVAIS_REPERTOIRE fi rm -rf * rm .[A-Za-z0-9]* # Supprime les fichiers commençant par un point. # rm -f .[^.]* ..?* pour supprimer les fichiers commençant par plusieurs # points. # (shopt -s dotglob; rm -f *) fonctionnera aussi. # Merci, S.C. pour l'avoir indiqué. # Les noms de fichier contenant tous les caractères de 0 à 255, à l'exception # de "/". # La suppression des fichiers commençant par des caractères bizarres est laissé # en exercice. # Autres opérations ici, si nécessaire. echo echo "Fait." echo "Anciens fichiers supprimés de $RepertoireCible." echo exit 0

$REPLY

La valeur par défaut lorsqu'une valeur est donnée par read. Aussi applicable au menu select, mais apporte seulement le numéro de l'élément de la variable choisie, et non pas la valeur de la variable elle-même.

#!/bin/bash echo echo -n "Quel est votre légume favori? " read echo "Votre légume favori est $REPLY." # REPLY contient la valeur du dernier "read" si et seulement si aucune variable # n'est spécifiée. echo echo -n "Quel est votre fruit favori? " read fruit echo "Votre fruit favori est $fruit." echo "mais..." echo "La valeur de \$REPLY est toujours $REPLY." # $REPLY est toujours initialisé à sa précédente valeur car la variable $fruit # a basorbé la nouvelle valeur obtenue par "read". echo exit 0

$SECONDS

Le nombre de secondes pendant lequel le script s'exécutait.

#!/bin/bash LIMITE_TEMPS=10 INTERVALLE=1 echo echo "Tapez sur Control-C pour sortir avant $LIMITE_TEMPS secondes." echo while [ "$SECONDES" -le "$LIMITE_TEMPS" ] do if [ "$SECONDES" -eq 1 ] then unites=seconde else unites=secondes fi echo "Ce script tourne depuis $SECONDES $unites." # Sur une machine lente, le script peut laisser échapper un élément du #+ comptage quelque fois dans la boucle while. sleep $INTERVALLE done echo -e "\a" # Beep! exit 0

$SHELLOPTS

la liste des options activées du shell, une variable en lecture seule

bash$ echo $SHELLOPTS braceexpand:hashall:histexpand:monitor:history:interactive-comments:emacs

$SHLVL

Niveau du shell, comment Bash est imbriqué. Si, à la ligne de commande, $SHLVL vaut 1, alors, dans un script, il sera incrémenté et prendra la valeur 2.

$TMOUT

Si la variable d'environnement $TMOUT est initialisée à une valeur différente de zéro appelée time, alors l'invite shell dépassera son délai au bout de time secondes. Ceci causera une déconnexion.

Malheureusement, ceci fonctionne seulement lors de l'attente d'une saisie sur une invite de la console ou dans un xterm. Bien qu'il serait sympathique de spéculer sur l'utilité de cette variable interne pour des saisies avec expiration de délai, par exemple en combinaison avec read, $TMOUT ne fonctionnera pas dans ce contexte et est virtuellement inutile pour l'écriture de scripts shell. (Une information semble indiquer qu'un read avec délai fontionne sur ksh.)

Implémenter une saisie avec délai dans un script est certainement possible, mais nécessiterait un code complexe. Une méthode est de configurer une boucle avec délai pour signaler au script lorsque le délai se termine. Ceci nécessite aussi une routine de gestion du signal pour récupérer (voir Exemple 30-5) l'interruption générée par la boucle de délai (ouf!).

Exemple 9-2. Saisie avec délai

#!/bin/bash # timed-input.sh # TMOUT=3 inutile dans un script LIMITETEMPS=3 # Trois secondes dans cette instance, peut être configuré avec #+ une valeur différente. AfficheReponse() { if [ "$reponse" = TIMEOUT ] then echo $reponse else # ne pas mixer les deux interfaces. echo "Votre légume favori est le $reponse" kill $! # Kill n'est plus nécessaire pour la fonction TimerOn lancé en #+ tâche de fond. # $! est le PID du dernier job lancé en tâche de fond. fi } TimerOn() { sleep $LIMITETEMPS && kill -s 14 $$ & # Attend 3 secondes, puis envoie sigalarm au script. } VecteurInt14() { reponse="TIMEOUT" AfficheReponse exit 14 } trap VecteurInt14 14 # Interruption de temps (14) détournée pour notre but. echo "Quel est votre légume favori?" TimerOn read reponse AfficheReponse # C'est une implémentation détournée de l'entrée de temps, #+ néanmoins l'option "-t" de "read" simplifie cette tâche. # Voir "t-out.sh", ci-dessous. # Si vous avez besoin de quelque chose de réellement élégant... #+ pensez à écrire l'application en C ou C++, #+ en utilisant les fonctions de la bibliothèque appropriée, telles que #+ 'alarm' et 'setitimer'. exit 0

Une autre méthode est d'utiliser stty.

Exemple 9-3. Encore une fois, saisie avec délai

#!/bin/bash # timeout.sh # Ecrit par Stephane Chazelas, # et modifié par l'auteur de ce document. INTERVALLE=5 # timeout interval lecture_timedout() { timeout=$1 nomvariable=$2 ancienne_configuration_tty=`stty -g` stty -icanon min 0 time ${timeout}0 eval read $nomvariable # ou simplement read $nomvariable stty "$ancienne_configuration_tty" # Voir la page man de "stty". } echo; echo -n "Quel est votre nom? Vite!" lecture_timedout $INTERVALLE votre_nom # Ceci pourrait ne pas fonctionner sur tous les types de terminaux. # Le temps imparti dépend du terminal (il est souvent de 25,5 secondes). echo if [ ! -z "$votre_nom" ] # Si le nom est entré avant que le temps ne se soit #+ écoulé... then echo "Votre nom est $votre_nom." else echo "Temps écoulé." fi echo # Le comportement de ce script diffère un peu de "timed-input.sh". # A chaque appui sur une touche, le compteur est réinitialisé. exit 0

Peut-être que la méthode la plus simple est d'utiliser l'option -t de read.

Exemple 9-4. read avec délai

#!/bin/bash # t-out.sh (suggestion de "syngin seven") LIMITETEMPS=4 # 4 secondes read -t $LIMITETEMPS variable <&1 echo if [ -z "$variable" ] then echo "Temps écoulé, la variable n'est toujours pas initialisée." else echo "variable = $variable" fi exit 0

$UID

numéro de l'identifiant utilisateur

numéro d'identification de l'utilisateur actuel, comme enregistré dans /etc/passwd

C'est l'identifiant réel de l'utilisateur actuel, même s'il a temporairement endossé une autre identité avec su. $UID est une variable en lecture seule, non sujet au changement à partir de la ligne de commande ou à l'intérieur d'un script, et est la contre partie de l'intégré id.

Exemple 9-5. Suis-je root?

#!/bin/bash # am-i-root.sh: Suis-je root ou non? ROOT_UID=0 # Root a l'identifiant $UID 0. if [ "$UID" -eq "$ROOT_UID" ] # Le vrai "root" peut-il se lever, s'il-vous-plaît? then echo "Vous êtes root." else echo "Vous êtes simplement un utilisateur ordinaire (mais maman vous aime tout autant.)." fi exit 0 # ============================================================= # # Le code ci-dessous ne s'exécutera pas, parce que le script s'est déjà arrêté. # Une autre méthode d'arriver à la même fin: NOM_UTILISATEURROOT=root nomutilisateur=`id -nu` # Ou... nomutilisateur=`whoami` if [ "$nomutilisateur" = "$NOM_UTILISATEURROOT" ] then echo "Vous êtes root." else echo "Vous êtes juste un gars régulier." fi

Voir aussi Exemple 2-2.

Les variables $ENV, $LOGNAME, $MAIL, $TERM, $USER et $USERNAME ne sont pas des variables intégrés à Bash. Elles sont néanmois souvent initialisées comme variables d'environnement dans un des fichiers de démarrage de Bash. $SHELL, le nom du shell de connexion de l'utilisateur, peut être configuré à partir de /etc/passwd ou dans un script d'<< initialisation >>, et ce n'est pas une variable intégrée à Bash. tcsh% echo $LOGNAME bozo tcsh% echo $SHELL /bin/tcsh tcsh% echo $TERM rxvt bash$ echo $LOGNAME bozo bash$ echo $SHELL /bin/tcsh bash$ echo $TERM rxvt

Paramètres de position

$0, $1, $2, etc.

paramètres de positions, passés à partir de la ligne de commande à un script, passés à une fonction, ou initialisés (set) à une variable (voir Exemple 4-5 et Exemple 11-13)

$#

nombre d'arguments sur la ligne de commande [2] ou de paramètres de position (voir Exemple 34-2)

$*

Tous les paramètres de position, vus comme un seul mot

$@

Identique à $*, mais chaque paramètre est une chaîne entre guillemets, c'est-à-dire que les paramètres sont passés de manière intacte, sans interprétation ou expansion. Ceci signifie, entre autres choses, que chaque paramètre dans la liste d'arguments est vu comme un mot séparé.

Exemple 9-6. arglist: Affichage des arguments avec $* et $@

#!/bin/bash # Appelez ce script avec plusieurs arguments, tels que "un deux trois". E_BADARGS=65 if [ ! -n "$1" ] then echo "Usage: `basename $0` argument1 argument2 etc." exit $E_BADARGS fi echo index=1 echo "Liste des arguments avec \"\$*\":" for arg in "$*" # Ne fonctionne pas correctement si "$*" n'est pas entre guillemets. do echo "Arg #$index = $arg" let "index+=1" done # $* voit tous les arguments comme un mot entier. echo "Liste entière des arguments vue comme un seul mot." echo index=1 echo "Liste des arguments avec \"\$@\":" for arg in "$@" do echo "Arg #$index = $arg" let "index+=1" done # $@ voit les arguments comme des mots séparés. echo "Liste des arguments vue comme des mots séparés." echo exit 0

Suite à un shift, $@ contient le reste des paramètres de la ligne de commande, sans le précédent $1, qui a été perdu.

#!/bin/bash # Appelé avec ./script 1 2 3 4 5 echo "$@" # 1 2 3 4 5 shift echo "$@" # 2 3 4 5 shift echo "$@" # 3 4 5 # Chaque "shift" perd le paramètre $1. # "$@" contient alors le reste des paramètres.

Le paramètre spécial $@ trouve son utilité comme outil pour filtrer l'entrée des scripts shell. La construction cat "$@" accepte l'entrée dans un script soit à partir de stdin soit à partir de fichiers donnés en paramètre du script. Voir Exemple 12-17 et Exemple 12-18.

Les paramètres $* et $@ affichent quelque fois un comportement inconsistent et bizarre, suivant la configuration de $IFS.

Exemple 9-7. Comportement de $* et $@ inconsistent

#!/bin/bash # Comportement non prédictible des variables internes Bash "$*" et "$@", #+ suivant qu'elles soient ou non entre guillemets. # Gestion inconsistente de la séparation de mots et des retours chariot. set -- "Premier un" "second" "troisième:un" "" "Cinquième: :un" # Initialise les arguments du script, $1, $2, etc. echo echo 'IFS inchangée, utilisant "$*"' c=0 for i in "$*" # entre guillemets do echo "$((c+=1)): [$i]" # Cette ligne reste identique à chaque instance. # Arguments de echo. done echo --- echo 'IFS inchangée, utilisant $*' c=0 for i in $* # entre guillemets do echo "$((c+=1)): [$i]" done echo --- echo 'IFS inchangée, utilisant "$@"' c=0 for i in "$@" do echo "$((c+=1)): [$i]" done echo --- echo 'IFS inchangée, utilisant $@' c=0 for i in $@ do echo "$((c+=1)): [$i]" done echo --- IFS=: echo 'IFS=":", utilisant "$*"' c=0 for i in "$*" do echo "$((c+=1)): [$i]" done echo --- echo 'IFS=":", utilisant $*' c=0 for i in $* do echo "$((c+=1)): [$i]" done echo --- var=$* echo 'IFS=":", utilisant "$var" (var=$*)' c=0 for i in "$var" do echo "$((c+=1)): [$i]" done echo --- echo 'IFS=":", utilisant $var (var=$*)' c=0 for i in $var do echo "$((c+=1)): [$i]" done echo --- var="$*" echo 'IFS=":", utilisant $var (var="$*")' c=0 for i in $var do echo "$((c+=1)): [$i]" done echo --- echo 'IFS=":", utilisant "$var" (var="$*")' c=0 for i in "$var" do echo "$((c+=1)): [$i]" done echo --- echo 'IFS=":", utilisant "$@"' c=0 for i in "$@" do echo "$((c+=1)): [$i]" done echo --- echo 'IFS=":", utilisant $@' c=0 for i in $@ do echo "$((c+=1)): [$i]" done echo --- var=$@ echo 'IFS=":", utilisant $var (var=$@)' c=0 for i in $var do echo "$((c+=1)): [$i]" done echo --- echo 'IFS=":", utilisant "$var" (var=$@)' c=0 for i in "$var" do echo "$((c+=1)): [$i]" done echo --- var="$@" echo 'IFS=":", utilisant "$var" (var="$@")' c=0 for i in "$var" do echo "$((c+=1)): [$i]" done echo --- echo 'IFS=":", utilisant $var (var="$@")' c=0 for i in $var do echo "$((c+=1)): [$i]" done echo # Essayez ce script avec ksh ou zsh -y. exit 0 # Ce script exemple par Stephane Chazelas, # et légèrement modifié par l'auteur de ce document.

Les paramètres $@ et $* diffèrent seulement lorsqu'ils sont entre des guillemets doubles.

Exemple 9-8. $* et $@ lorsque $IFS est vide

#!/bin/bash # Si $IFS est initialisé, mais vide, # alors "$*" et "$@" n'affiche pas les paramètres de position comme on pourrait # s'y attendre. mecho () # Affiche les paramètres de position. { echo "$1,$2,$3"; } IFS="" # Initialisé, mais vide. set a b c # Paramètres de position. mecho "$*" # abc,, mecho $* # a,b,c mecho $@ # a,b,c mecho "$@" # a,b,c # Le comportement de $* et $@ quand $IFS est vide dépend de la version de # Bash ou sh. # Personne ne peux donc conseiller d'utiliser cette "fonctionnalité" dans un # script. # Merci, S.C. exit 0

Autres paramètres spéciaux

$-

Les options passées au script (en utilisant set). Voir Exemple 11-13.

Ceci était originellement une construction de ksh adoptée dans Bash, et malheureusement elle ne semble pas fonctionner de façon fiable dans les scripts Bash. Une utilité possible pour ceci est d'avoir un script testant lui-même s'il est interactif.

$!

PID (identifiant du processus) du dernier job ayant fonctionné en tâche de fond

$_

Variable spéciale initialisée au dernier argument de la dernièr commande exécutée.

Exemple 9-9. variable tiret bas

#!/bin/bash echo $_ # /bin/bash # Simple appel de /bin/bash pour lancer ce script. du >/dev/null # Donc pas de sortie des commandes echo $_ # du ls -al >/dev/null # Donc pas de sortie des commandes echo $_ # -al (dernier argument) : echo $_ # :

$?

Code de sortie d'une commande, fonction, ou du script lui-même (voir Exemple 23-3)

$$

Identifiant du processus du script lui-même. La variable $$ trouve fréquemment son utilité dans les scripts pour construire des noms de fichiers temporaires << uniques >> (voir Exemple A-14, Exemple 30-6, Exemple 12-23 et Exemple 11-23). Ceci est généralement plus simple que d'appeler mktemp.