Guide avancé d'écriture des scripts Bash:
Précédent	Chapitre 16. Redirection d'E/S (entrées/sorties)	Suivant

16.2. Rediriger les blocs de code

Les blocs de code, comme les boucles while, until et for, voire même les blocs de test if/then peuvent aussi incorporer une redirection de stdin. Même une fonction peut utiliser cette forme de redirection (voir Exemple 23-7). L'opérateur < à la fin du bloc de code accomplit ceci.

Exemple 16-4. Boucle while redirigée

#!/bin/bash

if [ -z "$1" ]
then
  Fichier=noms.donnees       # par défaut, si aucun fichier n'est spécifié.
else
  Fichier=$1
fi  
#+ Fichier=${1:-noms.donnees}
#  peut remplacer le test ci-dessus (substitution de paramètres).

compteur=0

echo

while [ "$nom" != Smith ]  # Pourquoi la variable $name est-elle entre guillemets?
do
  read nom                 # Lit à partir de $Fichier, plutôt que de stdin.
  echo $nom
  let "compteur += 1"
done <"$Fichier"           # Redirige stdin vers le fichier $Fichier. 
#    ^^^^^^^^^^^^

echo; echo "$compteur names read"; echo

#  Notez que dans certains vieux langages de scripts de shells,
#+ la boucle redirigée pourrait tourner dans un sous-shell.
# Du coup, $compteur renverrait 0, la valeur initialisée en dehors de la boucle.
#  Bash et ksh évitent de lancer un sous-shell autant que possible,
#+ de façon à ce que ce script, par exemple, tourne correctement.
#
# Merci à Heiner Steven pour nous l'avoir indiqué.

exit 0

Exemple 16-5. Autre forme de boucle while redirigée

#!/bin/bash

# Ceci est une forme alternative au script précédent.

#  Suggéré par Heiner Steven
#+ comme astuce dans ces situations où une boucle de redirection est lancé
#+ comme un sous-shell, et donc que les variables à l'intérieur de la boucle
#+ ne conservent pas leurs valeurs une fois la boucle terminée.


if [ -z "$1" ]
then
  Fichier=noms.donnees     # Par défaut, si aucun fichier spécifié.
else
  Fichier=$1
fi  


exec 3<&0                  # Sauve stdin sur le descripteur de fichier 3.
exec 0<"$Fichier"          # Redirige l'entrée standard.

compteur=0
echo


while [ "$nom" != Smith ]
do
  read nom               # Lit à partir du stdin redirigé ($Fichier).
  echo $nom
  let "compteur += 1"
done <"$Fichier"         # La boucle lit à partir du fichier $Fichier. 
#    ^^^^^^^^^^^^


exec 0<&3                 # Restaure l'ancien stdin.
exec 3<&-                 # Ferme le temporaire fd 3.

echo; echo "$compteur noms lus"; echo

exit 0

Exemple 16-6. Boucle until redirigée

#!/bin/bash
# Identique à l'exemple précédent, mais avec une boucle "until".

if [ -z "$1" ]
then
  Fichier=noms.donnees  # Par défaut, si aucun nom de fichier n'est spécifié.
else
  Fichier=$1
fi  

# while [ "$nom" != Smith ]
until [ "$nom" = Smith ]     # Modification de  !=  en =.
do
  read nom                   # Lit à partir de $Fichier, plutôt que de stdin.
  echo $nom
done <"$Fichier"             # Redirige stdin vers le fichier $Fichier. 
#    ^^^^^^^^^^^^

# Même résultats qu'avec la boucle "while" du précédent exemple.

exit 0

Exemple 16-7. Boucle for redirigée

#!/bin/bash

if [ -z "$1" ]
then
  Fichier=noms.donnees          # Par défaut, si aucun fichier n'est spécifié.
else
  Fichier=$1
fi  

compteur_lignes=`wc $Fichier | awk '{ print $1 }'`
#           Nombre de lignes du fichier cible.
#
#  Très peu naturel, néanmoins cela montre qu'il est possible de rediriger
#+ stdin à l'intérieur d'une boucle "for"...
#+ si vous êtes assez intelligent.
#
# Une autre façon plus concise     compteur_lignes=$(wc < "$Fichier")


for nom in `seq $compteur_lignes`  # Rappelez-vous que "seq" affiche une séquence de nombres.
# while [ "$nom" != Smith ]   --   plus compliqué qu'une boucle "while" --
do
  read nom                    # Lit à partir de $Fichier, plutôt que de stdin.
  echo $nom
  if [ "$nom" = Smith ]       # A besoin de tout ce bagage supplémentaire ici.
  then
    break
  fi  
done <"$Fichier"              # Redirige stdin vers le fichier $Fichier. 
#    ^^^^^^^^^^^^

exit 0

Nous pouvons modifier le précédent exemple pour aussi rediriger la sortie de la boucle.

Exemple 16-8. Rediriger la boucle for (à la fois stdin et stdout)

#!/bin/bash

if [ -z "$1" ]
then
  Fichier=noms.donnees # Par défaut, si aucun fichier n'est spécifié.
else
  Fichier=$1
fi  

FichierSauvegarde=$Fichier.nouveau # Fichier où sauvegarder les résultats.
NomFinal=Jonah                     # Nom par lequel terminer la lecture.

nb_lignes=`wc $Fichier | awk '{ print $1 }'`  # Nombre de lignes du fichier cible.


for nom in `seq $nb_lignes`
do
  read nom
  echo "$nom"
  if [ "$nom" = "$NomFinal" ]
  then
    break
  fi  
done < "$Fichier" > "$FichierSauvegarde"  # Redirige stdin dans $Fichier,
#    ^^^^^^^^^^^^^^^^^^^^^^^^^^^       et sauvegarde dans le fichier.

exit 0

Exemple 16-9. Redirigé un test if/then

#!/bin/bash

if [ -z "$1" ]
then
  Fichier=noms.donnees   #  Valeur par défaut, si aucun nom de fichier n'est
                         #+ spécifié.
else
  Fichier=$1
fi  

VRAI=1

if [ "$VRAI" ]          # if true    et   if :   fonctionnent aussi.
then
 read nom
 echo $nom
fi <"$Fichier"
#  ^^^^^^^^^^^^

# Lit seulement la première ligne du fichier.
#  Un test "if/then" n'a aucun moyen de faire une itération sauf si il est
#+ intégré dans une boucle.

exit 0

Exemple 16-10. Fichier de données << nom.données >> pour les exemples ci-dessus

Aristotle
Belisarius
Capablanca
Euler
Goethe
Hamurabi
Jonah
Laplace
Maroczy
Purcell
Schmidt
Semmelweiss
Smith
Turing
Venn
Wilson
Znosko-Borowski

#  This is a data file for
#+ "redir2.sh", "redir3.sh", "redir4.sh", "redir4a.sh", "redir5.sh".

Rediriger stdout d'un bloc de code a le même effet que den sauver la sortie dans un fichier. Voir Exemple 3-2.

Les documents en ligne sont un cas spécial pour la redirection de blocs de code.

Il existe aussi d'autres moyens de générer des nombres pseudo aléatoires dans un script. Awk propose une façon agréable de le faire.

Le comportement de \ est dicté par son "auto-échappement", sa mise entre guillemets ou son apparition dans une substitution de commandes ou dans un document en ligne.
# Simple échappement et mise entre guillemets echo \z # z echo \\z # \z echo '\z' # \z echo '\\z' # \\z echo "\z" # \z echo "\\z" # \z # Substitution de commandes echo `echo \z` # z echo `echo \\z` # z echo `echo \\\z` # \z echo `echo \\\\z` # \z echo `echo \\\\\\z` # \z echo `echo \\\\\\\z` # \\z echo `echo "\z"` # \z echo `echo "\\z"` # \z # Document en ligne cat <<EOF \z EOF # \z cat <<EOF \\z EOF # \z # Ces exemples ont été donnés par Stéphane Chazelas.

Les élements d'une chaîne de caractères affectée à une variable peuvent être échappés, mais le caractère d'échappement seul ne peut être affecté à une variable.
variable=\ echo "$variable" # Ne fonctionne pas et donne le message d'erreur : # test.sh: : command not found # Un échappement seul ne peut être affecté correctement à une variable. # # Ce qui arrive ici est que "\" échappe le saut de ligne et #+ l'effet est variable=echo "$variable" #+ affectation invalide de variable variable=\ 23skidoo echo "$variable" # 23skidoo # Ça fonctionne car la deuxième ligne est une affectation #+ valide de variable. variable=\ # \^ échappement suivi d'un espace echo "$variable" # espace variable=\\ echo "$variable" # \ variable=\\\ echo "$variable" # Ne fonctionnera pas et donne le message d'erreur : # test.sh: \: command not found # # La première séquence d'échappement échappe la deuxième, mais la troisième est laissée #+ seule avec le même résultat que dans le premier exemple ci-dessus. variable=\\\\ echo "$variable" # \\ # Deuxième et quatrième séquences d'échappement # Ça marche.

Échapper un espace peut empêcher la séparation de mots dans une liste d'arguments pour une commande.

liste_fichiers="/bin/cat /bin/gzip /bin/more /usr/bin/less /usr/bin/emacs-20.7"
# Liste de fichiers comme argument(s) d'une commande.

# On demande de et tout lister, avec deux fichiers en plus.
ls -l /usr/X11R6/bin/xsetroot /sbin/dump $file_list

echo "-------------------------------------------------------------------------"

# Qu'arrive-t'il si nous échappons un ensemble d'espaces ?
ls -l /usr/X11R6/bin/xsetroot\ /sbin/dump\ $file_list
# Erreur: les trois premiers fichiers sont concaténés en un seul argument pour 'ls -l'
#        parce que les deux espaces échappés empêchent la séparation des arguments (mots).

L'échappement permet également d'écrire une commande sur plusieurs lignes. Normalement, chaque ligne séparée constitue une commande différente, mais un échappement à la fin d'une ligne échappe le caractère de saut de ligne, et la séquence de la commande continue sur la ligne suivante.

(cd /source/repertoire && tar cf - . ) | \
(cd /dest/repertoire && tar xpvf -)
# Répétant la commande de copie de répertoires d'Alan Cox, mais séparée en deux lignes
# pour accroître la lisibilité.

# Comme alternative :
tar cf - -C /source/directory . |
tar xpvf - -C /dest/directory
# Voir note ci-dessous.
# (Merci, Stéphane Chazelas.)

echo "foo
bar" 
#foo
#bar

echo

echo 'foo
bar'    # Pas encore de différences.
#foo
#bar

echo

echo foo\
bar     # Saut de ligne échappé.
#foobar

echo

echo "foo\
bar"     #  Pareil ici, car \ toujours interpreté comme un échappement à l'intérieur de
         #+ guillemets faibles.
#foobar

echo

echo 'foo\
bar'     # Le caractère d'échappement \ est pris littéralement à cause des guillemets forts.
#foor\
#bar

# Exemples suggérés par Stéphane Chazelas.

Notes

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
Utiliser exec	Niveau supérieur	Applications

Précédent	Sommaire	Suivant
Références indirectes aux variables	Niveau supérieur	La construction en double parenthèse

Précédent	Sommaire	Suivant
Types spéciaux de variables	Niveau supérieur	Sortie et code de sortie (ou d'état)

Précédent	Sommaire	Suivant
Manipuler les chaînes de caractères	Niveau supérieur	Typer des variables: declare ou typeset

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