Guide avancé d'écriture des scripts Bash:
PrécédentChapitre 10. Boucles et branchementsSuivant

10.1. Boucles

Une boucle est un bloc de code qui répète une liste de commandes aussi longtemps que la condition de contrôle de la boucle est vraie.

boucles for

for (in)

C'est la construction de boucle de base. Elle diffère de façon significative de sa contre partie en C.

for arg in [liste]
do
 commande(s)...
done

Note

A chaque passage dans la boucle, arg prend successivement la valeur de toutes les variables de la liste.

for arg in "$var1" "$var2" "$var3" ... "$varN"  
# Lors du tour 1 de la boucle, $arg = $var1	    
# Lors du tour 2 de la boucle, $arg = $var2	    
# Lors du tour 3 de la boucle, $arg = $var3	    
# ...
# Lors du tour N de la boucle, $arg = $varN

#  Les arguments dans [liste] sont mis entre guillemets pour empêcher une
#+ possible séparation des mots.

L'argument liste peut contenir des caractères joker.

Si do est sur la même ligne que for, il est impératif d'avoir un point virgule après la liste.

for arg in [liste] ; do

Exemple 10-1. Des boucles for simples

#!/bin/bash
# Liste les planètes.

for planete in Mercure Vénus Terre Mars Jupiter Saturne Uranus Neptune Pluton
do
  echo $planete
done

echo

# La 'liste' entière entourée par des guillemets crée une variable simple.
for planete in "Mercure Vénus Terre Mars Jupiter Saturne Uranus Neptune Pluton"
do
  echo $planete
done

exit 0

Note

Chaque élément de la [liste] peut contenir de multiples paramètres. C'est utile pour travailler sur des paramètres en groupe. Dans de tels cas, utilisez la commande set (voir Exemple 11-13) pour forcer l'analyse de chaque élément de la [liste] et l'affectation de chaque composant aux paramètres positionels.

Exemple 10-2. Boucle for avec deux paramètres dans chaque élément de la [liste]

#!/bin/bash
# Planètes revisitées.

# Associe le nom de chaque planète à sa distance du soleil.

for planete in "Mercure 36" "Vénus 67" "Terre 93"  "Mars 142" "Jupiter 483"
do
  set -- $planete  #  Analyse la variable "planete" et initialise les paramètres
                   #+ de position.
  #  Le "--" empêche de mauvaises surprises si $planete est nul ou commence avec
  #+ un tiret.

  #  Il peut être utile de sauvegarder les paramètres de position originaux, car
  #+ ils seront écrasés.
  # Une façon de le faire est d'utiliser un tableau,
  #        parametres_originaux=("$@")

  echo "$1		$2.000.000 miles du soleil"
  #-------deux tabulations---concatènent les zéros dans le paramètre $2
done

# (Merci, S.C., pour les clarifications supplémentaires.)

exit 0

Une variable peut fournir la [liste] dans une boucle for.

Exemple 10-3. Fileinfo: opérer sur une liste de fichiers contenue dans une variable

#!/bin/bash
# fileinfo.sh

FICHIERS="/usr/sbin/privatepw
/usr/sbin/pwck
/usr/sbin/go500gw
/usr/bin/fakefile
/sbin/mkreiserfs
/sbin/ypbind"   # Liste de fichiers qui vous intéressent.
                # Envoyez-les dans un fichier quelconque, /usr/bin/fauxfichier.

echo

for fichier in $FILES
do

  if [ ! -e "$fichier" ]       # Vérifie si le fichier existe.
  then
    echo "$fichier n'existe pas."; echo
    continue                # Au suivant.
  fi

  ls -l $fichier | awk '{ print $9 "         taille: " $5 }' # Affiche 2 champs.
  whatis `basename $fichier`   # Informations sur le fichier.
  echo
done  

exit 0

La [liste] dans une boucle for peut contenir un remplacement des noms de fichier, c'est-à-dire utiliser des jokers pour l'expansion de noms de fichiers.

Exemple 10-4. Agir sur des fichiers à l'aide d'une boucle for

#!/bin/bash
# list-glob.sh: Générer une [liste] dans une boucle for en utilisant "globbing".

echo

for fichier in *
do
  ls -l "$fichier"  # Liste tous les fichiers de $PWD (répertoire courant).
  # Rappelez-vous que le caractère joker "*" correspond à chaque nom de fichier,
  # néanmoins, lors du "globbing", il ne récupère pas les fichier commençant
  # par un point.

  # Si le modèle ne correspond à aucun fichier, il s'étend à lui-même. Pour
  # empêcher ceci, utilisez l'option nullglob
  # (shopt -s nullglob).
  # Merci, S.C.
done

echo; echo

for fichier in [jx]*
do
  rm -f $fichier    # Supprime seulement les fichiers commençant par un "j" ou
                    # un "x" dans $PWD.
  echo "Suppression du fichier \"$fichier\"".
done

echo

exit 0

Omettre la partie in [liste] d'une boucle for fait en sorte que la boucle opère sur $@, la liste des arguments donnés sur la ligne de commande du script. Une illustration particulièrement intelligente de ceci est Exemple A-17.

Exemple 10-5. in [liste] manquant dans une boucle for

#!/bin/bash

# Appeler à la fois avec et sans arguments, et voir ce que cela donne.

for a
do
 echo -n "$a "
done

#  La 'liste' est manquante, donc la boucle opère sur '$@'
#+ (la liste d'arguments sur la ligne de commande, incluant les espaces blancs).

echo

exit 0

Il est possible d'utiliser la substitution de commandes pour générer la [liste] d'une boucle for. Voir aussi Exemple 12-39, Exemple 10-10 et Exemple 12-33.

Exemple 10-6. Générer la [liste] dans une boucle for avec la substitution de commandes

#!/bin/bash
# Une boucle for avec une [liste] générée par une substitution de commande.

NOMBRES="9 7 3 8 37.53"

for nombre in `echo $NOMBRE`  # for nombre in 9 7 3 8 37.53
do
  echo -n "$nombre "
done

echo 
exit 0

Voici un exemple un peu plus complexe de l'utilisation de la substitution de commandes pour créer la [liste].

Exemple 10-7. Un remplaçant de grep pour les fichiers binaires

#!/bin/bash
#  bin-grep.sh: Trouve les chaînes de caractères correspondantes dans un fichier
#+ binaire.

# Un remplacement de "grep" pour les fichiers binaires.
# Similaire par son effet à "grep -a"

E_BADARGS=65
E_NOFILE=66

if [ $# -ne 2 ]
then
  echo "Usage: `basename $0` chaine nomfichier"
  exit $E_BADARGS
fi

if [ ! -f "$2" ]
then
	echo "Le fichier \"$2\" n'existe pas."
  exit $E_NOFILE
fi  


for word in $( strings "$2" | grep "$1" )
#  La commande "strings" liste les chaînes de caractères dans les fichiers
#+ binaires.
# Sortie envoyée via un tube dans "grep", qui cherche la chaîne désirée.
do
  echo $word
done

#  Comme S.C. l'a indiqué, la boucle for ci-dessus pourrait être remplacée avec
#+ la chaîne
#    strings "$2" | grep "$1" | tr -s "$IFS" '[\n*]'


#  Essayez quelque chose comme "./bin-grep.sh mem /bin/ls" pour comprendre ce
#+ script.

exit 0

Un peu la même chose.

Exemple 10-8. Afficher tous les utilisateurs du système

#!/bin/bash
# userlist.sh

FICHIER_MOTS_DE_PASSE=/etc/passwd
n=1           # Nombre d'utilisateurs

for nom in $(awk 'BEGIN{FS=":"}{print $1}' < "$FICHIER_MOTS_DE_PASSE" )
# Champ séparateur = :  ^^^^^^
# Affiche le premier champ      ^^^^^^^^
# Obtient l'entrée à partir du fichier        ^^^^^^^^^^^^^^^^^^^^^^
do
  echo "UTILISATEUR #$n = $nom"
  let "n += 1"
done  


# UTILISATEUR #1 = root
# UTILISATEUR #2 = bin
# UTILISATEUR #3 = daemon
# ...
# UTILISATEUR #30 = bozo

exit 0

Un dernier exemple d'une [liste] résultant d'une substitution de commande.

Exemple 10-9. Rechercher les auteurs de tous les binaires d'un répertoire

#!/bin/bash
# findstring.sh:
#  Cherche une chaîne de caractères particulière dans des binaires d'un
#+ répertoire particulier.

repertoire=/usr/bin/
chainef="Free Software Foundation"  # Voir quels fichiers viennent de la FSF.

for fichier in $( find $repertoire -type f -name '*' | sort )
do
  strings -f $fichier | grep "$chainef" | sed -e "s%$repertoire%%"
  #  Dans l'expression "sed", il est nécessaire de substituer le délimiteur
  #+ standard "/" parce que "/" se trouve être un caractère filtré. Ne pas le
  #+ faire provoque un message d'erreur (essayez).
done  

exit 0

#  Exercice (facile):
#  ---------------
#  Convertir ce script pour prendre en paramètres de ligne de commande les
#+ variables $repertoire et $chainef.

La sortie d'une boucle for peut être envoyée via un tube à une ou plusieurs commandes.

Exemple 10-10. Afficher les liens symboliques dans un répertoire

#!/bin/bash
# symlinks.sh: Liste les liens symboliques d'un répertoire.


repertoire=${1-`pwd`}
#  Par défaut, le répertoire courant, si le répertoire n'est pas sépcifié.
#  Equivalent au bloc de code ci-dessous.
# -----------------------------------------------------------------
# ARGS=1                 # Attend un argument en ligne de commande.
#
# if [ $# -ne "$ARGS" ]  # Si sans argument...
# then
#   repertoire=`pwd`     # répertoire courant
# else
#   repertoire=$1
# fi
# -----------------------------------------------------------------

echo "Liens symboliques du répertoire \"$repertoire\""

for fichier in "$( find $repertoire -type l )"   # -type l = liens symboliques
do
  echo "$fichier"
done | sort        # Sinon la liste de fichiers n'est pas trié.

#  Comme Dominik 'Aeneas' Schnitzer l'indique, ne pas mettre entre guillemets
#+ $( find $repertoire -type l )
#+ fera échouer le script sur les noms de fichier comprenant des espaces.
#  Même ceci ne prendra que le premier champ de chaque argument.

exit 0

Le stdout d'une boucle peut être redirigée vers un fichier, comme cette légère modification du précédent exemple le montre.

Exemple 10-11. Liens symboliques dans un répertoire, sauvés dans un fichier

#!/bin/bash
# symlinks.sh: Liste les liens symboliques dans un répertoire.

FICHIER_DE_SORTIE=liste.liens_symboliques  # fichier de sauvegarde

repertoire=${1-`pwd`}
#  Par défaut, le répertoire courant si aucun autre n'a été spécifié.


echo "liens symboliques dans le répertoire \"$repertoire\"" > "$FICHIER_DE_SORTIE"
echo "----------------------------------------------------" >> "$FICHIER_DE_SORTIE"

for fichier in "$( find $repertoire -type l )"    # -type l = liens symboliques
do
  echo "$fichier"
done | sort >> "$FICHIER_DE_SORTIE"    # stdout de la boucle
#               ^^^^^^^^^^^^^^^^^^       redirigé vers le fichier de sauvegarde.

exit 0

Il existe une autre syntaxe pour une boucle for ressemblant fortement à celle du C. Elle nécessite des parenthèses doubles.

Exemple 10-12. Une boucle for à la C

#!/bin/bash
# Deux façons de compter jusqu'à 10.

echo

# Syntaxe standard.
for a in 1 2 3 4 5 6 7 8 9 10
do
  echo -n "$a "
done  

echo; echo

# +==========================================+

# Maintenant, faisons de même en utilisant une syntaxe C.

LIMITE=10

for ((a=1; a <= LIMITE ; a++)) # Double parenthèses, et "LIMITE" sans "$".
do
  echo -n "$a "
done                           # Une construction empruntée à 'ksh93'.

echo; echo

# +=========================================================================+

#  Utilisons l'opérateur "virgule" C pour incrémenter deux variables en même
#+ temps.

for ((a=1, b=1; a <= LIMITE ; a++, b++))  # La virgule chaîne les opérations.
do
  echo -n "$a-$b "
done

echo; echo

exit 0

Voir aussi Exemple 26-8, Exemple 26-9 et Exemple A-7.

---

Maintenant, une boucle for utilisée dans un contexte de la << vie quotidienne >>.

Exemple 10-13. Utiliser efax en mode batch

#!/bin/bash

ARGUMENTS_ATTENDUS=2
E_MAUVAISARGS=65

if [ $# -ne $ARGUMENTS_ATTENDUS ]
# Vérifie le bon nombre d'arguments en ligne de commande.
then
	echo "Usage: `basename $0` téléphone# fichier-texte"
   exit $E_MAUVAISARGS
fi


if [ ! -f "$2" ]
then
  echo "Le fichier $2 n'est pas un fichier texte"
  exit $E_MAUVAISARGS
fi
  

fax make $2              #  Crée des fichiers formatés pour le fax à partir de
                         #+ fichiers texte.

for fichier in $(ls $2.0*)  # Concatène les fichiers convertis.
                       # Utilise le caractère joker dans la liste des variables.
do
  fic="$fic $fichier"
done  

efax -d /dev/ttyS3 -o1 -t "T$1" $fic   # Fait le boulot.


# Comme S.C. l'a indiqué, la boucle for peut être supprimée avec
#    efax -d /dev/ttyS3 -o1 -t "T$1" $2.0*
# mais ce n'est pas aussi instructif [grin].

exit 0
while

Cette construction teste une condition au début de la boucle et continue à boucler tant que la condition est vraie (renvoie un 0 code de sortie). Par opposition à une boucle for, une boucle while trouve son utilité dans des situations où le nombre de répétitions n'est pas connu dès le départ.

while [condition]
do
 commande...
done

Comme c'est le cas avec les boucles for/in, placez le do sur la même ligne que le test de la condition nécessite un point virgule.

while [condition] ; do

Notez que certaines boucles while spécialisées, comme par exemple une construction getopts, dévie quelque peu du modèle standard donné ici.

Exemple 10-14. Simple boucle while

#!/bin/bash

var0=0
LIMITE=10

while [ "$var0" -lt "$LIMITE" ]
do
  echo -n "$var0 "        # -n supprime le retour chariot.
  var0=`expr $var0 + 1`   # var0=$(($var0+1)) fonctionne aussi.
done

echo

exit 0

Exemple 10-15. Une autre boucle while

#!/bin/bash

echo

while [ "$var1" != "fin" ]     # while test "$var1" != "end"
do                             # fonctionne aussi.
  echo "Variable d'entrée #1 (quitte avec fin) "
  read var1                    # pas de 'read $var1' (pourquoi?).
  echo "variable #1 = $var1"   # A besoin des guillemets à cause du "#".
  # Si l'entrée est 'end', l'affiche ici.
  # Ne teste pas la condition de fin avant de revenir en haut de la boucle.
  echo
done  

exit 0

Une boucle while peut avoir de multiples conditions. Seule la condition finale détermine quand la boucle se termine. Ceci nécessite une syntaxe de boucle légèrement différente, malgré tout.

Exemple 10-16. Boucle while avec de multiples conditions

#!/bin/bash

var1=unset
precedent=$var1

while echo "Variable précédente = $precedent"
      echo
      precedent=$var1
      [ "$var1" != fin ] # Garde trace de ce que $var1 valait précédemment.
      #  Quatre conditions sur "while", mais seule la dernière contrôle la
      #+ boucle.
      # Le *dernier* code de sortie est celui qui compte.
do
  echo "Variable d'entrée #1 (quitte avec fin) "
  read var1
  echo "variable #1 = $var1"
done  

# Essayez de comprendre comment cela fonctionne.
# il y a un peu d'astuces.

exit 0

Comme pour une boucle for, une boucle while peut employer une syntaxe identique à C en utilisant la construction avec des parenthèses doubles (voir aussi Exemple 9-28).

Exemple 10-17. Syntaxe à la C pour une boucle while

#!/bin/bash
# wh-loopc.sh: Compter jusqu'à 10 dans une boucle "while".

LIMITE=10
a=1

while [ "$a" -le $LIMITE ]
do
  echo -n "$a "
  let "a+=1"
done           # Pas de surprises, jusqu'ici.

echo; echo

# +=================================================================+

# Maintenant, de nouveau mais avec une syntaxe C.

((a = 1))      # a=1
#  Les double parenthèses permettent les espaces pour initialiser une variable,
#+ comme en C.

while (( a <= LIMITE )) # Double parenthèses, et pas de "$" devant la variable.
do
  echo -n "$a "
  ((a += 1))   # let "a+=1"
  # Oui, en effet.
  #  Les double parenthèses permettent d'incrémenter une varibale avec une
  #+ syntaxe style C.
done

echo

# Maintenant, les programmeurs C se sentent chez eux avec Bash.

exit 0

Note

Une boucle while peut avoir son stdin redirigé vers un fichier par un < à la fin.

until

Cette construction teste une condition au début de la boucle et continue à boucler tant que la condition est fausse (l'opposé de la boucle while).

until [condition-est-vraie]
do
 commande...
done

Notez qu'une boucle until teste la condition de fin au début de la boucle, contrairement aux constructions similaires dans certains langages de programmation.

Comme c'est la cas avec les boucles for/in, placez do sur la même ligne que le test de la condition nécessite un point virgule.

until [condition-est-vraie] ; do

Exemple 10-18. Boucle until

#!/bin/bash

until [ "$var1" = fin ] # Condition du test ici, en haut de la boucle.
do
  echo "Variable d'entrée #1 "
  echo "(fin pour sortir)"
  read var1
  echo "variable #1 = $var1"
done  

exit 0
PrécédentSommaireSuivant
Boucles et branchementsNiveau supérieurBoucles imbriquées
>

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

Note

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.

Note

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.

Attention

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.

Note

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.

Attention

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

[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édentSommaireSuivant
Les variables revisitéesNiveau supérieurManipuler les chaînes de caractères
>

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

Exemple 11-21. Un script lançant exec sur lui-même

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

Note

L'option -exec pour find n'est pas du tout la même chose que la commande shell intégrée exec.

shopt

Cette commande permet de changer les options du shell au vol (voir Exemple 24-1 et Exemple 24-2). Elle apparait souvent dans les fichiers de démarrage de Bash, mais a aussi son utilité dans des scripts. Il est nécessaire de disposer de la version 2, ou ultérieurs, de Bash. 
shopt -s cdspell
# Permet des petites erreurs dans le nom des répertoires avec 'cd'

cd /hpme  # Oups! J'ai mal tapé '/home'.
pwd       # /home
          # Le shell a corrigé la faute de frappe.

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.

Notes

[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édentSommaireSuivant
Tests et branchementsNiveau supérieurCommandes de contrôle des jobs