Guide avancé d'écriture des scripts Bash:
Précédent	Chapitre 4. Introduction aux variables et aux paramètres	Suivant

4.4. Types spéciaux de variables

variables locales

des variables visibles seulement à l'intérieur d'un bloc de code ou d'une fonction (voir aussi variables locales dans fonctions)

variables d'environnement

variables qui affectent le comportement du shell et de l'interface utilisateur

Dans un contexte plus général, chaque processus a un << environnement >>, c'est-à-dire un groupe de variables contenant l'information à laquelle pourrait faire référence le processus. En ce sens, le shell se comporte comme n'importe quel processus.

Chaque fois qu'un shell démarre, il crée les variables shell correspondantes à ses propres variables d'environnement. Mettre à jour ou ajouter de nouvelles variables force le shell à mettre à jour son environnement, et tous les processus fils (les commandes qu'il exécute) héritent de cet environnement.

L'espace alloué à l'environnement est limité. Créer trop de variables d'environnement ou une variable d'environnement qui utilise un espace excessif peut causer des problèmes.

bash$ eval "`seq 10000 | sed -e 's/.*/export var&=ZZZZZZZZZZZZZZ/'`" bash$ du bash: /usr/bin/du: Argument list too long

(Merci, S. C. pour la clarification, et pour avoir fourni l'exemple ci-dessus.)

Si un script déclare des variable d'environnement, il faut qu'elles soient << exportées >>, c'est-à-dire, rapportées à l'environnement local du script. C'est la fonction de la commande export .

Un script peut exporter des variables seulement aux processus fils, c'est-à-dire seulement aux commandes ou processus que ce script particulier initie. Un script invoqué depuis la ligne de commande ne peux pas ré-exporter des variables à destination de l'environnement de la ligne de commande dont il est issu. Des processus fils ne peuvent pas ré exporter de variables aux processus parents qui les ont fait naître.

---

paramètres positionnels

les arguments passés aux scripts depuis la ligne de commande - $0, $1, $2, $3... $0 est le nom du script lui-même, $1 est le premier argument, $2 le second, $3 le troisième, et ainsi de suite. [1] Après $9, les arguments doivent être entourés d'accolades, par exemple, ${10}, ${11}, ${12}.

Les variables spéciales $* et $@ représentent tous les paramètres positionnels.

Exemple 4-5. Paramètres positionnels

#!/bin/bash

# Appelez ce script avec au moins 10 paramètres, par exemple
# ./scriptname 1 2 3 4 5 6 7 8 9 10
MINPARAMS=10

echo

echo "Le nom de ce script est \"$0\"."
# Ajoutez ./ pour le répertoire courant.
echo "Le nom de ce script est \"`basename $0`\"."
# Supprime le chemin du script (voir 'basename')

echo

if [ -n "$1" ]              # La variable testée est entre guillemets.
then
 echo "Le paramètre #1 est $1"  # Nous avons besoin des guillemets pour échapper
fi 

if [ -n "$2" ]
then
 echo "Le paramètre #2 est $2"
fi 

if [ -n "$3" ]
then
 echo "Le paramètre #3 est $3"
fi 

# ...


if [ -n "${10}" ]  #  Les paramètres supérieures à $9 doivent être compris entre
                   #+ accolades.
then
 echo "Le paramètre #10 est ${10}"
fi 

echo "-----------------------------------"
echo "Tous les paramètres de la ligne de commande sont: "$*""

if [ $# -lt "$MINPARAMS" ]
then
  echo
  echo "Donnez-moi au moins $MINPARAMS arguments en ligne de commande!"
fi  

echo

exit 0

La notation avec accolades pour les paramètres positionnels permet de référencer plutôt simplement le dernier argument passé à un script sur la ligne de commande. Ceci requiert également le référencement indirect.

args=$# # Nombre d'arguments passés. dernarg=${!args} # Noter que dernarg=${!$#} ne fonctionne pas.

Certains scripts peuvent effectuer différentes opérations suivant le nom sous lequel ils sont invoqués. Pour que cela fonctionne, le script a besoin de tester $0, le nom sous lequel il a été invoqué. Il doit aussi y avoir des liens symboliques vers tous les différents noms du script.

Si un script attend un paramètre en ligne de commande mais qu'il est invoqué sans, cela peut causer une affectation à valeur nulle, généralement un résultat non désiré. Une façon d'empêcher cela est d'ajouter un caractère supplémentaire des deux côtés de l'instruction d'affectation utilisant le paramètre positionnel attendu.

variable1_=$1_
# Cela préviendra l'erreur, même si le paramètre positionnel est absent.

argument_critique01=$variable1_

# Le caractère supplémentaire peut être retiré plus tard , si besoin est, comme ceci.
variable1=${variable1_/_/}   # Effets de bord seulement si $variable1_ commence par "_".
# Ceci utilise un des patrons de substitution de paramètres discustés au Chapitre 9.
# Laisser tout simplement le motif de remplacement aboutit à une destruction.

# Une façon plus directe de résoudre ce problème est de simplement tester 
#+ si le paramètre postionnel attendu a bien été passé.
if [ -z $1 ]
then
  exit $PARAM_POS_MANQUANT
fi

---

Exemple 4-6. wh, recherche d'un nom de domaine avec whois

#!/bin/bash

# Fait une recherche 'whois nom-domaine' sur l'un des trois serveurs:
#                    ripe.net, cw.net, radb.net

# Placez ce script, nommé 'wh' dans /usr/local/bin

# Requiert les liens symboliques:
# ln -s /usr/local/bin/wh /usr/local/bin/wh-ripe
# ln -s /usr/local/bin/wh /usr/local/bin/wh-cw
# ln -s /usr/local/bin/wh /usr/local/bin/wh-radb


if [ -z "$1" ]
then
  echo "Usage: `basename $0` [nom-domaine]"
  exit 65
fi

case `basename $0` in
# Vérifie le nom du script et appele le bon serveur
    "wh"     ) whois $1@whois.ripe.net;;
    "wh-ripe") whois $1@whois.ripe.net;;
    "wh-radb") whois $1@whois.radb.net;;
    "wh-cw"  ) whois $1@whois.cw.net;;
    *        ) echo "Usage: `basename $0` [nom-domaine]";;
esac 

exit 0

---

La commande shift réassigne les paramètres positionnels, ce qui a le même effet que de les déplacer vers la gauche d'un rang.

$1 <--- $2, $2 <--- $3, $3 <--- $4, etc.

Le vieux $1 disparaît,mais $0 (le nom du script) ne change pas. Si vous faites usage d'un grand nombre de paramètres positionnels dans un script, shift vous permet d'accèder à ceux au-delà de 10, bien que la notation notation {accolades} le permette également.

Exemple 4-7. Utiliser shift

#!/bin/bash
# Utilisation de 'shift' pour voir tous les paramètres de position.

#  Nommez ce script quelque chose comme shft,
#+ et appelez-le avec quelques paramètres, par exemple
#          ./shft a b c def 23 skidoo

until [ -z "$1" ]  # Jusqu'à ne plus avoir de paramètres...
do
  echo -n "$1 "
  shift
done

echo               # Retour chariot supplémentaire.

exit 0

La commande shift fonctionne aussi avec les paramètres passés à une fonction. Voir Exemple 34-10.

Notes

opérateurs logiques

&&

et (logique)

if [ $condition1 ] && [ $condition2 ] # Identique à: if [ $condition1 -a $condition2 ] # Renvoie vrai si à la fois condition1 et condition2 sont vraies... if [[ $condition1 && $condition2 ]] # Fonctionne aussi. # Notez que l'opérateur && n'est pas autorisé dans une construction [ ... ].

&& peut aussi, suivant le contexte, être utilisé dans une liste and pour concaténer des commandes.

||

ou (logique)

if [ $condition1 ] || [ $condition2 ] # Identique à: if [ $condition1 -o $condition2 ] # Renvoie vrai si soit condition1 soit condition2 est vraie... if [[ $condition1 || $condition2 ]] # Fonctionne aussi. # Notez que l'opérateur || n'est pas autorisé dans des constructions [ ... ].

Bash teste l'état de sortie de chaque instruction liée avec un opérateur logique.

Exemple 8-3. Tests de condition composés en utilisant && et ||

#!/bin/bash

a=24
b=47

if [ "$a" -eq 24 ] && [ "$b" -eq 47 ]
then
  echo "Le test #1 a réussi."
else
  echo "Le test #1 a échoué."
fi

# ERREUR:  si [ "$a" -eq 24 && "$b" -eq 47 ]
#          essaie d'exécuter ' [ "$a" -eq 24 '
#          et échoue à trouver le ']' correspondant.
#
#    si [[ $a -eq 24 && $b -eq 24 ]]   fonctionne
#    (Le "&&" a une signification différente en ligne 17 qu'en ligne 6.)
#    Merci, Stephane Chazelas.


if [ "$a" -eq 98 ] || [ "$b" -eq 47 ]
then
  echo "Le test #2 a réussi."
else
  echo "Le test #2 a échoué."
fi


#  Les options -a et -o apportent une alternative au test de la condition composée.
#  Merci à Patrick Callahan pour avoir remarqué ceci.


if [ "$a" -eq 24 -a "$b" -eq 47 ]
then
  echo "Le test #3 a réussi."
else
  echo "Le test #3 a échoué."
fi


if [ "$a" -eq 98 -o "$b" -eq 47 ]
then
  echo "Le test #4 a réussi."
else
  echo "Le test #4 a échoué."
fi


a=rhino
b=crocodile
if [ "$a" = rhino ] && [ "$b" = crocodile ]
then
  echo "Le test #5 a réussi."
else
  echo "Le test #5 a échoué."
fi

exit 0

Les opérateurs && et || trouvent aussi leur utilité dans un contexte arithmétique.

bash$ echo $(( 1 && 2 )) $((3 && 0)) $((4 || 0)) $((0 || 0)) 1 0 1 0

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.

Notes

Un exec sert aussi à réaffecter les descripteurs de fichiers.exec <fichier-zzz remplace stdin par le fichier fichier-zzz (voir Exemple 16-1).

Commandes

true

Une commande qui renvoie un succès (zéro) comme état de sortie, mais ne fait rien d'autre.

# Boucle sans fin while true # alias pour ":" do operation-1 operation-2 ... operation-n # A besoin d'un moyen pour sortir de la boucle. done

false

Une commande qui renvoit un état de sortie correspondant à un échec, mais ne fait rien d'autre.

# Fausse boucle while false do # Le code suivant ne sera pas exécuté. operation-1 operation-2 ... operation-n # Rien ne se passe! done

type [cmd]

Identique à la commande externe which, type cmd donne le chemin complet vers << cmd >>. Contrairement à which, type est une commande intégrée à Bash. L'option -a est très utile pour que type identifie des mots clés et des commandes internes, et localise aussi les commandes système de nom identiques.

bash$ type '[' [ is a shell builtin bash$ type -a '[' [ is a shell builtin [ is /usr/bin/[

hash [cmds]

Enregistre le chemin des commandes spécifiées (dans une table de hachage du shell), donc le shell ou le script n'aura pas besoin de chercher le $PATH sur les appels futurs à ces commandes. Quand hash est appelé sans arguments, il liste simplement les commandes qui ont été hachées. L'option -r réinitialise la table de hachage.

help

help COMMANDE cherche un petit résumé sur l'utilisation de la commande COMMANDE intégrée au shell. C'est l'équivalent de whatis, pour les commandes intégrées.

bash$ help exit exit: exit [n] Exit the shell with a status of N. If N is omitted, the exit status is that of the last command executed.

Précédent	Sommaire	Suivant
Les variables Bash ne sont pas typées	Niveau supérieur	Guillemets

Précédent	Sommaire	Suivant
Opérations et thèmes relatifs	Niveau supérieur	Constantes numériques

Précédent	Sommaire	Suivant
Boucles et branchements	Niveau supérieur	Boucles imbriquées

Précédent	Sommaire	Suivant
Les variables revisitées	Niveau supérieur	Manipuler les chaînes de caractères

Précédent	Sommaire	Suivant
Tests et branchements	Niveau supérieur	Commandes de contrôle des jobs

[1]	Le pid du script en cours est `$$`, bien sûr.
[2]	Les mots << argument >> et << paramètre >> sont souvent utilisés sans distinction. Dans le contexte de ce document, ils ont exactement la même signification, celle d'une variable passée à un script ou à une fonction.

[1]	Une exception à ceci est la commande time, listée dans la documentation Bash officielle en tant que mot clé.
[2]	Une option est un argument agissant comme un indicateur, changeant les comportements du script de façon binaire. L'argument associé avec une option particulière indique le comportement que l'option active ou désactive.