I/O

echo

envoie (vers stdout) une expression ou une variable (voir l'Exemple 4.1, « Affectation de variable et substitution  »).

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

Habituellement, 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 15.20, « lowercase : Change tous les noms de fichier du répertoire courant en minuscule. », l'Exemple 15.3, « Badname élimine dans le répertoire courant les fichiers dont le nom contient des caractères incorrects et des espaces blancs. », l'Exemple 15.43, « Paiement mensuel sur une hypothèque » et l'Exemple 15.44, « 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 habituellement \n (retour chariot) comme un des éléments de ses espaces 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() en langage C, et sa syntaxe est quelque 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 14.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"

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=65

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.

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 26.5, « Quelques propriétés spéciales des tableaux »).

Exemple 14.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 14.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

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

Exemple 14.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 14.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 came up with a simplified
#+ version of the above script (Thank you!).
#  It eliminates the need for grep.

#!/bin/bash

  uparrow=$'\x1b[A'
  downarrow=$'\x1b[B'
  leftarrow=$'\x1b[D'
  rightarrow=$'\x1b[C'

  read -s -n3 -p "Hit an arrow key: " x

  case "$x" in
  $uparrow)
     echo "You pressed up-arrow"
     ;;
  $downarrow)
     echo "You pressed down-arrow"
     ;;
  $leftarrow)
     echo "You pressed left-arrow"
     ;;
  $rightarrow)
     echo "You pressed right-arrow"
     ;;
  esac

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

#  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, « read avec délai »).

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 14.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 14.8. Problèmes lors de la lecture d'un tube

#!/bin/sh
# readpipe.sh
# Cet exemple est une contribution de Bjon Eriksson.

dernier="(null)"
cat $0 |
while read ligne
do
    echo "{$ligne}"
    dernier=$ligne
done
printf "\nTout est fait, dernier :$dernier\n"

exit 0  # Fin du code.
        # La sortie (partielle) du script suit.
        # Le 'echo' apporte les crochets supplémentaires.

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

./readpipe.sh 

{#!/bin/sh}
{dernier="(null)"}
{cat $0 |}
{while read ligne}
{do}
{echo "{$ligne}"}
{dernier=$ligne}
{done}
{printf "\nTout est fait, dernier :$dernier\n"}


Tout est fait, dernier :(null)

La variable (dernier) est initialisée à l'intérieur du sous-shell
mais est non initialisée à l'extérieur.

Le script gendiff, habituellement trouvé dans /usr/bin sur un grand nombre de 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. Voir Exemple A.38, « Un 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 14.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 suivant les répertoires d'une manière ordonnée. Une pile LIFO est utilisée pour conserver la trace des noms de 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 14.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 des variables. Dans la majorité des cas, il fonctionne comme une version simplifiée de expr.

Exemple 14.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

eval

eval arg1 [arg2] ... [argN]

Combine les arguments dans une expression ou liste d'expressions et les évalue. Toute variable contenue dans l'expression sera étendue. Le résultat se traduit en une commande. C'est utile pour de la génération de code à partir de la ligne de commande ou à l'intérieur d'un script.

bash$ processus=xterm
bash$ affiche_processus="eval ps ax | grep $processus"
bash$ $affiche_processus
1867 tty1     S      0:02 xterm
 2779 tty1     S      0:00 xterm
 2886 pts/1    S      0:00 grep xterm
              

Exemple 14.11. Montrer l'effet d'eval

#!/bin/bash

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, montrons comment "étendre" une variable en utilisant "eval" . . .

for i in 1 2 3 4 5; do
  eval valeur=$i
  #  value=$i a le même effet. "eval" n'est pas nécessaire ici.
  #  Une variable manquant de "signification" s'évalue à elle-même --
  #+ elle ne peut s'étendre en rien d'autre que sa valeur littérale.
  echo $valeur
done

echo
echo "---"
echo

for i in ls df; do
  valeur=eval $i
  #  valeur=$i a un effet complètement différent ici.
  #  "eval" évalue les commandes "ls" et "df" . . .
  #  Les termes "ls" et "df" ont une signification supplémentaire,
  #+ car ils sont interprétés comme des commandes,
  #+ plutôt que comme des chaînes de caractères.
  echo $valeur
done

exit 0

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

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

# Appeler ce script avec quelques paramètres en ligne de commande.
# Par exemple :
#     sh echo-params.sh premier deuxieme troisieme quatrieme cinquieme

params=$#              # Nombre de paramètres en ligne de commande.
param=1                # Commencer par le premier paramètre.

while [ "$param" -le "$params" ]
do
  echo -n "Paramètre "
  echo -n \$$param     #  Donne seulement le *nom* de la variable.
#         ^^^          #  $1, $2, $3, etc.
                       #  Pourquoi ?
                       #  \$ échappe le premier "$"
                       #+ donc il l'affiche littéralement,
                       #+ et $param déréférence "$param" . . .
                       #+ ... comme on s'y attendait.
  echo -n " = "
  eval echo \$$param   #  Donne la *valeur* de la variable.
# ^^^^      ^^^        #  Cet "eval" force l'*évaluation*
                       #+ de \$$
                       #+ comme une référence indirecte de variable.

(( param ++ ))         # Au suivant.
done

exit $?

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

$ sh echo-params.sh premier deuxieme troisieme quatrieme cinquieme
Paramètre $1 = premier
Paramètre $2 = deuxieme
Paramètre $3 = troisieme
Paramètre $4 = quatrieme
Paramètre $5 = cinquieme

Exemple 14.13. 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 14.14. 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

Rory Winston a apporté sa contribution en donnant un autre exemple de l'utilité de la commande eval.

Exemple 14.15. Utiliser eval pour forcer une substitution de variable dans un script Perl

Dans le script Perl "test.pl" :
        ...             
        my $WEBROOT = <WEBROOT_PATH>;
        ...

Pour forcer une substitution de variables, essayez :
        $export WEBROOT_PATH=/usr/local/webroot
        $sed 's/<WEBROOT_PATH>/$WEBROOT_PATH/' < test.pl > out

Mais ceci donne simplement :
        my $WEBROOT = $WEBROOT_PATH;

Néanmoins :
        $export WEBROOT_PATH=/usr/local/webroot
        $eval sed 's%\<WEBROOT_PATH\>%$WEBROOT_PATH%' < test.pl > out
#        ====

Ceci fonctionne bien et donne la substitution attendue :
        my $WEBROOT = /usr/local/webroot;


### Correction appliquée à l'exemple original de Paulo Marcel Coelho Aragao.

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 la commande.

Exemple 14.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 14.17. Inverser les paramètres de position

#!/bin/bash
# revposparams.sh : Inverse les paramètres de position.
# Script de Dan Jacobson, avec quelques corrections de style par l'auteur du document.


set a\ b c d\ e;
#     ^      ^     Espaces échappés
#       ^ ^        Espaces non échappés
OIFS=$IFS; IFS=:;
#              ^   Sauvegarde de l'ancien IFS et initialisation du nouveau.

echo

until [ $# -eq 0 ]
do          #      Passage des différents paramètres de position.
  echo "### k0 = "$k""     # Avant
  k=$1:$k;  #      Ajoute chaque paramètre de position à la variable de la boucle.
#     ^
  echo "### k = "$k""      # Après
  echo
  shift;
done

set $k  #  Initialise les nouveaux paramètres de position.
echo -
echo $# #  Nombre de paramètres de position.
echo -
echo

for i   #  Oublier la "liste in" initialise la variable -- i --
        #+ avec les paramètres de position.
do
  echo $i  # Affiche les nouveaux paramètres de position.
done

IFS=$OIFS  # Restaure IFS.

#  Question :
#  Est-il nécessaire d'initialiser un nouvel IFS pour que ce script fonctionne
#+ correctement ?
#  Que se passe-t'il dans le cas contraire ? Essayez.
#  Et pourquoi utiliser le nouvel IFS -- une virgule -- en ligne 17,
#+ pour l'ajout à la variable de la boucle ?
#  Quel est le but de tout ceci ?

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 14.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 10.2, « Boucle for avec deux paramètres dans chaque élément de la [liste] » et l'Exemple 15.52, « 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 14.19. « Déconfigurer » 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

export

La commande export ^[40] 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 14.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
              

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 ^[41] et les arguments associés à un script (par exemple nomscript -abc -e /usr/local).

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

Une construction getopts vient habituellement dans une boucle while, qui analyse les options et les arguments un à un, puis incrémente la variable implicite $OPTIND pour passer à la suivante.

Note

1. Les arguments passés à la ligne de commande vers le script doivent être précédés par un tiret (-). Le préfixe - permet à getopts de reconnaitre les arguments en ligne de commande comme des options. En fait, getopts ne traitera pas les arguments sans les préfixes - et terminera l'analyse des options au premier argument rencontré qui ne les aura pas.

2. Le modèle getopts diffère légèrement de la boucle while standard dans le fait qu'il manque les crochets de condition.

3. La construction getopts remplace la commande getopt qui est obsolète.

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 14.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 14.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 14.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 14.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. ^[42] 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. ^[43]

Exemple 14.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 14.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 24.1, « Alias à l'intérieur d'un script » et l'Exemple 24.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'

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
              

hash [cmds]

Enregistre le chemin des commandes spécifiées -- dans une table de hachage du shell ^[44] -- 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é 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 ^[45] .

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.

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.