Guide avancé d'écriture des scripts Bash:
Précédent	Chapitre 7. Tests	Suivant

7.4. Tests if/then imbriqués

Les tests utilisant les constructions if/then peuvent être imbriqués. Le résultat est identique à l'utilisation de l'opérateur de comparaison composée && ci-dessus.

if [ condition1 ] then if [ condition2 ] then faire-quelquechose # Mais seulement si "condition1" et "condition2" sont valides. fi fi

Voir Exemple 35-4 pour des tests de condition if/then imbriqués.

Précédent	Sommaire	Suivant
Opérateurs de comparaison (binaire)	Niveau supérieur	Tester votre connaissance des tests

# mtime = date de dernière modification du fichier cible # ctime = date de dernier changement d'état (via 'chmod' ou autre) # atime = date du dernier accès REP=/home/bozo/junk_files find "$REP" -type f -atime +5 -exec rm {} \; # Efface tous les fichiers contenu dans "/home/bozo/fichiers_bidons" #+ qui n'ont pas été accédés depuis au moins 5 jours. # # "-type typefichier", où # f = fichier classique # d = répertoire, etc. # (La page de manuel 'find' en a une liste complète.)

find /etc -exec grep '[0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*[.][0-9][0-9]*' {} \; # Trouve toutes les adresses IP (xxx.xxx.xxx.xxx) contenues dans les fichiers #+ situés dans le répertoire /etc . # Quelques correspondances n'auront rien à voir - comment peuvent-elles être #+ éliminées ? # Peut-être en faisant: find /etc -type f -exec cat '{}' \; | tr -c '.[:digit:]' '\n' \ | grep '^[^.][^.]*\.[^.][^.]*\.[^.][^.]*\.[^.][^.]*$' # [:digit:] est un ensemble de caractères POSIX 1003.2 # introduit avec le standard POSIX 1003.2. # Merci, S.C.

L'option -exec de find ne doit pas être confondue avec la commande intégrée du shellexec.

Exemple 12-2. incorrectname élimine dans le répertoire courant les fichiers dont le nom contient des caractères incorrects et des espaces blancs.

#!/bin/bash

# Efface les fichiers du répertoire courant contenant des mauvais caractères.

for nomfichier in *
do
mauvaisnom=`echo "$nomfichier" | sed -n /[\+\{\;\"\\\=\?~\(\)\<\>\&\*\|\$]/p`
# Les fichiers contenant ces méchants:     + { ; " \ = ? ~ ( ) < > & * | $
rm $mauvaisnom 2>/dev/null    # Les erreurs sont effacées.
done

# Maintenant, faire attention aux noms de fichiers contenant des espaces blancs.
find . -name "* *" -exec rm -f {} \;
# Le chemin du fichier trouvé par "find" remplace "{}".
#  Le '\' nous assure que le ';' est interprété litérallement, en tant que fin
#+ de commande.

exit 0

#---------------------------------------------------------------------
# Les commandes ci-dessous ne seront pas éxécutées à cause de la commande
# "exit" au dessus.

# Voici une alternative au script ci-dessus:
find . -name '*[+{;"\\=?~()<>&*|$ ]*' -exec rm -f '{}' \;
exit 0
# (Merci, S.C.)

Exemple 12-3. Effacer un fichier par son numéro d'inode

#!/bin/bash
# idelete.sh: Effacer un fichier grâce à son inode.

#  C'est très utile quand un nom de fichier commence avec un caractère illégal,
#+ comme un ? ou -.

NBARGS=1          # L'argument du nom de fichier doit être passé au script.
E_MAUVAISARGS=70
E_FICHIER_INEXISTANT=71
E_CHANGE_D_ESPRIT=72

if [ $# -ne "$NBARGS" ]
then
  echo "Usage: `basename $0` nomfichier"
  exit $E_MAUVAISARGS
fi  

if [ ! -e "$1" ]
then
  echo "Le fichier \""$1"\" n'existe pas."
  exit $E_FICHIER_INEXISTANT
fi  

inum=`ls -i | grep "$1" | awk '{print $1}'`
# inum = inode (NdT; index node) numéro de fichier
#  Chaque fichier possède une inode, qui contient ses informations d'adresses
#+ physiques.

echo; echo -n "Effacer vraiment \"$1\" (o/n)? "
# L'option '-v' de 'rm' pose la même question.
read reponse
case "$reponse" in
[nN]) echo "Vous avez changé d'avis"
      exit $E_CHANGE_D_ESPRIT
      ;;
*)    echo "Effacement en cours du \"$1\".";;
esac

find . -inum $inum -exec rm {} \;
echo "Fichier "\"$1"\" effacé!"

exit 0

Voir Exemple 12-22, Exemple 3-4 et Exemple 10-9 pour des exemples de scripts utilisant find. La page de manuel de cette commande, complexe et puissante, apporte des détails supplémentaires.

xargs

Un filtre qui sert à passer des paramètres à une commande, et aussi un outil pour réunir les commandes elles-mêmes. Il découpe un flux de données en des morceaux suffisament petits pour laisser les filtres et les commandes opérer. Considérez-le comme une puissante alternative aux guillemets inversés. Dans les situations où les guillemets inversés échouent avec une erreur "too many arguments" (trop d'arguments), substituer xargs règle souvent les problèmes. Habituellement, xargs lit depuis stdin ou depuis un tube mais il accèpte aussi de lire dans la sortie d'un fichier.

La commande par défaut d'xargs est echo. Cela signifie que tout flux entrant transmis via un tube vers xargs peut voir ses sauts de ligne et caractères d'espacements supprimés.
bash$ ls -l total 0 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 fichier1 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 fichier2 bash$ ls -l | xargs total 0 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 fichier1 -rw-rw-r-- 1 bozo bozo 0 Jan 29 23:58 fichier2

ls | xargs -p -l gzip Compresse avec gzip tous les fichiers du répertoire courant, un par un, et demande confirmation avant chaque opération.

Une option d'xargs intéressante est -n NN, qui limite à NN le nombre d'arguments passés.

ls | xargs -n 8 echo affiche le contenu du répertoire courant sur 8 colonnes.

Une autre option utile est -0, combinée avec find -print0 ou grep -lZ. Ceci permet de manipuler les arguments contenant des espaces ou des quotes.

find / -type f -print0 | xargs -0 grep -liwZ GUI | xargs -0 rm -f

grep -rliwZ GUI / | xargs -0 rm -f

N'importe laquelle des commande ci-dessus effacera tout fichier contenant << GUI >>. (Merci, S.C.)

Exemple 12-4. Fichier de traces utilisant xargs pour surveiller les logs système

#!/bin/bash

# Génère un fichier de traces dans le répertoire courant à partir de la fin de
# /var/log/messages.

# Note: /var/log/messages doit être lisible par tout le monde si le script
# est appelé par un utilisateur simple.
#         #root chmod 644 /var/log/messages

LIGNES=5

( date; uname -a ) >>fichiertraces
# Time and machine name
echo --------------------------------------------------------------------- >>fichiertraces
tail -$LIGNES /var/log/messages | xargs |  fmt -s >>fichiertraces
echo >>fichiertraces
echo >>fichiertraces

exit 0

Exemple 12-5. copyrep, copier les fichiers du répertoire courant vers un autre en utilisant xargs

#!/bin/bash

# Copie verbeusement tous les fichiers du répertoire courant
# dans le répertoire spécifié sur la ligne de commande

if [ -z "$1" ]   # Quitte si aucun paramètre n'est fourni.
then
  echo "Usage: `basename $0` rep-destination"
  exit 65
fi  

ls . | xargs -i -t cp ./{} $1
# C'est la même chose que
#    cp * $1
# sauf si les fichiers ont des espaces blancs dans leur nom

exit 0

expr

Evaluateur d'expression : Concatène et évalue les arguments suivant l'opération souhaitée (les arguments doivent être séparés par des espaces). Les opérations peuvent être arithmétiques, comparatives, chaîne de caractères ou logiques.

expr 3 + 5

renvoie 8

expr 5 % 3

renvoie 2

expr 5 \* 3

renvoie 15

L'opérateur de multiplication doit être échappé lorsqu'il est utilisé dans une expression arithmétique avec expr.

y=`expr $y + 1`

Incrémente une variable, de la même manière que let y=y+1 et y=$(($y+1)). Ceci est un exemple d'expansion arithmétique.

z=`expr substr $chaine $position $longueur`

Extrait une sous-chaîne de caractères de $longueur caractères, en partant de $position.

Exemple 12-6. Utiliser expr

#!/bin/bash

# Démonstration des possibilités de 'expr'
# ========================================

echo

# Opérations Arithmétiques
# ------------------------

echo "Opérations Arithmétique"
echo
a=`expr 5 + 3`
echo "5 + 3 = $a"

a=`expr $a + 1`
echo
echo "a + 1 = $a"
echo "(incrémentation d'une variable)"

a=`expr 5 % 3`
# modulo
echo
echo "5 mod 3 = $a"

echo
echo

# Opérations Logiques
# -------------------

#  Retourne 1 si vrai, 0 si faux,
#+ à l'opposé des conventions de Bash

echo "Opérations Logiques"
echo

x=24
y=25
b=`expr $x = $y`         # Test d'égalité.
echo "b = $b"            # 0  ( $x -ne $y )
echo

a=3
b=`expr $a \> 10`
echo 'b=`expr $a \> 10`, donc...'
echo "If a > 10, b = 0 (faux)"
echo "b = $b"            # 0  ( 3 ! -gt 10 )
echo

b=`expr $a \< 10`
echo "If a < 10, b = 1 (vrai)"
echo "b = $b"            # 1  ( 3 -lt 10 )
echo
# Notez l'échappement des opérations.

b=`expr $a \<= 3`
echo "If a <= 3, b = 1 (vrai)"
echo "b = $b"            # 1  ( 3 -le 3 )
# Il y a aussi l'opérande "\>=" (plus grand que ou égal à).


echo
echo

# Opérateurs de comparaison
# -------------------------

echo "Opérateurs de comparaison"
echo
a=zipper
echo "a is $a"
if [ `expr $a = snap` ]
# Force la re-évaluation de la variable 'a'
then
   echo "a ne vaut pas 'zipper'"
fi   

echo
echo



# Opérateur de chaine de caractères
# ---------------------------------

echo "Opérateur de chaînes de caractères"
echo

a=1234zipper43231
echo "Voici \"$a\"."

# length: longueur de la chaine
b=`expr length $a`
echo "La taille de \"$a\" est $b."

# index: position du premier caractère dans une sous-chaine
#        qui correspond à un caractère dans la chaine.
b=`expr index $a 23`
echo "La position du premier \"2\" dans \"$a\" est \"$b\"."

#  substr: extrait une sous-chaîne, en spécifiant la position de départ et la
#+ taille
b=`expr substr $a 2 6`
echo "sous-chaîne de \"$a\", commençant à la position 2,\
et long de 6 caractère est \"$b\"."


#  L'attitude par défaut de l'opérateur 'match' est de
#+ chercher une occurence à partir ***du début*** de la chaîne.
#
#        utilisation des expressions régulières
b=`expr match "$a" '[0-9]*'`               #  Comptage numérique.
echo Le nombre de chiffres au début de \"$a\" est $b.
b=`expr match "$a" '\([0-9]*\)'`           #  Notez que les parenthèses échappées
#                   ==      ==              + déclenchent une reconnaissance de sous-chaîne.
echo "Les chiffres au début de \"$a\" sont \"$b\"."

echo

exit 0

L'opérateur : est équivalent à match. Par exemple, b=`expr $a : [0-9]*` est l'équivalent exact de b=`expr match $a [0-9]*` du listing précédent.

#!/bin/bash echo echo "Opérations avec des chaînes utilisant la construction \"expr \$string : \" echo "=======================================================================" echo a=1234zipper5FLIPPER43231 echo "La chaîne en cours est \"`expr "$a" : '$.*$'`\"." # Parenthèses échappées groupant l'opérateur. == == # ********************************* #+ Les parenthèses échappées #+ correspondent à une sous-chaîne. # ********************************* # Si les parenthèses ne sont pas échappées... #+ alors 'expr' convertit la chaîne en un entier. echo "La taille de \"$a\" est `expr "$a" : '.*'`." # Taille de la chaîne echo "Le nombre de chiffre au début de \"$a\" est `expr "$a" : '[0-9]*'`." # ------------------------------------------------------------------------- # echo echo "Les chiffres au début de \"$a\" sont `expr "$a" : '$[0-9]*$'`." # == == echo "Les 7 premières lettres de \"$a\" sont `expr "$a" : '$.......$'`." # ========= == == # Encore, les parenthèses échappées forcent une correspondance de sous-chaîne # echo "Les 7 dernières lettres de \"$a\" sont `expr "$a" : '.*$.......$'`." # ========= fin de l'opérateur chaîne ^^ # (en fait, ça signifie qu'il saute un ou plus jusqu'à une sous-chaîne #+ spécifiée) echo exit 0

Cet exemple illustre comment expr utilise les opérateurs groupant appelés parenthèses echappées -- $ ... $ -- en tandem avec une analyse basée sur les expressions régulières pour faire coïncider une sous-chaîne de caractères.

Perl, sed et awk ont des capacités d'analyse de chaînes de caractères très largement supérieures. Une petite sous-routine sed ou awk dans un script (voir Section 34.2) est aussi une bonne alternative à expr.

Voir Section 9.2 pour en savoir plus sur les manipulations des chaînes de caractères.

Précédent	Sommaire	Suivant
Les commandes basiques	Niveau supérieur	Commandes de date et d'heure

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

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édent	Sommaire	Suivant
Boucles et branchements	Niveau supérieur	Boucles 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.

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.

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édent	Sommaire	Suivant
Les variables revisitées	Niveau supérieur	Manipuler 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).

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édent	Sommaire	Suivant
Tests et branchements	Niveau supérieur	Commandes de contrôle des jobs