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

16.3. Applications

Une utilisation intelligente de la redirection d'E/S permet d'analyser et de coudre ensemble de petits bouts de la sortie de commandes (voir Exemple 11-6). Ceci permet de générer des rapports et des fichiers de traces.

Exemple 16-11. Enregistrer des événements

#!/bin/bash
# logevents.sh, by Stephane Chazelas.

# Tracer des événements dans un fichier.
#  Vous devez être root pour exécuter ceci (pour avoir le droit d'écrire dans
#+ /var/log).

ROOT_UID=0     # Seuls les utilisateurs ayant l'identifiant $UID 0 ont les
               #+ privilèges de root.
E_NONROOT=67   # Code de sortie si non root.


if [ "$UID" -ne "$ROOT_UID" ]
then
  echo "Vous devez être root pour exécuetr ce script."
  exit $E_NONROOT
fi  


FD_DEBUG1=3
FD_DEBUG2=4
FD_DEBUG3=5

# Décommentez une des deux lignes ci-dessous pour activer le script.
# TRACE_EVENEMENTS=1
# TRACE_VARS=1


log()  # Ecrit la date et l'heure dans le fichier de traces.
{
echo "$(date)  $*" >&7  # Ceci *ajoute* la date dans le fichier.
                           # Voir ci-dessous.
}



case $NIVEAU_TRACES in
 1) exec 3>&2         4> /dev/null 5> /dev/null;;
 2) exec 3>&2         4>&2         5> /dev/null;;
 3) exec 3>&2         4>&2         5>&2;;
 *) exec 3> /dev/null 4> /dev/null 5> /dev/null;;
esac

FD_TRACEVARS=6
if [[ $TRACE_VARS ]]
then exec 6>> /var/log/vars.log
else exec 6> /dev/null               # Bury output.
fi

FD_TRACEEVENEMENTS=7
if [[ $TRACE_EVENEMENTS ]]
then
  # then exec 7 >(exec gawk '{print strftime(), $0}' >> /var/log/event.log)
  # La ligne ci-dessus ne fonctionnera pas avec Bash, version 2.04.
  exec 7>> /var/log/event.log        # Ajoute dans "event.log".
  log                                      # Ecrit la date et l'heure.
else exec 7> /dev/null                  # Supprime le sortie.
fi

echo "DEBUG3: début" >&${FD_DEBUG3}

ls -l >&5 2>&4                       # commande1 >&5 2>&4

echo "Done"                                # commande2 

echo "envoi mail" >&${FD_LOGEVENTS}   # Ecrit "envoi mail" sur fd #7.


exit 0

Précédent	Sommaire	Suivant
Rediriger les blocs de code	Niveau supérieur	Documents en ligne

VALIGN="top" >Précédent Sommaire SuivantTests et comparaisons: AlternativesNiveau supérieur<< Coloriser >> des scripts >

Jipe nous a indiqué un autre ensemble de techniques pour générer des nombres aléatoires à l'intérieur d'un intervalle donné.

# Générer des nombres aléatoires entre 6 et 30. rnumber=$((RANDOM%25+6)) # Générer des nombres aléatoires dans le même intervalle de 6 à 30, #+ mais le nombre doit être divisible de façon exacte par 3. rnumber=$(((RANDOM%30/3+1)*3)) # Exercice: Essayez de trouver le modèle en action ici.

A quel point $RANDOM est-il aléatoire? la meilleur façon de le tester est d'écrire un script qui enregistre la suite des nombres << aléatoires >> générés par $RANDOM. Faisons tourner $RANDOM plusieurs fois...

Exemple 9-25. Laisser tourner RANDOM plusieurs fois

#!/bin/bash
# A quel point RANDOM est aléatoire?

RANDOM=$$      #  Réinitialise le générateur de nombres aléatoires en utilisant
               #+ le PID du script.

PIPS=6         # A die has 6 pips.
COMPTEURMAX=600# Augmentez ceci, si vous n'avez rien de mieux à faire.
compteur=0     # Compteur.

zeros=0        # Doit initialiser les comptes à zéro.
uns=0          # car une variable non initialisée est null, et ne vaut pas zéro.
deux=0
trois=0
quatre=0
cinq=0
six=0

Affiche_resultat ()
{
echo
echo "uns =   $uns"
echo "deux =   $deux"
echo "trois = $trois"
echo "quatre =  $quatre"
echo "cinq =  $cinq"
echo "six =  $six"
echo
}

mise_a_jour_compteur()
{
case "$1" in
  0) let "uns += 1";;    # Comme die n'a pas de "zéro", ceci correspond à 1.
  1) let "deux += 1";;   # Et ceci à 2, etc.
  2) let "trois += 1";;
  3) let "quatre += 1";;
  4) let "cinq += 1";;
  5) let "six += 1";;
esac
}

echo


while [ "$compteur" -lt "$COMPTEURMAX" ]
do
  let "die1 = RANDOM % $PIPS"
  mise_a_jour_compteur $die1
  let "compteur += 1"
done  

Affiche_resultat

#  Les scores devraient être distribués de façon égale, en supposant que RANDOM
#+ soit correctement aléatoire.
#  Avec $COMPTEURMAX à 600, tout devrait tourner autour de 100, plus ou moins
#+ 20.
#
# Gardez en tête que RANDOM est un générateur pseudo-aléatoire,
# et pas un particulièrement bon.

# Exercice (facile):
# ---------------
# Réécrire ce script pour lancer une pièce 1000 fois.
# Les choix sont "PILE" ou "FACE".

exit 0

Comme nous avons vu sur le dernier exemple, il est préférable de << réinitialiser >> le générateur RANDOM à chaque fois qu'il est invoqué. Utiliser le même germe pour RANDOM ne fera que répéter la même série de nombres. (Ceci reflète le comportement de la fonction C random().)

Exemple 9-26. Réinitialiser RANDOM

#!/bin/bash
# seeding-random.sh: Utiliser la variable RANDOM.

NBMAX=25       # How many numbers to generate.

nombres_aleatoires ()
{
compteur=0
while [ "$compteur" -lt "$NBMAX" ]
do
  nombre=$RANDOM
  echo -n "$nombre "
  let "compteur += 1"
done  
}

echo; echo

RANDOM=1          #  Initialiser RANDOM met en place le générateur de nombres
                  #+ aléatoires.
nombres_aleatoires

echo; echo

RANDOM=1          # Même élément pour RANDOM...
nombres_aleatoires    # ...reproduit la même série de nombres.
                  #
                  #  Quand est-il utile de dupliquer une série de nombres
		  #+ "aléatoires"?

echo; echo

RANDOM=2          # Nouvel essai, mais avec un 'seed' différent...
nombres_aleatoires    # donne une autre série...

echo; echo

# RANDOM=$$  initialise RANDOM à partir du PID du script.
#  Il est aussi possible d'initialiser RANDOM à partir des commandes 'time' et
#+ 'date'.

# Un peu plus d'amusement...
SEED=$(head -1 /dev/urandom | od -N 1 | awk '{ print $2 }')
#  Sortie pseudo-aléatoire récupéré de /dev/urandom (fichier périphérique
#+ pseudo-aléatoire),
#+ puis convertit la ligne en nombres (octal) affichables avec "od".
#+ Finalement "awk" récupère un seul nombre pour SEED.
RANDOM=$SEED
nombres_aleatoires

echo; echo

exit 0

Le fichier périphérique /dev/urandom apporte un moyen de générer des nombres pseudo aléatoires bien plus << aléatoires >> que la variable $RANDOM. dd if=/dev/urandom of=fichier_cible bs=1 count=XX crée un fichier de nombres pseudo aléatoires bien distribués. Néanmoins, assigner ces nombres à une variable dans un script nécessite un petit travail supplémentaire, tel qu'un filtrage par l'intermédiaire de od (comme dans l'exemple ci-dessus) ou tel que l'utilisation de dd (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