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

Chapitre 19. Expressions rationnelles

Table des matières
19.1. Une brève introduction aux expressions rationnelles
19.2. Remplacement

Pour utiliser complètement la puissance de la programmation par script shell, vous devez maîtriser les expressions rationnelles. Certaines commandes et utilitaires habituellement utilisés dans les scripts, tels que expr, sed et awk interprètent et utilisent les ER.

Précédent	Sommaire	Suivant
Thèmes avancés	Niveau supérieur	Une brève introduction aux expressions rationnelles

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

Précédent	Sommaire	Suivant
Utiliser exec	Niveau supérieur	Applications

> (voir Exemple 12-42).

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.

Exemple 9-27. Nombres pseudo aléatoires, en utilisant awk

#!/bin/bash
# random2.sh: Renvoie un nombre pseudo-aléatoire compris dans la suite 0 - 1.
# Utilise la fonction rand() d'awk.

SCRIPTAWK=' { srand(); print rand() } '
# Commande(s) / paramètres passés à awk
# Notez que srand() regénère le générateur de nombre aléatoire de awk.

echo -n "Nombre aléatoire entre 0 et 1 = "
echo | awk "$SCRIPTAWK"

exit 0


# Exercices:
# ---------

# 1) En utilisant une construction boucle, affichez 10 nombres aléatoires
#    différents.
#      (Astuce: vous devez réinitialiser la fonction "srand()" à chaque tour de
#      la boucle. Qu'arrive-t'il si vous échouer à le faire?)

# 2) En utilisant un multiplicateur entier comme facteur d'échelle, générez des
#    nombres aléatoires compris entre 10 et 100.

# 3) De même que l'exercice #2, ci-dessus, mais en générant des nombres
#    aléatoires entiers cette fois.

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

BGCOLOR="#E0E0E0" WIDTH="90%" >

echo "\$variable01"  # donne $variable01

donne à l'anti-slash sa signification littérale

echo "\\" # donne \

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

Si la ligne d'un script termine avec un |, un caractère tube, alors il n'est pas absolument nécessaire de mettre un échappement \. Il est néanmoins considéré comme une bonne pratique de programmation de toujours échapper une ligne de code qui continue sur la ligne suivante.

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

[1]	Ici, la << séparation de mots >> signifie que la chaîne de caractères est divisée en un certain nombre d'arguments séparés, un par mot.

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

t=${var1#*-*} echo "var1 (avec tout, jusqu'au et incluant le premier - supprimé) = $t" # t=${var1#*-} fonctionne de la même façon, #+ car # correspond à la plus petite chaîne de caractères, #+ et * correspond à tout ce qui précède, incluant la chaîne vide. # (Merci, S. C. pour l'avoir indiqué.) t=${var1##*-*} echo "Si var1 contient un \"-\", renvoie un chaîne vide... var1 = $t" t=${var1%*-*} echo "var1 (avec tout à partir de la fin - supprimée) = $t" echo # ------------------------------------------- nom_chemin=/home/bozo/idees/pensees.pour.aujourdhui # ------------------------------------------- echo "nom_chemin = $nom_chemin" t=${nom_chemin##/*/} echo "nom_chemin, sans les préfixes = $t" # Même effet que t=`basename $nom_chemin` dans ce cas particulier. # t=${nom_chemin%/}; t=${t##*/} est une solution lpus générale, #+ mais elle échoue quelques fois. # Si $nom_chemin finit avec un retour chariot, alors `basename $nom_chemin` #+ ne fonctionnera pas mais l'expression ci-dessus le fera. # (Merci, S.C.) t=${nom_chemin%/*.*} # Même effet que t=`dirname $nom_chemin` echo "nom_chemin, sans les suffixes = $t" # Ceci va échouer dans certains cas, comme "../", "/foo////", # "foo/", "/". # Supprimer les suffixes, spécialement quand le nom de base n'en a pas, mais #+ que le nom du répertoire en a un, complique aussi le problème. # (Merci, S.C.) echo t=${nom_chemin:11} echo "$nom_chemin, avec les 11 premiers caractères supprimés = $t" t=${nom_chemin:11:5} echo "$nom_chemin, avec les 11 premiers caractères supprimés, longueur 5 = $t" echo t=${nom_chemin/bozo/clown} echo "$nom_chemin avec \"bozo\" remplacé par \"clown\" = $t" t=${nom_chemin/today/} echo "$nom_chemin avec \"today\" supprimé = $t" t=${nom_chemin//o/O} echo "$nom_chemin avec tous les o en majuscule = $t" t=${nom_chemin//o/} echo "$nom_chemin avec tous les o supprimés = $t" exit 0

${var/#Modele/Remplacement}

Si le préfixe de var correspond à Modele, alors Remplacement remplace Modele.

${var/%Modele/Remplacement}

Si le suffixe de var correspond à Modele, alors Remplacement remplace Modele.

Exemple 9-19. Modèles correspondant au préfixe ou au suffixe d'une chaîne de caractères

#!/bin/bash
# Remplacement de modèle sur le préfixe / suffixe d'une chaîne de caractères.

v0=abc1234zip1234abc    # Variable original.
echo "v0 = $v0"         # abc1234zip1234abc
echo

# Correspond au préfixe (début) d'une chaîne de caractères.
v1=${v0/#abc/ABCDEF}    # abc1234zip1234abc
                        # |-|
echo "v1 = $v1"         # ABCDE1234zip1234abc
                        # |---|

# Correspond au suffixe (fin) d'une chaîne de caractères.
v2=${v0/%abc/ABCDEF}    # abc1234zip123abc
                        #              |-|
echo "v2 = $v2"         # abc1234zip1234ABCDEF
                        #               |----|

echo

#  ----------------------------------------------------
#  Doit correspondre au début / fin d'une chaîne de caractères.
#+ sinon aucun remplacement ne se fera.
#  ----------------------------------------------------
v3=${v0/#123/000}       # Correspond, mais pas au début.
echo "v3 = $v3"         # abc1234zip1234abc
                        # PAS DE REMPLACEMENT.
v4=${v0/%123/000}       # Correspond, mais pas à la fin.
echo "v4 = $v4"         # abc1234zip1234abc
                        # PAS DE REMPLACEMENT.

exit 0

${!varprefixe*}, ${!varprefixe@}

Correspond à toutes les variables déjà déclarées commençant par varprefixe.
xyz23=quoiquecesoit xyz24= a=${!xyz*} # Se développe en les noms des variables précédemment déclarées # commençant par "xyz". echo "a = $a" # a = xyz23 xyz24 a=${!xyz@} # Même chose que ci-dessus. echo "a = $a" # a = xyz23 xyz24 # Bash, version 2.04, ajoute cette fonctionnalité.

Notes

[1]	Si $parametre est nul dans un script non interactif, il se terminera avec un code de retour 127 (le code d'erreur de Bash pour << commande introuvable >>).

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

VALIGN="top" >Précédent Sommaire SuivantBoucles 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.

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