Variables intégrées

Variables affectant le comportement des scripts bash.

$BASH

Le chemin vers le binaire Bash.

bash$ echo $BASH
/bin/bash

$BASH_ENV

Une variable d'environnement pointant vers un script Bash de démarrage lu lorsqu'un script est invoqué.

$BASH_SUBSHELL

une variable indiquant le niveau du sous-shell. C'est un nouvel ajout de Bash, version 3.

Voir l'Exemple 20.1, « Étendue des variables dans un sous-shell » pour son utilisation.

$BASH_VERSINFO[n]

Un tableau à six éléments contenant des informations sur la version installée de Bash. Ceci est similaire à $BASH_VERSION, ci-dessous, mais en un peu plus détaillé.

# Infos sur la version de Bash :

for n in 0 1 2 3 4 5
do
  echo "BASH_VERSINFO[$n] = ${BASH_VERSINFO[$n]}"
done

# BASH_VERSINFO[0] = 3                      # No majeur de version.
# BASH_VERSINFO[1] = 00                     # No mineur de version.
# BASH_VERSINFO[2] = 14                     # Niveau de correctifs.
# BASH_VERSINFO[3] = 1                      # Version construite.
# BASH_VERSINFO[4] = release                # État de la version.
# BASH_VERSINFO[5] = i386-redhat-linux-gnu  # Architecture.
                                            # (identique à $MACHTYPE).

$BASH_VERSION

La version de Bash installée sur le système.

bash$ echo $BASH_VERSION
3.00.14(1)-release
              

tcsh% echo $BASH_VERSION
BASH_VERSION: Undefined variable.
              

Vérifier $BASH_VERSION est une bonne méthode pour déterminer le shell qui est en cours d'exécution. $SHELL ne donne pas nécessairement la bonne réponse.

$DIRSTACK

La valeur du dessus de la pile de répertoires (affectée par pushd et popd)

Cette variable intégrée correspond à la commande dirs. Néanmoins, dirs affiche le contenu entier de la pile de répertoires.

$EDITOR

L'éditeur invoqué par défaut par un script, habituellement vi ou emacs.

$EUID

Numéro d'identifiant « effectif » de l'utilisateur.

Numéro d'identification, quelle que soit l'identité que l'utilisateur actuel assume, peut-être suite à un su.

Attention

$EUID n'est pas nécessairement le même que $UID.

$FUNCNAME

Nom de la fonction en cours.

xyz23 ()
{
  echo "$FUNCNAME en cours d'exécution."  # xyz23 en cours d'exécution.
}

xyz23

echo "FUNCNAME = $FUNCNAME"        # FUNCNAME =
                                   # vide en dehors d'une fonction

$GLOBIGNORE

Une liste de modèles de noms de fichiers à exclure de la correspondance lors d'un remplacement.

$GROUPS

Groupes auxquels appartient l'utilisateur.

C'est une liste (de type tableau) des numéros d'identifiant de groupes pour l'utilisateur actuel, identique à celle enregistrée dans /etc/passwd et /etc/group.

root# echo $GROUPS
0


root# echo ${GROUPS[1]}
1


root# echo ${GROUPS[5]}
6
              

$HOME

Répertoire personnel de l'utilisateur, habituellement /home/utilisateur (voir l'Exemple 9.16, « Utiliser la substitution et les messages d'erreur »)

$HOSTNAME

La commande hostname définit le nom de l'hôte au démarrage en utilisant un script de démarrage. Néanmoins, la fonction gethostname() initialise la variable interne Bash $HOSTNAME. Voir aussi l'Exemple 9.16, « Utiliser la substitution et les messages d'erreur ».

$HOSTTYPE

Type de l'hôte.

Comme $MACHTYPE, identifie le matériel du système.

bash$ echo $HOSTTYPE
i686

$IFS

Séparateur interne du champ de saisie.

Cette variable détermine la façon dont Bash reconnaît les champs ou les limites de mots lorsqu'il interprète des chaînes de caractères.

La valeur par défaut est un espace blanc (espace, tabulation et retour chariot) mais peut être changé, par exemple, pour analyser un fichier de données séparées par des virgules. Notez que $* utilise le premier caractère contenu dans $IFS. Voir l'Exemple 5.1, « Afficher des variables bizarres ».

bash$ echo "$IFS"



(Avec la valeur par défaut de $IFS, une ligne blanche apparaît.)
              


bash$ echo "$IFS" | cat -vte
 ^I$
 $
(Affiche un espace blanc -- un espace, ^I [tabulation horizontale],
  ou un retour chariot -- et affiche  un dollar ($) en fin de ligne.)



bash$ bash -c 'set w x y z; IFS=":-;"; echo "$*"'
w:x:y:z
(Lit les commandes à partir de la chaîne et affecte tout
argument suivant les paramètres de position)
              

Attention

$IFS ne gère pas les espaces blancs de la même façon que les autres caractères.

Exemple 9.1. $IFS et espaces blancs

#!/bin/bash
# $IFS traite les espaces blancs différemment des autres caractères.

affiche_un_argument_par_ligne()
{
  for arg
  do echo "[$arg]"
  done
}

echo; echo "IFS=\" \""
echo "-------"

IFS=" "
var=" a  b c   "
affiche_un_argument_par_ligne $var  # affiche_un_argument_par_ligne `echo " a  b c   "`
#
# [a]
# [b]
# [c]


echo; echo "IFS=:"
echo "-----"

IFS=:
var=":a::b:c:::"        # Identique à ci-dessus, mais substitue ":" à " ".
affiche_un_argument_par_ligne $var
#
# []
# [a]
# []
# [b]
# [c]
# []
# []
# []

# La même chose arrive avec le séparateur de champs "FS" dans awk.

# Merci, Stephane Chazelas.

echo

exit 0

(Merci beaucoup, Stéphane Chazelas, pour cette clarification et ces exemples.)

Voir aussi l'Exemple 15.41, « Analyser le domaine d'un courrier indésirable » , Exemple 10.7, « Un remplaçant de grep pour les fichiers binaires » et Exemple 18.14, « Analyser une boîte mail » pour des exemples instructifs sur l'utilisation de $IFS.

$IGNOREEOF

Ignore EOF : nombre de fins de fichier (control-D) que le shell va ignorer avant de déconnecter.

$LC_COLLATE

Souvent intégré dans les fichiers .bashrc ou /etc/profile, cette variable contrôle l'ordre d'examen dans l'expansion des noms de fichiers et les correspondances de modèles. Si elle est mal gérée, LC_COLLATE peut apporter des résultats inattendus dans le remplacement de noms de fichiers.

Note

À partir de la version 2.05 de Bash, le remplacement de noms de fichiers ne tient plus compte des lettres en minuscules et en majuscules dans une suite de caractères entre crochets. Par exemple, ls [A-M]* correspondrait à la fois à Fichier1.txt et à fichier1.txt. Pour annuler le comportement personnalisé de la correspondance par crochets, initialisez LC_COLLATE à C par un export LC_COLLATE=C dans /etc/profile et/ou ~/.bashrc.

$LC_CTYPE

Cette variable interne contrôle l'interprétation des caractères pour le remplacement et la correspondance de modèles.

$LINENO

Cette variable correspond au numéro de ligne du script shell dans lequel cette variable apparaît. Elle n'a une signification que dans le script où elle apparait et est surtout utilisée dans les phases de débogage.

# *** DEBUT BLOC DEBUG ***
dernier_argument_command=$_  # Le sauver.

echo "À la ligne numéro $LINENO, la variable \"v1\" = $v1"
echo "Dernier argument de la ligne exécutée = $dernier_argument_command"
# *** FIN BLOC DEBUG ***

$MACHTYPE

Type de machine.

Identifie le matériel du système.

bash$ echo $MACHTYPE
i686

$OLDPWD

Ancien répertoire courant (« OLD-print-working-directory », ancien répertoire où vous étiez).

$OSTYPE

Type de système d'exploitation.

bash$ echo $OSTYPE
linux

$PATH

Chemin vers les binaires, habituellement /usr/bin/, /usr/X11R6/bin/, /usr/local/bin, etc.

Lorsqu'une commande est donnée, le shell recherche automatiquement l'exécutable dans les répertoires listés dans le chemin. Le chemin est stocké dans la variable d'environnement, $PATH, une liste des répertoires, séparés par le symbole ":". Normalement, le système enregistre la définition de $PATH dans /etc/profile et/ou ~/.bashrc (voir l'Annexe G, Fichiers importants).

bash$ echo $PATH
/bin:/usr/bin:/usr/local/bin:/usr/X11R6/bin:/sbin:/usr/sbin

PATH=${PATH}:/opt/bin ajoute le répertoire /opt/bin au chemin actuel. Dans un script, il peut être avantageux d'ajouter temporairement un répertoire au chemin de cette façon. Lorsque le script se termine, le $PATH original est restauré (un processus fils, tel qu'un script, ne peut pas changer l'environnement du processus père, le shell).

Note

Le « répertoire » courant, ./, est habituellement omis de $PATH pour des raisons de sécurité.

$PIPESTATUS

Variable de type tableau contenant les codes de sortie de la dernière commande exécutée via un tube. De façon étonnante, ceci ne donne pas obligatoirement le même résultat que le code de sortie de la dernière commande exécutée.

bash$ echo $PIPESTATUS
0

bash$ ls -al | bogus_command
bash: bogus_command: command not found
bash$ echo $PIPESTATUS
141

bash$ ls -al | bogus_command
bash: bogus_command: command not found
bash$ echo $?
127
              

Les membres du tableau $PIPESTATUS contiennent le code de sortie de chaque commande respective exécutée via un tube. $PIPESTATUS[0] contient le code de sortie de la première commande du tube, $PIPESTATUS[1] le code de sortie de la deuxième commande et ainsi de suite.

Attention

La variable $PIPESTATUS peut contenir une valeur 0 erronée dans un shell de connexion (dans les versions précédant la 3.0 de Bash).

tcsh% bash

bash$ who | grep nobody | sort
bash$ echo ${PIPESTATUS[*]}
0
              

Les lignes ci-dessus contenues dans un script produiraient le résultat attendu, 0 1 0.

Merci, Wayne Pollock pour avoir partagé ceci en apportant l'exemple ci-dessus.

Note

La variable $PIPESTATUS donne des résultats inattendus dans certains contextes.

bash$ echo $BASH_VERSION
3.00.14(1)-release

bash$ $ ls | commande_boguee | wc
bash: commande_boguee: command not found
 0       0       0

bash$ echo ${PIPESTATUS[@]}
141 127 0
              

Chet Ramey attribue l'affichage ci-dessus au comportement de ls. Si ls écrit dans un tube dont la sortie n'est pas lue, alors SIGPIPE le tue et son code de sortie est 141. Sinon, son code de sortie est 0, comme attendu. C'est certainement le cas pour tr.

Note

$PIPESTATUS est une variable « volatile ». Elle doit être immédiatement capturée après le tube, c'est-à-dire avant que d'autres commandes n'interviennent.

bash$ $ ls | commande_boguee | wc
bash: commande_boguee: command not found
 0       0       0

bash$ echo ${PIPESTATUS[@]}
0 127 0

bash$ echo ${PIPESTATUS[@]}
0
              

Note

L'option pipefail pourrait être utile dans les cas où $PIPESTATUS ne donne pas l'information désirée.

$PPID

Le $PPID d'un processus est l'identifiant du processus (PID) père. ^[33]

Comparez ceci avec la commande pidof.

$PROMPT_COMMAND

Une variable contenant une commande à exécuter juste avant l'affichage de l'invite principale, $PS1.

$PS1

Ceci est l'invite principale, vue sur la ligne de commande.

$PS2

La deuxième invite, vue lorsqu'une saisie supplémentaire est attendue. Elle s'affiche comme « > ».

$PS3

La troisième invite, affichée lors d'une boucle select (voir l'Exemple 10.29, « Créer des menus en utilisant select »)

$PS4

La quatrième invite, affichée au début de chaque ligne d'affichage lorsqu'un script a été appelé avec l'option -x. Elle affiche un « + ».

$PWD

Répertoire courant (répertoire où vous êtes actuellement)

Ceci est analogue à la commande intégrée pwd.

#!/bin/bash

E_MAUVAIS_REPERTOIRE=73

clear # Efface l'écran.

RepertoireCible=/home/bozo/projects/GreatAmericanNovel

cd $RepertoireCible
echo "Suppression des anciens fichiers de $RepertoireCible."

if [ "$PWD" != "$RepertoireCible" ]
then    # Empêche la suppression d'un mauvais répertoire par accident.
  echo "Mauvais répertoire!"
  echo "Dans $PWD, plutôt que $RepertoireCible!"
  echo "Je quitte!"
  exit $E_MAUVAIS_REPERTOIRE
fi  

rm -rf *
rm .[A-Za-z0-9]*    # Supprime les fichiers commençant par un point.
# rm -f .[^.]* ..?*   pour supprimer les fichiers commençant par plusieurs points.
# (shopt -s dotglob; rm -f *)   fonctionnera aussi.
# Merci, S.C., pour nous l'avoir indiqué.

# Les noms de fichier peuvent contenir tous les caractères de 0 à 255, 
# à l'exception de "/".
# La suppression des fichiers commençant par des caractères bizarres est laissé
# en exercice.

# Autres opérations ici, si nécessaire.

echo
echo "Fait."
echo "Anciens fichiers supprimés de $RepertoireCible."
echo


exit 0

$REPLY

La variable par défaut lorsqu'aucune n'est adjointe au read. Aussi applicable au menu select, mais renvoie seulement le numéro de l'élément de la variable choisie et non pas la valeur de la variable elle-même.

#!/bin/bash
# reply.sh

# REPLY est la variable par défaut d'une commande 'read'

echo
echo -n "Quel est votre légume favori? "
read

echo "Votre légume favori est $REPLY."
#  REPLY contient la valeur du dernier "read" si et seulement si aucune variable
#+ n'est spécifiée.

echo
echo -n "Quel est votre fruit favori? "
read fruit
echo "Votre fruit favori est $fruit."
echo "mais..."
echo "La valeur de \$REPLY est toujours $REPLY."
#  $REPLY est toujours initialisé à sa précédente valeur car la variable $fruit
#+ a absorbé la nouvelle valeur obtenue par "read".

echo

exit 0

$SECONDS

Le nombre de secondes pris par l'exécution du script.

#!/bin/bash

LIMITE_TEMPS=10
INTERVALLE=1

echo
echo "Appuyez sur Control-C pour sortir avant $LIMITE_TEMPS secondes."
echo

while [ "$SECONDS" -le "$LIMITE_TEMPS" ]
do
  if [ "$SECONDS" -eq 1 ]
  then
    unites=seconde
  else  
    unites=secondes
  fi

  echo "Ce script tourne depuis $SECONDS $unites."
  #  Sur une machine lente, le script peut laisser échapper quelquefois
  #+ un élément du comptage 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, à quel point Bash est imbriqué. ^[34] Si, à la ligne de commande, $SHLVL vaut 1, alors dans un script, il sera incrémenté et prendra la valeur 2.

Note

Cette variable n'est pas affectée par les sous-shells. Utilisez $BASH_SUBSHELL quand vous avez besoin d'une indication d'une imbrication de sous-shell.

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

À partir de la version 2.05b de Bash, il est possible d'utiliser $TMOUT dans un script avec un read.

#  Fonctionne avec des scripts pour Bash, versions
#+ 2.05b et ultérieures.

TMOUT=3    # L'invite s'arrête dans trois secondes.

echo "Quelle est votre chanson favorite?"
echo "Faites vite car vous n'avez que $TMOUT secondes pour répondre !"
read chanson

if [ -z "$chanson" ]
then
  chanson="(sans réponse)"
  # Réponse par défaut.
fi

echo "Votre chanson favorite est $chanson."

Il existe d'autres façons, certaines plus complexes, pour implémenter une entrée avec temporisation. Une alternative consiste à configurer une boucle rythmée pour signaler au script la fin de l'attente. Ceci requiert aussi une routine de gestion du signal pour récupérer (voir l'Exemple 29.5, « Récupérer la sortie ») l'interruption créée par la boucle.

Exemple 9.2. Saisie avec délai

#!/bin/bash
# timed-input.sh

# TMOUT=3            Fonctionne aussi, depuis les dernières versions de Bash.

INTERRUPTION_TIMER=14
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ée 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 trois secondes, puis envoie sigalarm au script.
}  


VecteurInt14()
{
  reponse="TIMEOUT"
  AfficheReponse
  exit $INTERRUPTION_TIMER
}  

trap VecteurInt14 $INTERRUPTION_TIMER   #  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 le script "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'.
#  Néanmoins, pourquoi ne pas chronométrer un script complet,
#+ à la place d'une simple saisie d'un utilisateur ?

exit 0

Une autre méthode est d'utiliser stty.

Exemple 9.3. Encore une fois, saisie avec délai

#!/bin/bash
# timeout.sh

#  Écrit par Stephane Chazelas,
#+ et modifié par l'auteur de ce document.

INTERVALLE=5                # délai

lecture_delai() {
  delai=$1
  nomvariable=$2
  ancienne_configuration_tty=`stty -g`
  stty -icanon min 0 time ${delai}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_delai $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".
# À 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
# Inspiré d'une suggestion de "syngin seven" (merci).

LIMITETEMPS=4        # Quatre secondes

read -t $LIMITETEMPS variable <&1
#                             ^^^
#  Dans ce cas, "<&1" est nécessaire pour Bash 1.x et 2.x,
#  mais inutile pour Bash 3.x.

echo

if [ -z "$variable" ]  # Est nul ?
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 sujette au changement à partir de la ligne de commande ou à l'intérieur d'un script, et est la contrepartie 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 une personne ordinaire."
fi

Voir aussi l'Exemple 2.3, « cleanup : Une version améliorée et généralisée des scripts précédents ».

Note

Les variables $ENV, $LOGNAME, $MAIL, $TERM, $USER et $USERNAME ne sont pas des variables intégrées à Bash. Néanmoins, elles sont 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 l'Exemple 4.5, « Paramètres positionnels  » et l'Exemple 14.16, « Utiliser set avec les paramètres de position »)

$#

Nombre d'arguments sur la ligne de commande ^[35] ou de paramètres de position (voir l'Exemple 33.2, « Un script d'appel légèrement plus complexe »)

$*

Tous les paramètres de position, vus comme un seul mot.

Note

"$*" doit être entre guillemets.

$@

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

Note

Bien sûr, "$@" doit être entre guillemets.

Exemple 9.6. arglist : Affichage des arguments avec $* et $@

#!/bin/bash
# arglist.sh
# Appelez ce script avec plusieurs arguments, tels que "un deux trois".

E_MAUVAISARGS=65

if [ ! -n "$1" ]
then
  echo "Usage: `basename $0` argument1 argument2 etc."
  exit $E_MAUVAISARGS
fi  

echo

index=1    # Initialise le compteur.

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    # Ré-initialisation du compteur.
           # Qu'arrive-t'il si vous oubliez de le faire ?

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

index=1    # Ré-initialisation du compteur.

echo "Liste des arguments avec \$* (sans guillemets) :"
for arg in $*
do
  echo "Argument #$index = $arg"
  let "index+=1"
done             # $* sans guillemets voit les arguments comme des mots séparés.
echo "Liste des arguments vue comme des mots séparés."


exit 0

Suite à un shift, $@ contient le reste des paramètres de la ligne de commande, sans le $1 précédent 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 l'Exemple 15.24, « rot13 : rot13, cryptage ultra-faible. » et l'Exemple 15.25, « Générer des énigmes « Crypto-Citations » ».

Attention

Les paramètres $* et $@ affichent quelque fois un comportement incohérent et bizarre, suivant la configuration de $IFS.

Exemple 9.7. Comportement de $* et $@ incohérent

#!/bin/bash

#  Comportement non prévisible des variables internes Bash "$*" et "$@",
#+ suivant qu'elles soient ou non entre guillemets.
#  Gestion incohérente 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 $*                 # sans guillemets
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS inchangée, utilisant "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS inchangée, utilisant $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---

IFS=:
echo 'IFS=":", utilisant "$*"'
c=0
for i in "$*"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $*'
c=0
for i in $*
do echo "$((c+=1)): [$i]"
done
echo ---

var=$*
echo 'IFS=":", utilisant "$var" (var=$*)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $var (var=$*)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---

var="$*"
echo 'IFS=":", utilisant $var (var="$*")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant "$var" (var="$*")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant "$@"'
c=0
for i in "$@"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $@'
c=0
for i in $@
do echo "$((c+=1)): [$i]"
done
echo ---

var=$@
echo 'IFS=":", utilisant $var (var=$@)'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant "$var" (var=$@)'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

var="$@"
echo 'IFS=":", utilisant "$var" (var="$@")'
c=0
for i in "$var"
do echo "$((c+=1)): [$i]"
done
echo ---

echo 'IFS=":", utilisant $var (var="$@")'
c=0
for i in $var
do echo "$((c+=1)): [$i]"
done

echo

# Essayez ce script avec ksh ou zsh -y.

exit 0

# Ce script exemple par Stephane Chazelas,
# et légèrement modifié par l'auteur de ce document.

Note

Les paramètres $@ et $* diffèrent seulement lorsqu'ils sont entre guillemets.

Exemple 9.8. $* et $@ lorsque $IFS est vide

#!/bin/bash

#+ Si $IFS est initialisé mais vide,
#+ alors "$*" et "$@" n'affichent 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, Stephane Chazelas.

exit 0

Autres paramètres spéciaux

$-

Les options passées au script (en utilisant set). Voir l'Exemple 14.16, « Utiliser set avec les paramètres de position ».

Attention

Ceci était originellement une construction de ksh adoptée dans Bash et, malheureusement, elle ne semble pas fonctionner de façon fiable dans les scripts Bash. Une utilité possible pour ceci est d'avoir un script testant lui-même s'il est interactif.

$!

Identifiant du processus (PID) du dernier job ayant fonctionné en tâche de fond.

TRACE=$0.log

COMMANDE1="sleep 100"

echo "Trace des PID des commandes en tâche de fond pour le script : $0" >> "$TRACE"
# Pour qu'ils soient enregistrés et tués si nécessaire.
echo >> "$TRACE"

# Commandes de trace.

echo -n "PID de \"$COMMANDE1\" :  " >> "$TRACE"
${COMMANDE1} &
echo $! >> "$TRACE"
# PID de "sleep 100" :  1506

# Merci, Jacques Lederer, pour cette suggestion.

Utiliser $! pour contrôler un job :

job_qui_peut_se_bloquer & { sleep ${TIMEOUT}; eval 'kill -9 $!' &> /dev/null; }
# Force la fin d'un programme qui se comporte mal.
# Utile, par exemple, dans les scripts d'initialisation.

# Merci, Sylvain Fourmanoit, pour cette utilisation ingénieuse de la variable "!".

Ou autrement :

# Exemple de Matthew Sage.
# Utilisé avec sa permission.

DELAI=30   # Délai d'attente en secondes
nombre=0

job_qui_peut_se_bloquer & {
        while ((nombre < DELAI )); do
                eval '[ ! -d "/proc/$!" ] && ((count = TIMEOUT))'
                #  /proc est l'endroit où sont disponibles des informations
                #+ sur les processus en cours d'exécution.
                # "-d" teste si le répertoire existe.
                # Donc, nous attendons que le job en question se manifeste.
                ((nombre++))
                sleep 1
        done
        eval '[ -d "/proc/$!" ] && kill -15 $!'
        # Si le job est en cours d'exécution, tuons-le.
}

$_

Variable spéciale initialisée avec le dernier argument de la dernière 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, d'une fonction ou du script lui-même (voir l'Exemple 23.7, « Maximum de deux nombres »)

$$

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 l'Exemple A.13, « ftpget: Télécharger des fichiers via ftp  », l'Exemple 29.6, « Nettoyage après un Control-C », l'Exemple 15.31, « Déballer une archive rpm » et l'Exemple 14.27, « Un script qui se tue lui-même »). Ceci est généralement plus simple que d'appeler mktemp.