I/O

echo

envoie (vers stdout) une expression ou une variable (voir l'Exemple 4.1, « Affectation d'une variable et son remplacement par sa valeur »).

echo Bonjour
echo $a

Un echo nécessite l'option -e pour afficher des séquences d'échappement. Voir l'Exemple 5.2, « Caractères d'échappement ».

Généralement, chaque commande echo envoie un retour à la ligne, mais l'option -n désactive ce comportement.

Note

Un echo peut être utilisé pour envoyer des informations à un ensemble de commandes via un tube.

if echo "$VAR" | grep -q txt   # if [[ $VAR = *txt* ]]
then
  echo "$VAR contient la sous-chaîne \"txt\""
fi

Note

Un echo, en combinaison avec une substitution de commande peut définir une variable.

a=`echo "HELLO" | tr A-Z a-z`

Voir aussi l'Exemple 16.22, « lowercase : Change tous les noms de fichier du répertoire courant en minuscule. », l'Exemple 16.3, « Badname élimine dans le répertoire courant les fichiers dont le nom contient des caractères incorrects et des espaces blancs. », l'Exemple 16.47, « Paiement mensuel sur une hypothèque » et l'Exemple 16.48, « Conversion de base ».

Sachez que echo `commande` supprime tous les retours chariot que la sortie de commande génère.

La variable $IFS (séparateur interne de champ) contient en général le caractère spécial \n (retour chariot) comme un des éléments de ses blancs. Du coup, Bash divise la sortie de commande suivant les retours chariot et les prend comme argument pour echo. Ensuite, echo affiche ces arguments séparés par des espaces.

bash$ ls -l /usr/share/apps/kjezz/sounds
-rw-r--r--    1 root     root         1407 Nov  7  2000 reflect.au
 -rw-r--r--    1 root     root          362 Nov  7  2000 seconds.au




bash$ echo `ls -l /usr/share/apps/kjezz/sounds`
total 40 -rw-r--r-- 1 root root 716 Nov 7 2000 reflect.au -rw-r--r-- 1 root root ...
              

Donc, comment pouvons-nous intégrer un retour chariot dans la chaîne de caractère d'un echo ?

# Intégrer un retour chariot ?
echo "Pourquoi cette chaîne \n ne s'affiche pas sur deux lignes ?"
# Pas de deuxième ligne.

# Essayons autre chose.

echo

echo $"Une ligne de texte contenant
un retour chariot."
# S'affiche comme deux lignes distinctes (retour chariot intégré).
# Mais, le préfixe "$" des variables est-il réellement nécessaire ?

echo

echo "Cette chaîne se divise
en deux lignes."
# Non, le "$" n'est pas nécessaire.

echo
echo "---------------"
echo

echo -n $"Autre ligne de texte contenant
un retour chariot."
# S'affiche comme deux lignes distinctes (retour chariot intégré).
# Même l'option -n échoue à la suppression du retour chariot ici.

echo
echo
echo "---------------"
echo
echo

# Néanmoins, ce qui suit ne fonctionne pas comme attendu.
# Pourquoi pas ? Astuce : affectation d'une variable.
chaine1=$"Encore une autre ligne de texte contenant
un retour chariot (peut-être)."

echo $chaine1
# Encore une autre ligne de texte contenant un retour chariot (peut-être).
#                                          ^
# Le retour chariot est devenu une espace.

# Merci pour cette indication, Steve Parker.

Note

Cette commande est une commande intégrée au shell, et n'est pas identique à /bin/echo, bien que son comportement soit similaire.

bash$ type -a echo
echo is a shell builtin
 echo is /bin/echo
              

printf

La commande printf, un print formaté, est un echo amélioré. C'est une variante limitée de la fonction printf() de la bibliothèque du langage C, et sa syntaxe est un peu différente.

printf format-string... parametre...

Il s'agit de la version intégrée à Bash de la commande /bin/printf ou /usr/bin/printf. Voir la page de manuel pour printf (la commande système) pour un éclairage détaillé.

Attention

Les anciennes versions de Bash peuvent ne pas supporter printf.

Exemple 15.2. printf en action

#!/bin/bash
# printf demo

PI=3.14159265358979
ConstanteDecimale=31373
Message1="Greetings,"
Message2="Earthling."

echo

printf "Pi avec deux décimales = %1.2f" $PI
echo
printf "Pi avec neuf décimales = %1.9f" $PI  # Il arrondit même correctement.

printf "\n"                                  # Affiche un retour chariot.
                                             # Équivalent à 'echo'.

printf "Constante = \t%d\n" $ConstanteDecimale  # Insère une tabulation (\t).

printf "%s %s \n" $Message1 $Message2

echo

# ==========================================#
# Simulation de la fonction C, sprintf().
# Changer une variable avec une chaîne de caractères formatée.

echo 

Pi12=$(printf "%1.12f" $PI)
echo "Pi avec 12 décimales = $Pi12"      # Erreur d'arrondi !

Msg=`printf "%s %s \n" $Message1 $Message2`
echo $Msg; echo $Msg

#  La fonction 'sprintf' est maintenant accessible en tant que module chargeable
#+ de Bash mais ce n'est pas portable.

exit 0

Formater les messages d'erreur est une application utile de printf

E_MAUVAISREP=85

var=repertoire_inexistant

error()
{
  printf "$@" >&2
  # Formate les paramètres de position passés et les envoie vers stderr.
  echo
  exit $E_MAUVAISREP
}

cd $var || error $"Ne peut aller dans %s." "$var"

# Merci, S.C.

Voir aussi Exemple 36.15, « Barre de progression ».

read

« Lit » la valeur d'une variable à partir de stdin, c'est-à-dire récupère interactivement les entrées à partir du clavier. L'option -a permet à read de lire des variables tableau (voir l'Exemple 27.5, « Quelques propriétés spéciales des tableaux »).

Exemple 15.3. Affectation d'une variable, en utilisant read

#!/bin/bash
# "Lire" des variables.

echo -n "Entrez la valeur de la variable 'var1' : "
# L'option -n d'echo supprime le retour chariot.

read var1
#  Notez qu'il n'y a pas de '$' devant var1 car elle est en train d'être
#+ initialisée.

echo "var1 = $var1"


echo

# Une simple instruction 'read' peut initialiser plusieurs variables.
echo -n "Entrez les valeurs des variables 'var2' et 'var3' " \
   "(séparées par des espaces ou des tabulations): "
read var2 var3
echo "var2 = $var2      var3 = $var3"
#  Si vous entrez seulement une valeur,
#+ les autres variables resteront non initialisées (null).

exit 0

Un read sans variable associée assigne son entrée à la variable dédiée $REPLY.

Exemple 15.4. Qu'arrive-t'il quand read n'a pas de variable

#!/bin/bash
# read-novar.sh

echo

# ------------------------------ #
echo -n "Saisissez une valeur : "
read var
echo "\"var\" = "$var""
# Tout se passe comme convenu.
# ------------------------------ #

echo

# ------------------------------------------------------------------- #
echo -n "Saisissez une nouvelle valeur : "
read           #  Aucune variable n'est donnée à 'read', donc...
               #+ La saisie par 'read' est affectée à la variable par défaut, $REPLY.
var="$REPLY"
echo "\"var\" = "$var""
# Ceci est équivalent au premier bloc de code.
# ------------------------------------------------------------------- #

echo
echo "========================="
echo


#  Cet exemple est similaire au script "reply.sh".
#  Néanmoins, celui-ci montre que $REPLY est disponible
#+ même après un 'read' dans une variable de la façon classique.

# ================================================================= #

#  Dans certaines instances, vous pourriez souhaiter ignorer la première valeur lue.
#  Dans de tels cas, ignorez tout simplement la variable $REPLY.

{ # Bloc de code.
read            # Ligne 1, à ignorer
read ligne2     # Ligne 2, sauvegarder dans la variable.
  } <$0
echo "La ligne 2 de ce script est :"
echo "$ligne2"  #   # read-novar.sh
echo            #   #!/bin/bash  ligne ignorée.

# Voir aussi le script soundcard-on.sh.

exit 0

Normalement, saisir un \ supprime le retour chariot lors de la saisie suite à un read. Avec l'option -r, le caractère \ saisi sera interprété littéralement.

Exemple 15.5. Lecture de plusieurs lignes par read

#!/bin/bash

echo

echo "Saisissez une chaîne de caractères terminée par un \\, puis appuyez sur ENTER."
echo "Ensuite, saisissez une deuxième chaîne de caractères (sans \\ cette fois), " \
  "puis appuyez de nouveau sur ENTER."
read var1     # Le "\" supprime le retour chariot lors de la lecture de $var1.
              #     première ligne \
              #     deuxième ligne

echo "var1 = $var1"
#     var1 = première ligne deuxième ligne

#  Pour chaque ligne terminée par un "\",
#+ vous obtenez une invite sur la ligne suivante pour continuer votre entrée
#+ dans var1.

echo; echo

echo "Saisissez une autre chaîne de caractères terminée par un \\ , puis appuyez sur ENTER."
read -r var2  # L'option -r fait que le "\" est lu littéralement.
              #     première ligne \

echo "var2 = $var2"
#     var2 = première ligne \

# La saisie de données se termine avec le premier ENTER.

echo 

exit 0

La commande read a quelques options intéressantes permettant d'afficher une invite et même de lire des frappes clavier sans appuyer sur ENTER.

# Lit une touche sans avoir besoin d'ENTER.

read -s -n1 -p "Appuyez sur une touche " touche
echo; echo "La touche était "\"$touche\""."

# L'option -s permet de supprimer l'écho.
# L'option -n N signifie que seuls N caractères sont acceptés en entrée.
# L'option -p permet l'affichage d'une invite avant de lire l'entrée.

#  Utiliser ces options est assez complexe car elles nécessitent d'être saisies dans le
#+ bon ordre.

L'option -n pour read permet aussi la détection des flèches de direction et certaines des autres touches inhabituelles.

Exemple 15.6. Détecter les flèches de direction

#!/bin/bash
# arrow-detect.sh : Détecte les flèches du clavier et quelques autres touches.
# Merci, Sandro Magi, pour m'avoir montré comment faire.

# --------------------------------------------
# Codes générés par l'appui sur les touches.
flechehaut='\[A'
flechebas='\[B'
flechedroite='\[C'
flechegauche='\[D'
insert='\[2'
delete='\[3'
# --------------------------------------------

SUCCES=0
AUTRE=65

echo -n "Appuyer sur une touche...  "
#  Il est possible qu'il faille appuyer aussi sur ENTER si une touche non gérée 
#+ ici est utilisée.
read -n3 touche                      # Lit 3 caractères.

echo -n "$touche" | grep "$flechehaut"  # Vérifie si un code est détecté.
if [ "$?" -eq $SUCCES ]
then
  echo "Appui sur la touche flèche haut."
  exit $SUCCES
fi

echo -n "$touche" | grep "$flechebas"
if [ "$?" -eq $SUCCES ]
then
  echo "Appui sur la touche flèche bas."
  exit $SUCCES
fi

echo -n "$touche" | grep "$flechedroite"
if [ "$?" -eq $SUCCES ]
then
  echo "Appui sur la touche flèche droite."
  exit $SUCCES
fi

echo -n "$touche" | grep "$flechegauche"
if [ "$?" -eq $SUCCES ]
then
  echo "Appui sur la touche flèche gauche."
  exit $SUCCES
fi

echo -n "$touche" | grep "$insert"
if [ "$?" -eq $SUCCES ]
then
  echo "Appui sur la touche \"Insert\"."
  exit $SUCCES
fi

echo -n "$touche" | grep "$delete"
if [ "$?" -eq $SUCCES ]
then
  echo "Appui sur la touche \"Delete\"."
  exit $SUCCES
fi


echo "Autre touche."

exit $AUTRE

# ========================================= #

#  Mark Alexander vient avec une version
#+ simplifiée du script ci-dessus (Merci !).
#  Cela supprime le besoin du grep.

#!/bin/bash

  flechehaut=$'\x1b[A'
  flechebas=$'\x1b[B'
  flechegauche=$'\x1b[D'
  flechedroite=$'\x1b[C'

  read -s -n3 -p "Appuyez sur une flèche : " x

  case "$x" in
  $flechehaut)
     echo "Vous avez appuyé sur la flèche haute"
     ;;
  $flechebas)
     echo "Vous avez appuyé sur la flèche basse"
     ;;
  $flechegauche)
     echo "Vous avez appuyé sur la flèche gauche"
     ;;
  $flechedroite)
     echo "Vous avez appuyé sur la flèche droite"
     ;;
  esac

exit $?

# ========================================= #

# Antonio Macchi propose une alternative plus simple.

#!/bin/bash

while true
do
  read -sn1 a
  test "$a" == `echo -en "\e"` || continue
  read -sn1 a
  test "$a" == "[" || continue
  read -sn1 a
  case "$a" in
    A)  echo "haut";;
    B)  echo "bas";;
    C)  echo "droite";;
    D)  echo "gauche";;
  esac
done

# ========================================= #

#  Exercice :
#  ---------
#  1) Ajouter la détection des touches "Home", "End", "PgUp" et "PgDn".

L'option -n de read ne détectera pas la touche Entrée (saut de ligne).

L'option -t de read permet de limiter le temps de réponse (voir l'Exemple 9.4, « Lecture avec délai » et Exemple A.41, « Quacky : un jeu de mots de type Perquackey »).

L'option -u prend comme argument le descripteur de fichier du fichier destination.

La commande read peut aussi « lire » l'entrée à partir d'un fichier redirigé vers stdin. Si le fichier contient plus d'une ligne, seule la première ligne est affectée à la variable. Si read a plus d'un paramètre, alors chacune des variables se voit assignée une suite de mots séparés par des espaces blancs. Attention !

Exemple 15.7. Utiliser read avec la redirection de fichier

#!/bin/bash

read var1 < fichier-donnees
echo "var1 = $var1"
# var1 initialisée avec la première ligne du fichier d'entrées "fichier-donnees"

read var2 var3 < fichier-donnees
echo "var2 = $var2   var3 = $var3"
# Notez le comportement non intuitif de "read" ici.
# 1) Revient au début du fichier d'entrée.
# 2) Chaque variable est maintenant initialisée avec une chaîne correspondante,
#    séparée par des espaces blancs, plutôt qu'avec une ligne complète de texte.
# 3) La variable finale obtient le reste de la ligne.
# 4) S'il existe plus de variables à initialiser que de chaînes terminées par
#    une espace blanche sur la première ligne du fichier, alors les variables
#    supplémentaires restent vides.

echo "------------------------------------------------"

# Comment résoudre le problème ci-dessus avec une boucle :
while read ligne
do
  echo "$ligne"
done <fichier-donnees
# Merci à Heiner Steven de nous l'avoir proposé.

echo "------------------------------------------------"

#  Utilisez $IFS (variable comprenant le séparateur interne de fichier, soit
#+ Internal File Separator) pour diviser une ligne d'entrée pour "read", si vous
#+ ne voulez pas des espaces blancs par défaut.

echo "Liste de tous les utilisateurs:"
OIFS=$IFS; IFS=:       # /etc/passwd utilise ":" comme séparateur de champ.
while read nom motpasse uid gid nomcomplet ignore
do
  echo "$nom ($nomcomplet)"
done </etc/passwd   # Redirection d'entrées/sorties.
IFS=$OIFS              # Restaure l'$IFS original.
# Cette astuce vient aussi de Heiner Steven.



#  Initialiser la variable $IFS à l'intérieur même de la boucle élimine le
#+ besoin d'enregistrer l'$IFS originale dans une variable temporaire.
#  Merci à Dim Segebart de nous l'avoir indiqué.
echo "------------------------------------------------"
echo "Liste de tous les utilisateurs:"

while IFS=: read nom motpasse uid gid nomcomplet ignore
do
  echo "$nom ($nomcomplet)"
done </etc/passwd   # Redirection d'entrées/sorties.

echo
echo "\$IFS vaut toujours $IFS"

exit 0

Note

Envoyer la sortie d'un tube vers une commande read en utilisant echo pour définir des variables échouera.

Cependant, envoyer la sortie d'un cat à travers un tube semble fonctionner.

cat fichier1 fichier2 |
while read ligne
do
echo $ligne
done

Néanmoins, comme Bjön Eriksson le montre :

Exemple 15.8. Problèmes lors de la lecture d'un tube

#!/bin/sh
# readpipe.sh
# This example contributed by Bjon Eriksson.

last="(null)"
cat $0 |
while read line
do
    echo "{$line}"
    last=$line
done
printf "\nAll done, last:$last\n"

exit 0  # End of code.
        # (Partial) output of script follows.
        # The 'echo' supplies extra brackets.

#############################################

./readpipe.sh 

{#!/bin/sh}
{last="(null)"}
{cat $0 |}
{while read line}
{do}
{echo "{$line}"}
{last=$line}
{done}
{printf "nAll done, last:$lastn"}


All done, last:(null)

The variable (last) is set within the subshell but unset outside.

Le script gendiff, qu'on trouve normalement dans /usr/bin sur la plupart des distributions Linux, envoie la sortie de find via un tube vers la construction while read.

find $1 \( -name "*$2" -o -name ".*$2" \) -print |
while read f; do
. . .

Astuce

Il est possible de coller le texte dans le champ en entrée d'un read (mais pas de lignes multiples !). Voir Exemple A.38, « Générateur de fichiers pad pour les auteurs de shareware ».

Système de fichiers

cd

La commande familière de changement de répertoire, cd, trouve son intérêt dans les scripts où l'exécution d'une commande requiert d'être dans un répertoire spécifique.

(cd /source/repertoire && tar cf - . ) | (cd /dest/repertoire && tar xpvf -)

[à partir de l'exemple précédemment cité d'Alan Cox]

L'option -P (physique) pour cd fait qu'il ignore les liens symboliques.

cd - affecte la variable $OLDPWD.

Attention

La commande cd ne fonctionne pas de la façon attendue si deux slashs se suivent.

bash$ cd //
bash$ pwd
//
              

La sortie devrait être /. Ceci est un problème à la fois à partir de la ligne de commande et dans un script.

pwd

Print Working Directory (NdT : Affiche le répertoire courant). Cela donne le répertoire courant de l'utilisateur (ou du script) (voir l'Exemple 15.9, « Modifier le répertoire courant »). L'effet est identique à la lecture de la variable intégrée $PWD.

pushd, popd, dirs

Cet ensemble de commandes est un mécanisme pour enregistrer les répertoires de travail, un moyen pour revenir en arrière ou aller en avant à travers les répertoires d'une manière ordonnée. Une pile LIFO est utilisée pour conserver la trace des noms des répertoires. Des options permettent diverses manipulations sur la pile de répertoires.

pushd nom-rep enregistre le chemin de nom-rep dans la pile de répertoires et change le répertoire courant par nom-rep

popd supprime (enlève du haut) le chemin du dernier répertoire et, en même temps, change de répertoire courant par celui qui vient d'être récupéré dans la pile.

dirs liste le contenu de la pile de répertoires (comparez ceci avec la variable $DIRSTACK). Une commande pushd ou popd satisfaite va automatiquement appeler dirs.

Les scripts requérant différents changements du répertoire courant sans coder en dur les changements de nom de répertoire peuvent faire un bon usage de ces commandes. Notez que la variable tableau implicite $DIRSTACK, accessible depuis un script, tient le contenu de la pile des répertoires.

Exemple 15.9. Modifier le répertoire courant

#!/bin/bash

rep1=/usr/local
rep2=/var/spool

pushd $rep1
# Fera un 'dirs' automatiquement (liste la pile des répertoires sur stdout).
echo "Maintenant dans le répertoire `pwd`." # Utilise les guillemets inverses
                                            # pour 'pwd'.

# Maintenant, faisons certaines choses dans le répertoire 'rep1'.
pushd $rep2
echo "Maintenant dans le répertoire `pwd`."

# Maintenant, faisons certaines choses dans le répertoire 'rep2'.
echo "L'entrée supérieure du tableau DIRSTACK est $DIRSTACK."
popd
echo "Maintenant revenu dans le répertoire `pwd`."

# Maintenant, faisons certaines choses de plus dans le répertoire 'rep1'.
popd
echo "Maintenant revenu dans le répertoire original `pwd`."

exit 0

# Que se passe-t'il si vous n'exécutez pas 'popd' puis quittez le script ?
# Dans quel répertoire vous trouverez-vous ? Pourquoi ?

Variables

let

La commande let réalise des opérations arithmétiques sur les variables. ^[59] Dans beaucoup de cas, elle fonctionne comme une version simplifiée de expr.

Exemple 15.10. Laisser let faire un peu d'arithmétique.

#!/bin/bash

echo

let a=11            # Identique à 'a=11'
let a=a+5           # Équivalent à  let "a = a + 5"
                    # (double guillemets et espaces pour le rendre plus lisible)
echo "11 + 5 = $a"  # 16

let "a <<= 3"       # Équivalent à  let "a = a << 3"
echo "\"\$a\" (=16) décalé de 3 places = $a"
                    # 128

let "a /= 4"        # Équivalent à  let "a = a / 4"
echo "128 / 4 = $a" # 32

let "a -= 5"        # Équivalent à  let "a = a - 5"
echo "32 - 5 = $a"  # 27

let "a = a * 10"    # Équivalent à  let "a = a * 10"
echo "27 * 10 = $a" # 270

let "a %= 8"        # Équivalent à  let "a = a % 8"
echo "270 modulo 8 = $a  (270 / 8 = 33, reste $a)"
                    # 6

echo

exit 0

Attention

La commande let peut, dans certains cas, renvoyer un état de sortie anormal.

# Ainsi qu'Evgeniy Ivanov le remarque :

var=0
echo $?     # 0
            # Normal.

let var++
echo $?     # 1
            # La commande a réussi, donc pourquoi pas $?=0 ???
            # C'est une anomalie !

let var++
echo $?     # 0
            # Normal.


# Et de même...

let var=0
echo $?     # 1
            # La commande a réussi, donc pourquoi pas $?=0 ???
#  Cependant, comme le remarque Jeff Gorak,
#+ c'est une partie des spécifications de 'let'...
# "Si le dernier ARG vaut 0, let renvoie 1;
#  dans les autres cas, let renvoie 0." ['help let']>

eval

eval arg1 [arg2] ... [argN]

Combine les arguments d'une expression ou liste d'expressions et les évalue. Toutes les variables contenues dans l'expression sont étendues. Le résultat produit est la conversion d'une chaîne de caractère en une commande.

Astuce

La commande eval peut servir à générer du code en ligne de commande ou à l'intérieur d'un script.

bash$ commande="ps ax"
bash$ processus="ps ax"
bash$ eval "$commande" | grep "$processus"
26973 pts/3    R+     0:00 grep --color ps ax
 26974 pts/3    R+     0:00 ps ax
              

Chaque appel à eval force à la ré-évaluation de ses arguments.

a='$b'
b='$c'
c=d

echo $a             # $b
                    # Premier niveau.
eval echo $a        # $c
                    # Second niveau.
eval eval echo $a   # d
                    # Troisième niveau.

# Merci, E. Choroba.

Exemple 15.11. Montrer l'effet d'eval

#!/bin/bash
# Exercising "eval" ...

y=`eval ls -l`  # Similaire à y=`ls -l`
echo $y         # mais les retours chariot sont supprimés parce que la variable
                # n'est pas entre guillemets.
echo
echo "$y"       # Les retours chariot sont préservés lorsque la variable se
                # trouve entre guillemets.

echo; echo

y=`eval df`     # Similaire à y=`df`
echo $y         # mais les retours chariot ont été supprimés.

#  Quand LF n'est pas préservé, il peut être plus simple d'analyser la sortie,
#+ en utilisant des outils comme "awk".

echo
echo "==========================================================="
echo

# Maintenant, nous vous montrons quoi faire d'utile avec "eval"...
# (Merci E. Choroba!)

version=3.4     #  Pouvons-nous répartir la version en deux parties, la version
                #+ majeure et la version mineure en une seule commande ?
echo "version = $version"
eval majeur=${version/./;mineur=}     #  Remplace '.' dans la version par ';mineur='
                                      #  La substitution ramène '3; minor=4'
                                      #+ donc eval donne mineur=4, majeur=3
echo majeur: $major, mineur: $mineur  #  majeur: 3, mineur: 4

Exemple 15.12. Utilisation de eval pour sélectionner des variables

#!/bin/bash
# arr-choice.sh

#  Passing arguments to a function to select
#+ one particular variable out of a group.

arr0=( 10 11 12 13 14 15 )
arr1=( 20 21 22 23 24 25 )
arr2=( 30 31 32 33 34 35 )
#       0  1  2  3  4  5      Element number (zero-indexed)


choose_array ()
{
  eval array_member=\${arr${array_number}[element_number]}
  #                 ^       ^^^^^^^^^^^^
  #  Using eval to construct the name of a variable,
  #+ in this particular case, an array name.

  echo "Element $element_number of array $array_number is $array_member"
} #  Function can be rewritten to take parameters.

array_number=0    # First array.
element_number=3
choose_array      # 13

array_number=2    # Third array.
element_number=4
choose_array      # 34

array_number=3    # Null array (arr3 not allocated).
element_number=4
choose_array      # (null)

# Thank you, Antonio Macchi, for pointing this out.

Exemple 15.13. Afficher les paramètres en ligne de commande

#!/bin/bash
# echo-params.sh

# Call this script with a few command-line parameters.
# For example:
#     sh echo-params.sh first second third fourth fifth

params=$#              # Number of command-line parameters.
param=1                # Start at first command-line param.

while [ "$param" -le "$params" ]
do
  echo -n "Command-line parameter "
  echo -n \$$param     #  Gives only the *name* of variable.
#         ^^^          #  $1, $2, $3, etc.
                       #  Why?
                       #  \$ escapes the first "$"
                       #+ so it echoes literally,
                       #+ and $param dereferences "$param" . . .
                       #+ . . . as expected.
  echo -n " = "
  eval echo \$$param   #  Gives the *value* of variable.
# ^^^^      ^^^        #  The "eval" forces the *evaluation*
                       #+ of \$$
                       #+ as an indirect variable reference.

(( param ++ ))         # On to the next.
done

exit $?

# =================================================

$ sh echo-params.sh first second third fourth fifth
Command-line parameter $1 = first
Command-line parameter $2 = second
Command-line parameter $3 = third
Command-line parameter $4 = fourth
Command-line parameter $5 = fifth

Exemple 15.14. Forcer une déconnexion

#!/bin/bash
# Tuer ppp pour forcer une déconnexion

# Le script doit être exécuté en tant qu'utilisateur root.

killppp="eval kill -9 `ps ax | awk '/ppp/ { print $1 }'`"
#                     -------- ID du processus ppp -----  

$killppp                  # Cette variable est maintenant une commande.


# Les opérations suivantes doivent être faites en tant qu'utilisateur root.

chmod 666 /dev/ttyS3      #  Restaure les droits de lecture/écriture, sinon que
                          #+ se passe-t'il ?
#  Comme nous lançons un signal SIGKILL à ppp après avoir changé les droits sur
#+ le port série, nous restaurons les droits à l'état initial.

rm /var/lock/LCK..ttyS3   #  Supprime le fichier de verrouillage du port série.
                          #+ Pourquoi ?

#  Note :
#  Suivant le matériel et même la version du noyau,
#+ le port du modem de votre machine pourrait être différent --
#+ /dev/ttyS1 ou /dev/ttyS2.

exit 0

# Exercices:
# ---------
# 1) Que le script vérifie si l'utilisateur root l'appelle.
# 2) Faire une vérification concernant le processus à tuer (qu'il existe bien).
# 3) Écrivez une autre version de ce script basé sur 'fuser' :
#+   if [ fuser -s /dev/modem ]; then ...

Exemple 15.15. Une version de rot13

#!/bin/bash
# Une version de "rot13" utilisant 'eval'.
# Comparez à l'exemple "rot13.sh".

setvar_rot_13()              # "rot13" scrambling
{
  local nomvar=$1 valeurvar=$2
  eval $nomvar='$(echo "$valeurvar" | tr a-z n-za-m)'
}


setvar_rot_13 var "foobar"   # Lancez "foobar" avec rot13.
echo $var                    # sbbone

setvar_rot_13 var "$var"     # Lance "sbbone" à travers rot13.
                             # Revenu à la variable originale.
echo $var                    # foobar

# Exemple de Stephane Chazelas.
# Modifié par l'auteur du document.

exit 0

Exemple A.53, « Pratiquer le code Morse » utilise eval pour convertir array des éléments en une liste de commandes.

La commande eval apparaît dans l'ancienne syntaxe du référencement indirect.

eval var=\$$var

Astuce

La commande eval peut être utilisée pour paramétriser le développement des accolades.

Attention

La commande eval est risquée et devrait normalement être évitée quand il existe une alternative raisonnable. Un eval $COMMANDES exécute le contenu de COMMANDES, qui pourrait contenir des surprises désagréables comme rm -rf *. Lancer eval sur un code inconnu écrit par des personnes inconnues vous fait prendre des risques importants.

set

La commande set modifie la valeur de variables/options internes au script. Une utilisation est de modifier les options qui déterminent le comportement du script. Une autre application est d'affecter aux paramètres de position du script le résultat d'une commande (set `commande`). Le script peut alors séparer les différents champs de la sortie de commande.

Exemple 15.16. Utiliser set avec les paramètres de position

#!/bin/bash

# script "set-test"

# Appeler ce script avec trois paramètres en ligne de commande,
# par exemple, "./set-test one two three".

echo
echo "Paramètres de position avant set \`uname -a\` :"
echo "Argument #1 = $1"
echo "Argument #2 = $2"
echo "Argument #3 = $3"


set `uname -a` # Configure les paramètres de position par rapport à la sortie
               # de la commande `uname -a`

echo $_        # inconnu
# Drapeaux initialisés dans le script.

echo "Paramètres de position après set \`uname -a\` :"
# $1, $2, $3, etc. reinitialisés suivant le résultat de `uname -a`
echo "Champ #1 de 'uname -a' = $1"
echo "Champ #2 de 'uname -a' = $2"
echo "Champ #3 de 'uname -a' = $3"
echo ---
echo $_        # ---
echo

exit 0

Plus de jeu avec les paramètres de position.

Exemple 15.17. Inverser les paramètres de position

#!/bin/bash
# revposparams.sh: Reverse positional parameters.
# Script by Dan Jacobson, with stylistic revisions by document author.


set a\ b c d\ e;
#     ^      ^     Spaces escaped 
#       ^ ^        Spaces not escaped
OIFS=$IFS; IFS=:;
#              ^   Saving old IFS and setting new one.

echo

until [ $# -eq 0 ]
do          #      Step through positional parameters.
  echo "### k0 = "$k""     # Before
  k=$1:$k;  #      Append each pos param to loop variable.
#     ^
  echo "### k = "$k""      # After
  echo
  shift;
done

set $k  #  Set new positional parameters.
echo -
echo $# #  Count of positional parameters.
echo -
echo

for i   #  Omitting the "in list" sets the variable -- i --
        #+ to the positional parameters.
do
  echo $i  # Display new positional parameters.
done

IFS=$OIFS  # Restore IFS.

#  Question:
#  Is it necessary to set an new IFS, internal field separator,
#+ in order for this script to work properly?
#  What happens if you don't? Try it.
#  And, why use the new IFS -- a colon -- in line 17,
#+ to append to the loop variable?
#  What is the purpose of this?

exit 0

$ ./revposparams.sh

### k0 = 
### k = a b

### k0 = a b
### k = c a b

### k0 = c a b
### k = d e c a b

-
3
-

d e
c
a b

Invoquer set sans aucune option ou argument liste simplement toutes les variables d'environnement ainsi que d'autres variables qui ont été initialisées.

bash$ set
AUTHORCOPY=/home/bozo/posts
 BASH=/bin/bash
 BASH_VERSION=$'2.05.8(1)-release'
 ...
 XAUTHORITY=/home/bozo/.Xauthority
 _=/etc/bashrc
 variable22=abc
 variable23=xzy
              

Utiliser set avec l'option -- affecte explicitement le contenu d'une variable aux paramètres de position. Si aucune variable ne suit --, cela déconfigure les paramètres de positions.

Exemple 15.18. Réaffecter les paramètres de position

#!/bin/bash

variable="un deux trois quatre cinq"

set -- $variable
# Initialise les paramètres de position suivant le contenu de "$variable".

premier_param=$1
deuxieme_param=$2
shift; shift       # Shift fait passer les deux premiers paramètres de position.
# shift 2 fonctionne aussi
params_restant="$*"

echo
echo "premier paramètre = $premier_param"             # un
echo "deuxième paramètre = $deuxieme_param"           # deux
echo "paramètres restants = $params_restant"          # trois quatre cinq

echo; echo

# De nouveau.
set -- $variable
premier_param=$1
deuxieme_param=$2
echo "premier paramètre = $premier_param"             # un
echo "deuxième paramètre = $deuxieme_param"           # deux

# ======================================================

set --
# Désinitialise les paramètres de position si aucun variable n'est spécifiée.

premier_param=$1
deuxieme_param=$2
echo "premier paramètre = $premier_param"             # (valeur null)
echo "deuxième paramètre = $deuxieme_param"           # (valeur null)

exit 0

Voir aussi l'Exemple 11.2, « Boucle for avec deux paramètres dans chaque élément de la [liste] » et l'Exemple 16.56, « Utiliser getopt pour analyser les paramètres de la ligne de commande ».

unset

La commande unset supprime une variable shell en y affectant réellement la valeur null. Notez que cette commande n'affecte pas les paramètres de position.

bash$ unset PATH

bash$ echo $PATH




bash$ 

Exemple 15.19. « Dés-assigner » une variable

#!/bin/bash
# unset.sh: Dés-initialiser une variable.

variable=hello                       # Initialisée.
echo "variable = $variable"

unset variable                       # Dés-initialisée.
                                     # Même effet que : variable=
echo "(unset) variable = $variable"  # $variable est null.

if [ -z "$variable" ]                # Tente un test de longueur de chaîne.
then
  echo "\$variable a une taille nulle."
fi

exit 0

Note

Dans la plupart des cas, pour une variable être undeclared ou avoir été unset, cela revient au même. Cependant, l'expression de substitution de paramètre ${parameter:-default} fait parfois une distinction entre les deux.

export

La commande export ^[60] rend disponibles des variables aux processus fils du script ou shell en cours d'exécution. Une utilisation importante de la commande export se trouve dans les fichiers de démarrage pour initialiser et rendre accessible les variables d'environnement aux processus utilisateur suivants.

Attention

Malheureusement, il n'existe pas de moyens pour exporter des variables dans le processus parent, vers le processus appelant ou qui a exécuté le script ou le shell.

Exemple 15.20. Utiliser export pour passer une variable à un script awk embarqué

#!/bin/bash

# Encore une autre version du script "column totaler" (col-totaler.sh)
# qui ajoute une colonne spécifiée (de nombres) dans le fichier cible.
#  Il utilise l'environnement pour passer une variable de script à 'awk'...
#+ et place le script awk dans une variable.

ARGS=2
E_MAUVAISARGS=65

if [ $# -ne "$ARGS" ] # Vérifie le bon nombre d'arguments de la ligne de
                      # commande.
then
   echo "Usage: `basename $0` nomfichier numéro_colonne"
   exit $E_MAUVAISARGS
fi

nomfichier=$1
numero_colonne=$2

#===== Identique au script original, jusqu'à ce point =====#

export numero_colonne
#  Exporte le numéro de colonne dans l'environnement de façon à ce qu'il soit
#+ disponible plus tard.


# ------------------------------------------------
awkscript='{ total += $ENVIRON["numero_colonne"] }
END { print total }' $nomfichier
# Oui, une variable peut contenir un script awk.
# ------------------------------------------------

# Maintenant, exécute le script awk
awk "$awkscript" "$nomfichier"


# Merci, Stephane Chazelas.

exit 0

Astuce

Il est possible d'initialiser et d'exporter des variables lors de la même opération, en faisant export var1=xxx.

Néanmoins, comme l'a indiqué Greg Keraunen, dans certaines situations, ceci peut avoir un effet différent que d'initialiser une variable, puis de l'exporter.

bash$ export var=(a b); echo ${var[0]}
(a b)



bash$ var=(a b); export var; echo ${var[0]}
a
              

Note

Une variable à exporter peut nécessiter un traitement spécial. Voir Exemple L.2, « Fichier .bash_profile ».

declare, typeset

Les commandes declare et typeset spécifient et/ou restreignent les propriétés des variables.

readonly

Identique à declare -r, configure une variable en lecture-seule ou, du coup, la transforme en constante. Essayer de modifier la variable échoue avec un message d'erreur. C'est l'équivalent shell du type const pour le langage C.

getopts

Ce puissant outil analyse les arguments en ligne de commande passés au script. C'est l'équivalent Bash de la commande externe getopt et de la fonction getopt familière aux programmeurs C. Il permet de passer et de concaténer de nombreuses options ^[61] et les arguments associés à un script (par exemple nomscript -abc -e /usr/local).

La syntaxe getopts utilise deux variables implicites. $OPTIND est le pointeur de l'argument (OPTion INDex) et $OPTARG (OPTion ARGument) l'argument (optionnel) attaché à une option. Deux points suivant le nom de l'option lors de la déclaration marque cette option comme ayant un argument associé.

L'expression getopts a lieu généralement dans une boucle while, qui analyse les options et les arguments un à un, incrémente la variable implicite $OPTIND pour pointer vers la suivante.

Note

1. Les arguments passés au script sur la ligne de commande doivent être précédés d'un tiret (-). Ce préfixe - permet à getopts de reconnaître les arguments en ligne de commande comme des options. En fait, getopts ne traite pas les arguments non préfixés par - et arrête l'analyse des options au premier argument non préfixé rencontré.

2. La syntaxe getopts diffère légèrement de la boucle while standard par le fait qu'il lui manque les crochets de condition.

3. La construction getopts remplace avantageusement la commande getopt traditionnelle, en apportant plus de fonctionnalités.

while getopts ":abcde:fg" Option
# Déclaration initiale.
# a, b, c, d, e, f et g sont les options (indicateurs) attendues.
# Le : après l'option 'e' montre qu'il y aura un argument associé.
do
  case $Option in
    a ) # Fait quelque chose avec la variable 'a'.
    b ) # Fait quelque chose avec la variable 'b'.
    ...
    e)  # Fait quelque chose avec la variable 'e', et aussi avec $OPTARG,
        # qui est l'argument associé passé avec l'option 'e'.
    ...
    g ) # Fait quelque chose avec la variable 'g'.
  esac
done
shift $(($OPTIND - 1))
# Déplace le pointeur d'argument au suivant.

# Tout ceci n'est pas aussi compliqué qu'il n'y paraît <grin>.

Exemple 15.21. Utiliser getopts pour lire les options/arguments passés à un script

#!/bin/bash
#+ S'exercer avec getopts et OPTIND
#+ Script modifié le 10/09/03 suivant la suggestion de Bill Gradwohl.

#  Nous observons ici comment 'getopts' analyse les arguments en ligne de
#+ commande du script.
#  Les arguments sont analysés comme des "options" (flags) et leurs arguments
#+ associés.

# Essayez d'appeller ce script avec
# 'nomscript -mn'
# 'nomscript -oq qOption' (qOption peut être une chaîne de caractère arbitraire.)
# 'nomscript -qXXX -r'
#
# 'nomscript -qr'    - Résultat inattendu, prend "r" comme argument à l'option
#                      "q"
# 'nomscript -q -r'  - Résultat inattendu, identique à ci-dessus
# 'scriptname -mnop -mnop'  - Résultat inattendu
# (OPTIND est incapable d'indiquer d'où provient une option)

#  Si une option attend un argument ("flag:"), alors il récupèrera tout ce qui
#+ se trouve ensuite sur la ligne de commandes.

SANS_ARGS=0 
E_ERREUROPTION=65

if [ $# -eq "$SANS_ARGS" ]  # Script appelé sans argument?
then
  echo "Usage: `basename $0` options (-mnopqrs)"
  exit $E_ERREUROPTION        # Sort et explique l'usage, si aucun argument(s)
                              # n'est donné.
fi  
# Usage: nomscript -options
# Note: tiret (-) nécessaire


while getopts ":mnopq:rs" Option
do
  case $Option in
    m     ) echo "Scénario #1: option -m-   [OPTIND=${OPTIND}]";;
    n | o ) echo "Scénario #2: option -$Option-   [OPTIND=${OPTIND}]";;
    p     ) echo "Scénario #3: option -p-   [OPTIND=${OPTIND}]";;
    q     ) echo "Scénario #4: option -q- \
avec l'argument \"$OPTARG\"   [OPTIND=${OPTIND}]";;
    # Notez que l'option 'q' doit avoir un argument associé,
    # sinon il aura la valeur par défaut.
    r | s ) echo "Scénario #5: option -$Option-"'';;
    *     ) echo "Option non implémentée.";;   # DEFAULT
  esac
done

shift $(($OPTIND - 1))
# Décrémente le pointeur d'argument de façon à ce qu'il pointe vers le prochain.
#  $1 référence maintenant le premier élément n'étant pas une option sur la
#+ ligne de commande si un tel élément existe.
 
 exit 0

#   Comme Bill Gradwohl le dit,
#  "Le mécanisme getopts vous permet de spécifier :  nomscript -mnop -mnop
#+  mais il n'y a pas de moyen de différencier d'où cela vient en utilisant
#+  OPTIND."

Comportement des scripts

source, . (commande point)

Cette commande, lorsqu'elle est appelée à partir de la ligne de commande, exécute un script. À l'intérieur d'un script, un source nom-fichier charge le fichier nom-fichier. Exécuter le source d'un fichier (point de commandes) importe le code dans le script, s'ajoutant au script (même effet que la directive #include dans un programme C). Le résultat est le même que si les lignes « sourcées » de code étaient présentes physiquement dans le corps du script. Ceci est utile dans les situations où de multiples scripts utilisent un fichier de données communes ou une bibliothèque de fonctions.

Exemple 15.22. « Inclure » un fichier de données

#!/bin/bash

. fichier-donnees    # charge un fichier de données.
# Même effet que "source fichier-donnees", mais plus portable.

#  Le fichier "fichier-donnees" doit être présent dans le répertoire courant,
#+ car il est référencé par rappor à son 'basename'.

# Maintenant, référençons quelques données à partir de ce fichier.

echo "variable1 (de fichier-donnees) = $variable1"
echo "variable3 (de fichier-donnees) = $variable3"

let "sum = $variable2 + $variable4"
echo "Somme de variable2 + variable4 (de fichier-donnees) = $sum"
echo "message1 (de fichier-donnees) est \"$message1\""
# Note:                                 guillemets échappés

print_message Ceci est la fonction message-print de fichier-donnees.


exit 0

Le fichier fichier-données pour l'Exemple 15.22, « « Inclure » un fichier de données », ci-dessus, doit être présent dans le même répertoire.

# This is a data file loaded by a script.
# Files of this type may contain variables, functions, etc.
# It may be loaded with a 'source' or '.' command by a shell script.

# Let's initialize some variables.

variable1=22
variable2=474
variable3=5
variable4=97

message1="Hello, how are you?"
message2="Enough for now. Goodbye."

print_message ()
{
# Echoes any message passed to it.

  if [ -z "$1" ]
  then
    return 1
    # Error, if argument missing.
  fi

  echo

  until [ -z "$1" ]
  do
    # Step through arguments passed to function.
    echo -n "$1"
    # Echo args one at a time, suppressing line feeds.
    echo -n " "
    # Insert spaces between words.
    shift
    # Next one.
  done  

  echo

  return 0
}  

Si le fichier inclus est lui-même un script exécutable, alors il sera exécuté, puis renverra le contrôle au script qui l'a appelé. Un script exécutable inclus pourrait utiliser un return dans ce but.

Des arguments pourraient être passés (en option) au fichier inclus en tant que paramètres de position.

source $fichier $arg1 arg2

Il est même possible pour un script de s'intégrer (se sourcer) lui-même, bien qu'il ne semble pas que cela ait la moindre application pratique.

Exemple 15.23. Un script (inutile) qui se charge lui-même

#!/bin/bash
# self-source.sh : un script qui s'exécute lui-même "récursivement."
# De "Stupid Script Tricks", Volume II.

NBTOURSMAX=100    # Nombre maximal de tours d'exécution.

echo -n  "$nb_tour  "
#  Lors du premier tour, ceci va juste afficher deux espaces car $nb_tour n'est
#+ toujours pas initialisé.

let "nb_tour += 1"
#  Suppose que la variable non initialisée $nb_tour peut être incrémentée la
#+ première fois.
#  Ceci fonctionne avec Bash et pdksh mais cela repose sur un comportement
#+ non portable (et certainement dangereux).
#  Il serait mieux d'initialiser $nb_tour à 0 avant de l'incrémenter.

while [ "$nb_tour" -le $NBTOURSMAX ]
do
  . $0   # Le script "s'inclut" lui-même, plutôt que de s'appeler.
         # ./$0 (qui serait une vraie récursion) ne fonctionne pas ici.
         # Pourquoi ?
done  

#  Ce qui arrive ici n'est pas réellement une récursion, car le script
#+ s'étend lui-même effectivement, c'est-à-dire que cela génère une nouvelle
#+ section de code, à chaque tour de la boucle 'while' lors du 'source' en ligne
#+ 20.
#
#  Bien sûr, le script interprète chaque nouvelle ligne incluse "#!" comme un
#+ commentaire, et non pas comme le début d'un nouveau script.

echo

exit 0   # L'effet très net est le comptage de 1 à 100.
         # Très impressionnant.

# Exercice :
# ---------
#  Écrire un script qui utilise cette astuce pour faire quelque chose de
#+ réellement utile.

exit

Termine un script sans condition. ^[62] La commande exit peut prendre de façon optionnelle un argument de type entier, qui est renvoyé au script en tant qu'état de sortie du script. C'est une bonne pratique de terminer tous les scripts, même les plus simples, avec un exit 0, indiquant un succès.

Note

Si un script se termine avec un exit sans argument, l'état de sortie est le statut de exit lors de son dernier lancement dans le script, sans compter le exit. C'est équivalent à un exit $?.

Note

Une commande exit peut aussi être utilisé pour terminer un sous-shell.

exec

Cette commande shell intégrée remplace le processus courant avec une commande spécifiée. Normalement, lorsque le shell rencontre une commande, il lance un processus fils pour exécuter la commande. En utilisant la commande intégrée exec, le shell n'exécute aucun processus fils et la commande bénéficiant du exec remplace purement et simplement le shell. Lorsqu'elle est utilisée dans un script, cela force la sortie (exit) du script lorsque la commande bénéficiant du exec se termine. ^[63]

Exemple 15.24. Effets d'exec

#!/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 15.25. 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 99   # Ne quittera pas ici.
          # Le code de retour ne sera pas 99.

Un exec sert aussi à réaffecter les descripteurs de fichiers. Par exemple, exec fichier-zzz remplace stdin par le fichier fichier-zzz.

Note

L'option -exec de 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 l'Exemple 25.1, « Alias à l'intérieur d'un script » et l'Exemple 25.2, « unalias : Configurer et supprimer un alias »). Elle apparaît souvent dans les fichiers de démarrage de Bash mais a aussi son utilité dans des scripts. Nécessite la version 2, ou ultérieure, de Bash.

shopt -s cdspell
# Permet des petites erreurs dans le nom des répertoires avec 'cd'
# Options : -s pour "set" (assigner), -u pour "unset" (désassigner)

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

caller

Placer une commande caller dans une fonction affiche des informations sur stdout à propos de celui qui a appelé cette fonction.

#!/bin/bash

fonction1 ()
{
  # À l'intérieur de fonction1 ().
  caller 0   # Parle-moi de lui.
}

fonction1    # Ligne 9 du script.

# 9 main test.sh
# ^                 Numéro de ligne où a eu lieu l'appel de la fonction.
#   ^^^^            Appelé depuis la partie "main" du script.
#        ^^^^^^^    Nom du script appelant.

caller 0     # N'a aucun effet parce qu'il n'est pas à l'intérieur d'une fonction.

Une commande caller peut aussi renvoyer des informations de l'appelant sur un script inclus à l'intérieur d'un autre script. De façon analogue à une fonction, ceci est un « appel de sous-routine ».

Cette commande est utile pour le débogage.

Commandes

true

Une commande qui renvoie un succès (zéro) comme état de sortie, mais ne fait rien d'autre.

bash$ true
bash$ echo $?
0
              

# Boucle sans fin
while true   # alias pour ":"
do
   operation-1
   operation-2
   ...
   operation-n
   # A besoin d'un moyen pour sortir de la boucle ou le script ne s'arrêtera pas.
done

false

Une commande qui renvoie un état de sortie correspondant à un échec, mais ne fait rien d'autre.

bash$ false
bash$ echo $?
1
              

# Tester "false"
if false
then
  echo "false évalué à \"true\""
else
  echo "false évalué à \"false\""
fi
# false s'évalue "false"


# Boucle while "false" (boucle nulle)
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 identifie « 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 identique.

bash$ type '['
[ is a shell builtin
bash$ type -a '['
[ is a shell builtin
 [ is /usr/bin/[


bash$ type type
type is a shell builtin
              

La commande type pout être utile pour tester si une certaine commande existe.

hash [cmds]

Enregistre le chemin des commandes marquées -- dans la table de hachage du shell. ^[64] -- donc le shell ou le script n'aura pas besoin de rechercher le $PATH sur les futurs appels à ces commandes. Quand hash est appelé sans arguments, il liste simplement les commandes qui ont été stockées. L'option -r réinitialise la table de hachage.

bind

La commande intégrée bind affiche ou modifie les correspondances de touche de readline ^[65] .

help

Récupère un petit résumé sur l'utilisation d'une commande intégrée au shell. C'est l'équivalent de whatis pour les commandes intégrées. Dans la version 4 de Bash, l'affichage de l'information d'aide comporte à ce sujet une mise à jour très utile.

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.