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

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 15.22, « 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.47, « Paiement mensuel sur une hypothèque » et l'Exemple 15.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 14.2. printf en action

&ex47;

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

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

&ex36;

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

&readnovar;/>

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 14.5. Lecture de plusieurs lignes par read

&readr;

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

&arrowdetect;

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 14.7. Utiliser read avec la redirection de fichier

&readredir;

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

&readpipe;

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 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 à 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 14.9. Modifier le répertoire courant

&ex37;

Variables

let

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

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

&ex46;

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$ chaine_de_commande=xterm
bash$ eval $chaine_de_commande
Système de fichiers           Blocs de 1K      Util. Disp. Util.% Monté sur
 /dev/sda5              1904920    590204   1217952  33% /
 /dev/sda9              5409672    892396   4517276  17% /home
 /dev/sda1             18431244  13244376   5186868  72% /media/hd
 /dev/sda7             10142384   7812496   1814676  82% /usr
 /dev/sda8              1138428    258964    821632  24% /var

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
              

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 14.11. Montrer l'effet d'eval

&ex43;

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

&arrchoice;

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

&echoparams;

Exemple 14.14. Forcer une déconnexion

&ex44;

Exemple 14.15. Une version de rot13

&rot14;

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

eval var=\$$var

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 14.16. Utiliser set avec les paramètres de position

&ex34;

Plus de jeu avec les paramètres de position.

Exemple 14.17. Inverser les paramètres de position

&revposparams;

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

&setpos;

Voir aussi l'Exemple 10.2, « Boucle for avec deux paramètres dans chaque élément de la [liste] » et l'Exemple 15.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 14.19. « Dés-assigner » une variable

&uns;

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

export

La commande export ^[52] 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é

&coltotaler3;

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 ^[53] 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 14.21. Utiliser getopts pour lire les options/arguments passés à un script

&ex33;

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

&ex38;

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.

&ex38bis;

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

&selfsource;

exit

Termine un script sans condition. ^[54] 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. ^[55]

Exemple 14.24. Effets d'exec

&ex54;

Exemple 14.25. Un script lançant exec sur lui-même

&selfexec;

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 marquées -- dans la table de hachage du shell. ^[56] -- 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 ^[57] .

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.