Guide avancé d'écriture des scripts Bash:
Précédent		Suivant

Guide avancé d'écriture des scripts Bash:

Chapitre 25. Constructeurs de listes

Les constructions de << liste and >> et de << liste or >> apportent un moyen de réaliser un certain nombre de commandes consécutivement. Elles peuvent remplacer efficacement des if/then complexes, voire imbriqués ou même des instructions case.

Chaîner des commandes

liste and

commande-1 && commande-2 && commande-3 && ... commande-n
Chaque commande s'exécute à son tour à condition que la dernière commande ait renvoyé un code de retour true (zéro). Au premier retour false (différent de zéro), la chaîne de commande s'arrête (la première commande renvoyant false est la dernière à être exécutée).

Exemple 25-1. Utiliser une << liste and >> pour tester des arguments de la ligne de commande

#!/bin/bash
# "liste et"

if [ ! -z "$1" ] && echo "Argument #1 = $1" && [ ! -z "$2" ] && echo "Argument #2 = $2"
then
  echo "Au moins 2 arguments passés au script."
  # Toute la commande chaînée doit être vraie.
else
  echo "Moins de 2 arguments passés au script."
  # Au moins une des commandes de la chaîne a renvoyé faux.
fi  
# Notez que "if [ ! -z $1 ]" fonctionne, mais que son supposé équivalent,
#  if [ -n $1 ] ne fonctionne pas. Néanmoins, mettre entre guillemets corrige
#  cela: if [ -n "$1" ] fonctionne.  Attention!
# Il est mieux de toujours mettre entre guillemets les variables testées.


# Ceci accomplit la même chose, en utilisant une instruction if/then pure.
if [ ! -z "$1" ]
then
  echo "Argument #1 = $1"
fi
if [ ! -z "$2" ]
then
  echo "Argument #2 = $2"
  echo "Au moins 2 arguments passés au script."
else
  echo "Moins de 2 arguments passés au script."
fi
# C'est plus long et moins élémgant que d'utiliser une "liste et".


exit 0

Exemple 25-2. Un autre test des arguments de la ligne de commande en utilisant une << liste and >>

#!/bin/bash

ARGS=1        # Nombre d'arguments attendus.
E_BADARGS=65  # Valeur de sortie si un nombre incorrect d'arguments est passé.

test $# -ne $ARGS && echo "Usage: `basename $0` $ARGS argument(s)" && exit $E_BADARGS
# Si condition-1 vrai (mauvais nombre d'arguments passés au script),
# alors le reste de la ligne s'exécute et le script se termine.

# La ligne ci-dessous s'exécute seulement si le test ci-dessus a échoué.
echo "Bon nombre d'arguments passés à ce script."

exit 0

# Pour vérifier la valeur de sortie, faites un "echo $?" après la fin du script.

Bien sûr, une liste and peut aussi initialiser des variables à une valeur par défaut.
arg1=$@ # Initialise $arg1 aux arguments de la ligne de commande, s'il y en a. [ -z "$arg1" ] && arg1=DEFAUT # Initialise à DEFAUT si non spécifié sur la ligne de commande.

liste or

commande-1 || commande-2 || commande-3 || ... commande-n
Chaque commande s'exécute à son tour aussi longtemps que la commande précédente renvoie false. Au premier retour true, la chaîne de commandes s'arrête (la première commande renvoyant true est la dernière à être exécutée). C'est évidemment l'inverse de la << liste and >>.

Exemple 25-3. Utiliser des << listes or >> en combinaison avec une << liste and >>

#!/bin/bash

#  delete.sh, utilitaire pas-si-stupide de suppression de fichier.
#  Usage: delete nomfichier

E_MAUVAISARGS=65

if [ -z "$1" ]
then
  echo "Usage: `basename $0` nomfichier"
  exit $E_MAUVAISARGS  # Pas argument? On sort.
else  
  fichier=$1           # Initialisation du nom du fichier.
fi  


[ ! -f "$fichier" ] && echo "Le fichier \"$fichier\" introuvable. \
Je refuse peureusement d'effacer un fichier inexistant."
# LISTE ET, pour donner le message d'erreur si le fichier est absent.
# Notez que le message echo continue sur la seconde ligne avec un échappement.

[ ! -f "$file" ] || (rm -f $file; echo "Fichier \"$file\" supprimé.")
# LISTE OU, pour supprimer le fichier si présent.

# Notez la logique inversée ci-dessus.
# La LISTE-ET s'exécute si vrai, la LISTE-OU si faux.

exit 0

Si la première commande dans une << liste or >> renvoie true, elle sera exécutée.

Le code de sortie d'une liste and ou d'une liste or correspond au code de sortie de la dernière commande exécutée.

Les combinaisons intelligentes de listes << and >> et << or >> sont possibles, mais la logique pourrait rapidement devenir difficile et nécessiter des phases de déboguages intensives.
false && true || echo false # false # Même résultat avec ( false && true ) || echo false # false # Mais *pas* false && ( true || echo false ) # (rien ne s'affiche) # Notez le groupement de gauche à droite et une évaluation des instructions, # car les opérateurs logiques "&&" et "||" ont la même priorité. # Il est mieux d'éviter de telles complexités, sauf si vous savez ce que vous # faites. # Merci, S.C.

Voir Exemple A-8 et Exemple 7-4 pour des illustrations de l'utilisation de listes and / or pour tester des variables.

#!/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

# *** 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 ***

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

#!/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

#!/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

#!/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

#!/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

#!/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

#!/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

#!/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

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

#!/bin/bash exec echo "Je sors \"$0\"." # Sortie du script ici. # ---------------------------------- # Les lignes suivantes ne s'exécutent jamais. echo "Cet echo ne sera jamais exécuté." exit 99 # Ce script ne sortira jamais par ici. # Vérifier le code de sortie après l'exécution du #+ du script avec un 'echo $?'. # Cela ne sera *pas* 99.

#!/bin/bash # self-exec.sh echo echo "Cette ligne apparaît UNE FOIS dans le script, cependant elle continue à s'afficher." echo "Le PID de cette instance du script est toujours $$." # Démontre qu'un sous-shell n'est pas un processus fils. echo "==================== Tapez Ctl-C pour sortir ====================" sleep 1 exec $0 # Lance une autre instance du même script remplaçant le précédent. echo "Cette ligne ne s'affichera jamais!" # Pourquoi pas? exit 0

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
Alias	Niveau supérieur	Tableaux

[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.

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

[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.

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