14. Commandes internes et intégrées

Une commande intégrée est une commande contenue dans la boîte à outils de Bash, elle est donc littéralement intégrée. C'est soit pour des raisons de performance -- les commandes intégrées s'exécutent plus rapidement que les commandes externes, qui nécessitent le plus souvent de dupliquer le processus -- soit parce qu'une commande intégrée spécifique a besoin d'un accès direct aux variables internes du shell.

Une commande intégrée peut être le synonyme d'une commande système du même nom mais Bash la réimplémente en interne. Par exemple, la commande Bash echo n'est pas la même que /bin/echo bien que leurs comportements soient pratiquement identiques.

#!/bin/bash

echo "Cette ligne utilise la commande intégrée \"echo\"."
/bin/echo "Cette ligne utilise la commande système /bin/echo."

Un mot clé est un mot, une expression ou un opérateur réservé. Les mots clés ont une signification particulière pour le shell et sont en fait les blocs permettant la construction de la syntaxe du shell. À titre d'exemple, for, while, do et ! sont des mots clés. Comme les commandes intégrées, les mots clés sont codés en dur dans Bash mais, contrairement à une commande intégrée, un mot clé n'est pas en lui-même une commande mais une sous-unité d'une expression de commande. [50]

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]

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

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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.
              

14.1. Commandes de contrôle des jobs

Certaines des commandes de contrôle de jobs prennent en argument un identifiant de job (job identifier). Voir la table à la fin de ce chapitre.

jobs

Liste les jobs exécutés en tâche de fond en indiquant le numéro de job. Pas aussi utile que ps.

[Note]

Note

Il est trop facile de confondre les jobs et les processus. Certaines commandes intégrées, telles que kill, disown et wait acceptent soit un numéro de job soit un numéro de processus comme argument. Les commandes fg, bg et jobs acceptent seulement un numéro de job.

bash$ sleep 100 &
[1] 1384

bash $ jobs
[1]+  Running                 sleep 100 &

« 1 » est le numéro de job (les jobs sont maintenus par le shell courant). « 1384 » est le PID ou numéro de processus (les processus sont maintenus par le système). Pour tuer ce job/processus, faites soit un kill %1 soit un kill 1384.

Merci, S.C.

disown

Supprime le(s) job(s) de la table du shell des jobs actifs.

fg, bg

La commande fg fait basculer un job, qui tournait en tâche de fond, en avant-plan. La commande bg relance un job suspendu en tâche de fond. Si aucun numéro de job n'est spécifié, alors la commande fg ou bg agit sur le job en cours d'exécution.

wait

Suspend l'exécution du script jusqu'à ce que tous les jobs en tâche de fond aient terminé, ou jusqu'à ce que le numéro de job ou l'identifiant de processus spécifié en option se termine. Retourne l'état de sortie de la commande attendue.

Vous pouvez utiliser la commande wait pour empêcher un script de se terminer avant qu'un job en arrière-plan ne finisse son exécution (ceci créerait un processus orphelin).

Exemple 14.26. Attendre la fin d'un processus avant de continuer

&ex39.sh;

Optionnellement, wait peut prendre un identifiant de job en tant qu'argument, par exemple, wait%1 ou wait $PPID. Voir la table des identifiants de job.

[Astuce]

Astuce

À l'intérieur d'un script, lancer une commande en arrière-plan avec un "et commercial" (&) peut faire que le script se bloque jusqu'à un appui sur la touche ENTER. Ceci semble arriver avec les commandes qui écrivent sur stdout. Cela peut être un gros problème.

#!/bin/bash
# test.sh

ls -l &
echo "Terminé."
bash$ ./test.sh
Terminé.
 [bozo@localhost test-scripts]$ total 1
 -rwxr-xr-x    1 bozo     bozo           34 Oct 11 15:09 test.sh
 _

               


    Comme l'explique Walter Brameld IV :

    Ces scripts ne se bloquent pas. Il semble qu'ils le fassent car la commande
    en tâche de fond écrit le texte sur la console après l'invite. L'utilisateur
    a l'impression que l'invite n'a jamais été affichée. Voici la séquence des
    événements :

    1. Le script lance la commande en tâche de fond.
    2. Le script quitte.
    3. Le shell affiche l'invite.
    4. La commande en tâche de fond continue son exécution et l'écriture du
       texte sur la console.
    5. La commande en tâche de fond se termine.
    6. L'utilisateur ne voit pas une invite en bas de l'affichage, pensant
       du coup que le script est bloqué.

Placer un wait après la commande de tâche de fond semble remédier à ceci.

#!/bin/bash
# test.sh

ls -l &
echo "Terminé."
wait
bash$ ./test.sh
Terminé.
 [bozo@localhost test-scripts]$ total 1
 -rwxr-xr-x    1 bozo     bozo           34 Oct 11 15:09 test.sh
               

Rediriger la sortie de la commande dans un fichier ou même sur /dev/null permet aussi d'éviter ce problème.

suspend

Ceci a un effet similaire à Controle+Z, mais cela suspend le shell (le processus père du shell devrait le relancer à un moment approprié).

logout

Sort d'un login shell, quelque fois en spécifiant un état de sortie.

times

Donne des statistiques sur le temps système passé lors de l'exécution des commandes de la façon suivante :

0m0.020s 0m0.020s

Cette fonctionnalité est d'une valeur relativement limitée car il est peu commun d'évaluer la rapidité des scripts shells.

kill

Force la fin d'un processus en lui envoyant le signal de terminaison approprié (voir l'Exemple 16.6, « pidof aide à la suppression d'un processus »).

Exemple 14.27. Un script qui se tue lui-même

&selfdestruct;

[Note]

Note

kill -l liste tous les signaux (comme le fait le fichier /usr/include/asm/signal.h). Un kill -9 est une mort certaine, qui terminera un processus qui refuse obstinément de mourir avec un simple kill. Quelque fois, un kill -15 fonctionne. Un processus zombie, c'est-à-dire un processus qui a terminé mais dont le processus père n'a pas encore été tué, ne peut pas être tué par un utilisateur connecté -- vous ne pouvez pas tuer quelque chose qui est déjà mort -- mais en généeal init nettoiera tôt au tard.

killall

La commande killall tue un processus en cours d'exécution suivant son nom, plutôt que son identifiant de processus. S'il existe plusieurs instances d'une même commande, killall les tuera toutes.

[Note]

Note

Ceci fait référence à la commande killall de /usr/bin, pas au script killall dans /etc/rc.d/init.d.

command

La directive command désactive les alias et les fonctions pour la commande « COMMANDE » qui la suit immédiatement.

bash$ command ls
              
[Note]

Note

C'est une des trois directives qui modifient le traitement de commandes de script. Les autres sont des commandes intégrées et activées.

builtin

Appeler builtin COMMANDE_INTEGREE lance la commande COMMANDE_INTEGREE en tant que commande intégrée du shell, désactivant temporairement à la fois les fonctions et les commandes externes du système disposant du même nom.

enable

Ceci active ou désactive une commande intégrée du shell. Comme exemple, enable -n kill désactive la commande intégrée kill, de façon à ce que, quand Bash rencontre kill, il appelle la commande externe /bin/kill.

L'option -a d'enable liste toutes les commandes intégrées du shell, indiquant si elles sont ou non activées. L'option -f nomfichier permet à enable de charger une commande intégrée en tant que module de bibliothèque partagée (DLL) à partir d'un fichier objet correctment compilé. [58].

autoload

Ceci est une transposition à Bash du chargeur automatique de ksh. Avec autoload activé, une fonction avec une déclaration « autoload » se chargera depuis un fichier externe à sa première invocation. [59] Ceci sauve des ressources système.

Notez qu'autoload ne fait pas partie de l'installation de base de Bash. Il a besoin d'être chargé avec enable -f (voir ci-dessus).

Tableau 14.1. Identifiants de jobs

Notation Signification
%N Numéro de job [N]
%S Appel (ligne de commande) de jobs commençant par la chaîne de caractères S
%?S Appel (ligne de commande) de jobs contenant la chaîne de caractères S
%% Job « courant » (dernier job arrêté en avant-plan ou lancé en tâche de fond)
%+ Job « courant » (dernier job arrêté en avant-plan ou lancé en tâche de fond)
%- Dernier job
$! Dernier processus en tâche de fond



[50] Une exception à ceci est la commande time, listée dans la documentation Bash officielle en tant que mot clé (« mot réservé »).

[52] Exporter des informations revient à les rendre disponibles dans un contexte plus général. Voir aussi la portée.

[53] Une option est un argument agissant comme un indicateur, changeant le comportement du script de façon binaire. L'argument associé à une option indique le comportement que cette option active ou désactive.

[54] Techniquement, une commande exit termine seulement le processus ou le shell dans lequel il s'exécute, pas le processus parent.

[55] Sauf si exec est utilisé pour affecter de nouveau les descripteurs de fichiers.

[56]

Le hachage (ou découpage) est une méthode pour créer des clés de recherche pour des données stockées dans une table. Les éléments de données eux-mêmes sont « découpés » pour créer des clés en utilisant un des nombreux algorithmes (méthodes ou recettes) simples de mathématiques.

Un avantage du hachage est qu'il est rapide. Un inconvénient est que les collisions -- où une seule clé correspond à plus d'un élément de données -- sont possibles.

Pour des exemples de hachage, voir Exemple A.20, « Bibliothèque de fonctions de hachage » et Exemple A.21, « Coloriser du texte en utilisant les fonctions de hachage ».

[57] La bibliothèque readline est utilisée par Bash pour lire les entrées utilisateur dans un shell interactif.

[58] Le source C pour un certain nombre de commandes intégrées chargeables est disponible typiquement dans le répertoire /usr/share/doc/bash-?.??/functions.

Notez que l'option -f d'enable n'est pas reconnue sur tous les systèmes.

[59] Le même effet qu'autoload peut être réalisé avec typeset -fu.