Le Shell UNIX interprète les commandes de l'utilisateur, qui sont soit directement entrées par celui-ci, ou qui peuvent être lues depuis un fichier appelé un script shell ou programme. Ces scripts sont interprétés, donc non compilés. Le Shell lit les commandes de chaque ligne du script et cherche ces commandes dans le système (voir Section 2, « Avantages du Bourne Again SHell »), alors qu'un compilateur convertit un programme en une forme lisible par la machine, un fichier exécutable - lequel peut alors être employé dans un script.

A part de passer des commandes au noyau, la tâche principale du Shell est de mettre en place un environnement utilisateur qui peut être configuré individuellement par le biais de fichiers de configuration.

Tout comme les gens connaissent une variété de langages, votre système UNIX généralement offre une variété de types de Shell  :

Le fichier /etc/shells donne un aperçu des Shells connus du système Linux  :

mia:~> cat /etc/shells
/bin/bash
/bin/sh
/bin/tcsh
/bin/csh

Votre Shell par défaut est déclaré dans le fichier /etc/passwd , comme cette ligne pour l'utilisateur mia :

mia:L2NOfqdlPrHwE:504:504:Mia Maya:/home/mia:/bin/bash

Pour permuter d'un Shell à un autre, simplement entrez le nom du nouveau Shell actif dans le terminal. Le système trouve le répertoire où le nom apparaît au moyen des paramètres de PATH, et puisqu'un Shell est un fichier exécutable (programme), le Shell courant l'active et il s'exécute. Une nouvelle invite est souvent affichée, du fait que chaque Shell a une interface propre :

mia:~> tcsh
[mia@post21 ~]$

Le projet GNU (ne pas confondre GNU et UNIX) offre des outils pour l'administration de système de type UNIX qui sont libres et qui respectent les standards UNIX.

Bash est un Shell compatible avec sh qui incorpore des spécificités utiles du Korn Shell (ksh) et du C Shell (csh). Il est censé se conformer à la norme IEEE POSIX P1003.2/ISO 9945.2 Standards des Shell et Outils. Il offre des améliorations fonctionnelles par rapport à sh pour la programmation et l'utilisation interactive ; ce qui inclut l'édition de commande en ligne, historique illimité des commandes, contrôle des travaux, fonctions Shell et alias, tableau indexé de taille illimitée, et l'arithmétique d'entiers dans toutes les bases depuis la base 2 jusqu'à la base 64. Bash peut exécuter la plupart des scripts sh sans modification.

Comme les autres projets GNU, le projet bash a été lancé pour préserver, protéger et promouvoir la liberté d'utiliser, étudier, copier, modifier et redistribuer les logiciels. Il est généralement admis que de telles conditions stimulent la créativité. Cela a été le cas avec le programme Bash, qui a beaucoup de fonctionnalités que les autres Shells n'offrent pas.

Bash determine le type de programme qui doit être exécuté. Les programmes standards sont les commandes système qui existent sous forme compilée dans le système. Quand un tel programme est exécuté, un nouveau processus est créé parce que Bash lance une copie exacte de lui-même. Ce processus fils a le même environnement que son parent, seul l'identifiant est différent. Cette procédure est appellée forking.

Une fois que le processus a fourché, l'espace d'adresse du processus fils est renseigné avec ses propres informations. Ceci est fait grâce à un appel système par exec.

Le mécanisme fork-and-exec cependant substitue une ancienne commande par une nouvelle, tandis que l'environnement dans lequel le nouveau programme est exécuté reste le même, y compris la configuration des entrées/sorties, des variables d'environnement et des priorités. Ce mécanisme est employé pour créer tous les processus UNIX, donc il s'applique aussi au système d'opération Linux. Même le premier processus, init, avec l'ID 1, fourche dans la procédure de démarrage appelée bootstrapping.

Les commandes intégrées sont parties intégrantes du Shell lui-même. Quand le nom d'une commande intégrée est employé comme le premier mot d'une commande simple, le Shell exécute la commande directement, sans créer un nouveau processus. Les commandes intégrées sont nécessaires pour implanter des fonctionnalités impossibles ou difficiles à mettre en oeuvre par des outils externes.

Bash possède 3 types de commandes intégrées :

La plupart de ces intégrées seront abordées dans les chapitres suivants. Pour les commandes qui ne le seront pas, se référer aux pages Info.

Quand le programme en exécution est un script Shell, Bash créera un nouveau processus Bash en activant un fork. Ce sous-Shell lit les lignes du script une par une. Les commandes de chaque ligne sont lues, interprétées et exécutées comme si elles avaient été entrées au clavier.

Tandis que le sous-Shell opère sur chaque ligne du script, le Shell parent attend que le processus fils ait fini. Quand il n'y a plus de ligne à lire dans le script, le sous-Shell se termine. Le Shell parent s'active et affiche l'invite de nouveau.

Ce guide traite principalement du dernier bloc de construction Shell : les scripts. Quelques considerations générales avant de continuer :

La structure d'un script est très flexible. Même si Bash permet beaucoup de liberté, vous devez mettre en oeuvre une logique rigoureuse, un contrôle des données, une efficacité qui permet à l'utilisateur qui exécute le script de le faire facilement et correctement.

Au moment d'écrire un nouveau script, posez-vous les questions suivantes :

La table ci-dessous donne un aperçu des termes de programmation avec lesquels vous devez vous familiariser :

Afin d'accélérer les phases de développement, l'ordre logique du programme devrait être pensé à l'avance. C'est votre première étape quand vous développez un script.

Diverses méthodes peuvent être utilisées ; une des plus courantes est la constitution de listes. Lister les opérations nécessaires au programme vous permet de décrire chaque tâche. Les opérations unitaires peuvent être référencées par leur numéro dans la liste.

En utilisant vos propres mots pour déterminer les opérations à exécuter par votre programme il vous sera plus facile de créer un programme compréhensible. Ensuite, vous écrivez le langage compris par Bash.

L'exemple ci-dessous montre un tel enchaînement logique. Il décrit la rotation des fichiers journaux. Cet exemple montre la possible réitération d'une boucle, en fonction du nombre de fichiers journaux sur lesquels vous voulez paramétrer une rotation.

L'utilisateur va devoir saisir des données pour que le programme effectue quelque chose. La saisie de l'utilisateur doit être sollicitée et mémorisée. L'utilisateur devrait être informé que 'son' crontab va être changé.

Le script mysystem.sh ci-dessous exécute des commandes bien connues (date, w, uname, uptime) pour afficher des informations au sujet de la machine et sur vous.

tom:~> cat -n mysystem.sh
     1  #!/bin/bash
     2  clear
     3  echo "This is information provided by mysystem.sh.  Le programme démarre maintenant."
     4
     5  echo "Bonjour, $USER"
     6  echo
     7
     8  echo "Nous sommes le `date`, semaine `date +"%V"`."
     9  echo
    10
    11  echo "Ces utilisateurs sont actuellement connectés :"
    12  w | cut -d " " -f 1 - | grep -v USER | sort -u
    13  echo
    14
    15  echo "`uname -s` est le système, `uname -m` le processeur."
    16  echo
    17
    18  echo "Le système fonctionne depuis :"
    19  uptime
    20  echo
    21
    22  echo "C'est pas plus compliqué !"

Un script commence toujours par ces 2 caractères : « #! ». Suit le nom du Shell qui exécutera les commandes suivant. Ce script commence en effaçant l'écran à la ligne 2. La ligne 3 fait afficher un message pour informer l'utilisateur de ce qui va se passer. La ligne 5 salue l'utilisateur. Les lignes 6, 9, 13, 16 et 20 ne sont là que pour aérer l'affichage des résultats. La ligne 8 affiche la date du jour et le numéro de la semaine. Ligne 11 encore un message informatif, ainsi que ligne 3, 18 et 22. La ligne 12 formate le résultat de la commande w ; la ligne 15 affiche le nom du système d'exploitation et le type de processeur. La ligne 19 donne la durée de fonctionnement du système ainsi que sa charge.

echo et printf sont des commandes intégrées de Bash. La première retourne toujours un statut à 0, et affiche simplement ses arguments terminés par un caractère de fin de ligne sur la sortie standard, tandis que la deuxième autorise des options de formatage de la chaîne et renvoie un statut différent de 0 en cas d'échec.

Voici le même script avec l'intégrée printf :

tom:~> cat mysystem.sh
#!/bin/bash
clear
printf "This is information provided by mysystem.sh.  Le programme démarre maintenant."

printf "Bonjour, $USER.\n\n"

printf "Nous sommes le `date`, semaine `date +"%V"`.\n\n"

printf "Ces utilisateurs sont actuellement connectés :\n"
w | cut -d " " -f 1 - | grep -v USER | sort -u
printf "\n"

printf "`uname -s` est le système, `uname -m` le processeur.\n\n"

printf "Le système fonctionne depuis :\n"
uptime
printf "\n"

printf "C'est pas plus compliqué\n"

L'écriture d'un script convivial en insérant des messages est traité au Chapitre 8, Ecrire des scripts interactifs.

	La localisation standard du Bourne Again Shell
	Ceci implique que le programme bash est installé dans /bin.

	Si stdout n'est pas disponible
	Si vous exécutez un script par cron, fournir le chemin complet et rediriger les résultats et les erreurs. Du fait que le Shell tourne en mode non-interactif, toute erreur provoquera la fin du script prématurément si vous n'y songez pas.

Les chapitres suivants traiteront en détail les scripts ci-dessus.

Un script init démarre les services système sur des machines UNIX et Linux. Les démons de journalisation du système, de gestion des ressources, de contrôle d'accès et de mails en sont des exemples. Ces scripts, aussi appelés scripts de démarrage, sont stockés dans un endroit particulier de votre système, tel que /etc/rc.d/init.d ou /etc/init.d. Init, le processus initial, lit ses fichiers de configuration et décide quels services il démarre ou arrête en fonction du niveau d'exécution système. Le niveau d'exécution est un état de configuration du système (NdT qui correspond à une utilisation particulière du système) ; chaque système a un niveau d'exécution qui autorise un unique utilisateur, par exemple, pour exécuter des tâches administratives, pour lesquelles le système doit être dans un état aussi stable que possible. Comme par exemple récupérer un fichier système important depuis une sauvegarde. Les niveaux d'exécution de démarrage et d'arrêt sont habituellement aussi configurés.

Les tâches à exécuter au démarrage ou à l'arrêt d'un service sont listées dans le script de lancement. C'est l'une des tâches de l'administrateur système de configurer init, de façon que les services soient lancés et stoppés au bon moment. Quand vous êtes confrontés à cette tâche, vous avez besoin d'une bonne compréhension des procédures de démarrage et d'arrêt du système. Nous vous conseillons donc de lire les pages man pour init et inittab avant de vous lancer dans les scripts d'initialisation.

Voici un exemple très simple qui joue un son au démarrage et à l'arrêt de la machine :

#!/bin/bash

# This script is for /etc/rc.d/init.d
# Link in rc3.d/S99audio-greeting and rc0.d/K01audio-greeting

case "$1" in
'start')
  cat /usr/share/audio/at_your_service.au > /dev/audio
  ;;
'stop')
  cat /usr/share/audio/oh_no_not_again.au > /dev/audio
  ;;
esac
exit 0

L'instruction case souvent utilisée dans ce genre de script est décrite à la Section 2.5, « Emploi de l'instruction exit et du if ».

Un script Shell est une séquence de commandes dont vous avez un usage répété. Cette séquence est en principe exécutée en entrant le nom du script sur la ligne de commande. Alternativement, vous pouvez utiliser des scripts pour automatiser des tâches via l'outil cron. Un autre usage des scripts est celui fait par la procédure de démarrage et d'arrêt d'UNIX où les opérations des services et démons sont définies dans des scripts « init ».

Pour créer un script Shell, ouvrez un nouveau fichier avec l'éditeur. N'importe quel éditeur fera l'affaire : vim, emacs, gedit, dtpad et cetera sont tous valides. Vous pouvez songer à utiliser un éditeur sophistiqué comme vim ou emacs, parce qu'ils peuvent être configurés pour reconnaître la syntaxe Shell et Bash et donc peuvent être d'une grande aide en évitant ces erreurs que les débutants font, tel que oublier un crochet ou un point-virgule.

	Le vidéo-inverse dans vim
	Pour activer le vidéo-inverse dans vim, passer la commande :set syntax enable Vous pouvez ajouter ce paramètre à votre fichier .vimrc pour rendre permanent cette configuration.

Entrez des commandes UNIX dans ce nouveau fichier, comme vous le feriez sur la ligne de commande. Ainsi que nous l'avons vu dans le chapitre précédent (voir Section 3, « L'exécution de commandes »), les commandes peuvent être des fonctions Shell, des commandes intégrées, des commandes UNIX et le nom d'un autre script.

Donnez à votre script un nom significatif qui donne une idée de ce qu'il fait. Assurez vous que ce nom ne soit pas en conflit avec une commande existante. Afin d'éviter des confusions, les noms de scripts souvent finissent par .sh ; mais même dans ce cas, il peut y avoir un autre script dans votre système qui porte le même nom. Vérifier avec which, whereis et les autres commandes qui renvoyent des informations sur les programmes et les fichiers :

Dans cet exemple nous employons l'intégrée echo pour informer l'utilisateur sur ce qui va se dérouler, avant que la tâche qui crééra le résultat s'exécute. Il est fortement recommandé d'informer les utilisateurs sur ce que fait le script, de façon à éviter qu'ils deviennent anxieux parce que le script ne fait rien. Nous reviendrons sur le sujet de la notification aux utilisateurs au Chapitre 8, Ecrire des scripts interactifs.

Figure 2.1. script1.sh

Ecrivez ce script. Ce peut être une bonne idée de créer un répertoire ~/scripts pour ranger vos scripts. Ajoutez le répertoire au contenu de la variable PATH variable :

Si vous êtes tout nouveau avec Bash, utilisez un éditeur de texte qui emploie différentes couleurs pour les différentes constructions syntaxiques. Le code de couleur est une fonction de vim, gvim, (x)emacs, kwrite et de beaucoup d'autres éditeurs. Se référer à la documentation de votre éditeur.

	Des invites différentes
	L'invite varie au long de ce guide selon l'humeur de l'auteur. Ce qui ressemble plus à la vie réelle que l'invite classique $. La seule convention que nous avons gardé est que l'invite de root finit par #.

Le script doit avoir les permissions d'exécution pour le propriétaire afin d'être exécutable. Quand vous définissez des permissions, contrôlez que vous avez obtenu les permissions voulues. Une fois fait, le script peut être lancé comme toute autre commande :

willy:~/scripts> chmod u+x script1.sh

willy:~/scripts> ls -l script1.sh
-rwxrw-r--    1 willy	willy		456 Dec 24 17:11 script1.sh

willy:~> script1.sh
Le script démarre.
Salut, willy !

Je vais afficher une liste des utilisateurs connectés :

  3:38pm  up 18 days,  5:37,  4 users,  load average: 0.12, 0.22, 0.15
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU  WHAT
root     tty2     -                Sat 2pm  4:25m  0.24s  0.05s  -bash
willy	 :0       -                Sat 2pm   ?     0.00s   ?     -
willy    pts/3    -                Sat 2pm  3:33m 36.39s 36.39s  BitchX willy ir
willy    pts/2    -                Sat 2pm  3:33m  0.13s  0.06s  /usr/bin/screen

Je définis 2 variables, maintenant.
Ceci est une chaîne : noir
Et ceci est un nombre : 9

Je vous rends la main, maintenant.

willy:~/scripts> echo $COLOUR

willy:~/scripts> echo $VALUE

willy:~/scripts>

C'est la façon la plus courante d'exécuter un script. C'est préférable d'exécuter le script comme ça dans un sous-Shell. Les variables, fonctions et alias créés dans le sous-Shell sont seulement connus dans la session Bash de ce sous-Shell. Quand le sous-Shell finit et que le parent reprend le contrôle, tout est réinitialisé et les changements faits dans l'environnement du Shell par le script sont oubliés.

Si vous ne mettez pas le répertoire de scripts dans votre PATH, et si . (le répertoire courant) n'est pas dans le PATH non plus, vous pouvez lancer le script comme ça :

Un script peut aussi être explicitement exécuté par un Shell particulier, mais généralement on ne fait ça que pour obtenir un comportement spécial, comme vérifier que le script tourne avec un autre Shell ou afficher une trace pour debugger.

Le Shell spécifié démarrera en tant que sous-Shell de votre Shell actif et exécutera le script. On le fait quand on veut que le script démarre avec des options ou des conditions spécifiques qui ne sont pas indiquées dans le script.

Si vous ne voulez pas démarrer un nouveau Shell mais exécuter le script dans le Shell courant, vous faites source :

	source = .
	L'intégrée Bash source est un synonyme de la commande Bourne shell . (dot).

Le script n'a pas besoin de permission d'exécution dans ce cas. Les commandes sont exécutées dans l'environnement du Shell actif, par conséquent tout changement restera tel quel quand le script aura terminé :

willy:~/scripts> source script1.sh
--output ommitted--

willy:~/scripts> echo $VALUE
9

willy:~/scripts>

Quand un script s'exécute dans un sous-Shell, vous devriez définir quel Shell doit exécuter ce script. Le type de Shell pour lequel vous avez écrit le script peut ne pas être celui par défaut de votre système, alors les commandes peuvent ne pas être interprétées par un Shell inadéquat.

La première ligne du script définit le Shell à lancer. Les 2 premiers caractères de la première ligne devraient être #!, puis suit le chemin vers le Shell qui doit interpréter les commandes qui suivent. Les lignes blanches sont aussi prises en compte, donc ne commencez pas votre script par une ligne vide.

Dans ce guide, tous les scripts commenceront par la ligne

Comme indiqué auparavant, ceci implique que le programme Bash doit se trouver dans /bin.

Vous devriez vous rappeler que vous ne serez peut-être pas la seule personne à lire votre code. Beaucoup d'utilisateurs et d'administrateurs système lancent des scripts qui ont été écrits par d'autres. Si ils veulent voir comment vous avez fait, les commentaires sont utiles pour éclairer le lecteur.

Les commentaires vous rendent aussi la vie plus facile. Par exemple vous avez lu beaucoup de pages man pour obtenir de certaines commandes de votre script un résultat donné. Vous ne vous souviendrez plus de ce qu'il fait après quelques semaines, à moins d'avoir commenté ce que vous avez fait, comment et pourquoi.

Prenez en exemple script1.sh et copiez le sur commented-script1.sh, que vous éditez de sorte que les commentaires réflètent ce que le script fait. Tout ce qui apparaît après le # sur une ligne est ignoré par le Shell et n'apparaît qu'à l'édition.

#!/bin/bash
# Ce script efface le terminal, affiche un message d'accueil et donne des informations
# sur les utilisateurs connectés.  Les 2 exemples de variables sont définis et affichés.

clear				# efface le terminal

echo "Le script démarre."

echo "Salut, $USER !"		# le signe dollar est employé pour obtenir le contenu d'une variable
echo

echo "Je vais maintenant vous afficher une liste des utilisateurs connectés :"
echo							
w				# montre qui est connecté
echo				# et ce qu'ils font

echo "Je définis 2 variables maintenant."
COLOUR="noir"				# définit une variable locale Shell 
VALUE="9"					# définit une variable locale Shell 
echo "Ceci est une chaîne : $COLOUR"		# affiche le contenu de la variable 
echo "Et ceci est un nombre : $VALUE"		# affiche le contenu de la variable
echo

echo "Je vous redonne la main maintenant."
echo

Dans un script correct, les premières lignes sont habituellement des commentaires sur son but. Puis chaque portion importante de code devrait être commentée autant que la clarté le demande. Les scripts d'init Linux, par exemple, dans le répertoire init.d sont généralement bien documentés puisque ils doivent être lisibles et éditables par quiconque utilise Linux.

Quand les choses ne vont pas comme attendues, vous devez déterminer qu'est-ce qui provoque cette situation. Bash fournit divers moyens pour débugger. La plus commune est de lancer le sous-Shell avec l'option -x ce qui fait s'exécuter le script en mode débug. Une trace de chaque commande avec ses arguments est affichée sur la sortie standard après que la commande ait été interprétée mais avant son exécution.

Ceci est le script commented-script1.sh exécuté en mode débug. Notez que les commentaires ne sont pas visibles dans la sortie du script.

willy:~/scripts> bash -x script1.sh
+ clear

+ echo 'Le script démarre.'
Le script démarre.
+ echo 'Salut, willy !'
Salut, willy !
+ echo

+ echo 'Je vais maintenant vous afficher une liste des utilisateurs connectés :'
Je vais maintenant vous afficher une liste des utilisateurs connectés :
+ echo

+ w
  4:50pm  up 18 days,  6:49,  4 users,  load average: 0.58, 0.62, 0.40
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU  WHAT
root     tty2     -                Sat 2pm  5:36m  0.24s  0.05s  -bash
willy	 :0       -                Sat 2pm   ?     0.00s   ?     -
willy	 pts/3    -                Sat 2pm 43:13  36.82s 36.82s  BitchX willy ir
willy    pts/2    -                Sat 2pm 43:13   0.13s  0.06s  /usr/bin/screen
+ echo

+ echo 'Je définis 2 variables maintenant.'
Je définis 2 variables maintenant.
+ COLOUR=noir
+ VALUE=9
+ echo 'Ceci est une chaîne : '
Ceci est une chaîne :
+ echo 'Et ceci est un nombre : '
Et ceci est un nombre :
+ echo

+ echo 'Je vous redonne la main maintenant.'
Je vous redonne la main maintenant.
+ echo

	Fonctionnalités à venir du Bash
	Il y a maintenant un débugger complet pour Bash, disponible sur SourceForge. Cependant, cela nécessite une version modifiée de bash-2.05. Cette fonctionnalité devrait être disponible dans la version bash-3.0.

Avec l'intégrée set vous pouvez exécuter en mode normal ces portions de code où vous êtes sûr qu'il n'y a pas d'erreurs, et afficher les informations de débuggage seulement pour les portions douteuses. Admettons que nous ne soyons pas sûr de ce que fait la commande w dans l'exemple commented-script1.sh, alors nous pouvons l'entourer dans le script comme ceci :

set -x			# active le mode débug
w
set +x			# stoppe le mode débug

La sortie affiche alors ceci :

willy: ~/scripts> script1.sh
Le script démarre.
Salut, willy !

Je vais maintenant vous afficher une liste des utilisateurs connectés :

+ w
  5:00pm  up 18 days,  7:00,  4 users,  load average: 0.79, 0.39, 0.33
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU  WHAT
root     tty2     -                Sat 2pm  5:47m  0.24s  0.05s  -bash
willy    :0       -                Sat 2pm   ?     0.00s   ?     -
willy    pts/3    -                Sat 2pm 54:02  36.88s 36.88s  BitchX willyke
willy    pts/2    -                Sat 2pm 54:02   0.13s  0.06s  /usr/bin/screen
+ set +x

Je définis 2 variables maintenant.
Ceci est une chaîne :
Et ceci est un nombre :

Je vous redonne la main maintenant.

willy: ~/scripts>

On peut basculer du mode activé à désactivé autant de fois que l'on veut dans le script.

La table ci-dessous donne un aperçu d'autres options Bash utiles :

Le signe - est utilisé pour activer une option Shell et le + pour la désactiver. Ne vous faites pas avoir !

Dans l'exemple qui suit, nous montrons l'usage de ces options depuis la ligne de commande :

willy:~/scripts> set -v

willy:~/scripts> ls
ls 
commented-scripts.sh	script1.sh

willy:~/scripts> set +v
set +v

willy:~/scripts> ls *
commented-scripts.sh    script1.sh

willy:~/scripts> set -f

willy:~/scripts> ls *
ls: *: No such file or directory

willy:~/scripts> touch *

willy:~/scripts> ls
*   commented-scripts.sh    script1.sh

willy:~/scripts> rm *

willy:~/scripts> ls
commented-scripts.sh    script1.sh

De façon alternative, ces modes peuvent être indiqués dans le script lui-même, en ajoutant l'option voulue sur la première ligne de déclaration du Shell. Les options peuvent être combinées, comme c'est généralement le cas pour les commandes UNIX :

Une fois que vous avez localisé la partie douteuse, vous pouvez ajouter des instructions echo devant chaque commande douteuse, de sorte que vous verrez exactement où et pourquoi le résultat n'est pas satisfaisant. Dans le script commented-script1.sh, ça pourrait être fait comme ça, toujours en supposant que l'affichage des utilisateurs nous cause des soucis :

echo "debug message : avant exécution de la commande w"; w

Dans des scripts plus élaborés echo peut être inséré pour faire afficher le contenu de variables à différentes étapes du script, afin de détecter les erreurs :

echo "Variable VARNAME a la valeur $VARNAME."

Quand vous modifiez n'importe lequel des fichiers ci-dessus, les utilisateurs doivent soit se reconnecter, soit exécuter (source) le fichier modifié afin que prennent effet les modifications. De la deuxième manière, les modifications sont appliquées à la session active du Shell :

Figure 3.1. Différentes invites pour des utilisateurs différents

La plupart des scripts Shell s'exécutent dans leur propre environnement : les processus enfants n'héritent pas des variables du parent à moins que celui-ci les exporte. Exécuter avec source un fichier contenant des instructions Shell est un moyen d'appliquer les changements à son propre environnement, de définir des variables dans son Shell actif.

Cet exemple montre aussi le paramétrage de diverses invites pour divers utilisateurs. Dans ce cas, rouge signifie danger. Si vous avez une invite verte, ne vous inquiétez pas trop.

Notez que source resourcefile est équivalent à . resourcefile.

Si vous vous trouvez perdu avec tous ces fichiers de configuration, et que vous ne ciblez pas où un certain paramètre est défini, employez echo, tout comme pour debugger un script ; voir la Section 3.2, « Débugger qu'une partie du script ». Vous pouvez ajouter des lignes comme celles-ci :

echo "Avant exécution de .bash_profile.."

ou comme celles-ci :

echo "Avant définition de PS1 dans .bashrc:"
export PS1="[la bonne valeur]"
echo "PS1 est défini comme ceci $PS1"

Comme dans l'exemple ci-dessus, les variables Shell sont en majuscule par convention. Bash garde une liste de 2 types de variables :

franky ~> printenv
CC=gcc
CDPATH=.:~:/usr/local:/usr:/
CFLAGS=-O2 -fomit-frame-pointer
COLORTERM=gnome-terminal
CXXFLAGS=-O2 -fomit-frame-pointer
DISPLAY=:0
DOMAIN=hq.xalasys.com
e=
TOR=vi
FCEDIT=vi
FIGNORE=.o:~
G_BROKEN_FILENAMES=1
GDK_USE_XFT=1
GDMSESSION=Default
GNOME_DESKTOP_SESSION_ID=Default
GTK_RC_FILES=/etc/gtk/gtkrc:/nethome/franky/.gtkrc-1.2-gnome2
GWMCOLOR=darkgreen
GWMTERM=xterm
HISTFILESIZE=5000
history_control=ignoredups
HISTSIZE=2000
HOME=/nethome/franky
HOSTNAME=octarine.hq.xalasys.com
INPUTRC=/etc/inputrc
IRCNAME=franky
JAVA_HOME=/usr/java/j2sdk1.4.0
LANG=en_US
LDFLAGS=-s
LD_LIBRARY_PATH=/usr/lib/mozilla:/usr/lib/mozilla/plugins
LESSCHARSET=latin1
LESS=-edfMQ
LESSOPEN=|/usr/bin/lesspipe.sh %s
LEX=flex
LOCAL_MACHINE=octarine
LOGNAME=franky
LS_COLORS=no=00:fi=00:di=01;34:ln=01;36:pi=40;33:so=01;35:bd=40;33;01:cd=40;33;01:or=01;05;37;41:mi=01;05;37;41:ex=01;32:*.cmd=01;32:*.exe=01;32:*.com=01;32:*.btm=01;32:*.bat=01;32:*.sh=01;32:*.csh=01;32:*.tar=01;31:*.tgz=01;31:*.arj=01;31:*.taz=01;31:*.lzh=01;31:*.zip=01;31:*.z=01;31:*.Z=01;31:*.gz=01;31:*.bz2=01;31:*.bz=01;31:*.tz=01;31:*.rpm=01;31:*.cpio=01;31:*.jpg=01;35:*.gif=01;35:*.bmp=01;35:*.xbm=01;35:*.xpm=01;35:*.png=01;35:*.tif=01;35:
MACHINES=octarine
MAILCHECK=60
MAIL=/var/mail/franky
MANPATH=/usr/man:/usr/share/man/:/usr/local/man:/usr/X11R6/man
MEAN_MACHINES=octarine
MOZ_DIST_BIN=/usr/lib/mozilla
MOZILLA_FIVE_HOME=/usr/lib/mozilla
MOZ_PROGRAM=/usr/lib/mozilla/mozilla-bin
MTOOLS_FAT_COMPATIBILITY=1
MYMALLOC=0
NNTPPORT=119
NNTPSERVER=news
NPX_PLUGIN_PATH=/plugin/ns4plugin/:/usr/lib/netscape/plugins
OLDPWD=/nethome/franky
OS=Linux
PAGER=less
PATH=/nethome/franky/bin.Linux:/nethome/franky/bin:/usr/local/bin:/usr/local/sbin:/usr/X11R6/bin:/usr/bin:/usr/sbin:/bin:/sbin:.
PS1=\[\033[1;44m\]franky is in \w\[\033[0m\]
PS2=More input>
PWD=/nethome/franky
SESSION_MANAGER=local/octarine.hq.xalasys.com:/tmp/.ICE-unix/22106
SHELL=/bin/bash
SHELL_LOGIN=--login
SHLVL=2
SSH_AGENT_PID=22161
SSH_ASKPASS=/usr/libexec/openssh/gnome-ssh-askpass
SSH_AUTH_SOCK=/tmp/ssh-XXmhQ4fC/agent.22106
START_WM=twm
TERM=xterm
TYPE=type
USERNAME=franky
USER=franky
_=/usr/bin/printenv
VISUAL=vi
WINDOWID=20971661
XAPPLRESDIR=/nethome/franky/app-defaults
XAUTHORITY=/nethome/franky/.Xauthority
XENVIRONMENT=/nethome/franky/.Xdefaults
XFILESEARCHPATH=/usr/X11R6/lib/X11/%L/%T/%N%C%S:/usr/X11R6/lib/X11/%l/%T/%N%C%S:/usr/X11R6/lib/X11/%T/%N%C%S:/usr/X11R6/lib/X11/%L/%T/%N%S:/usr/X11R6/lib/X11/%l/%T/%N%S:/usr/X11R6/lib/X11/%T/%N%S
XKEYSYMDB=/usr/X11R6/lib/X11/XKeysymDB
XMODIFIERS=@im=none
XTERMID=
XWINHOME=/usr/X11R6
X=X11R6
YACC=bison -y

2.1.2. Variables locales

Les variables locales ne sont visibles que dans le Shell courant. La commande intégrée set sans aucune option fait afficher une liste de toutes les variables (y compris les variables d'environnement ) et les fonctions. L'affichage sera trié et dans un format réutilisable.

Ci-dessous un fichier diff obtenu par comparaison entre l'affichage de printenv et de set, après l'avoir expurgé des fonctions qui sont aussi affichées par set:

franky ~> diff set.sorted printenv.sorted | grep "<" | awk '{ print $2 }'
BASE=/nethome/franky/.Shell/hq.xalasys.com/octarine.aliases
BASH=/bin/bash
BASH_VERSINFO=([0]="2"
BASH_VERSION='2.05b.0(1)-release'
COLUMNS=80
DIRSTACK=()
DO_FORTUNE=
EUID=504
GROUPS=()
HERE=/home/franky
HISTFILE=/nethome/franky/.bash_history
HOSTTYPE=i686
IFS=$'
LINES=24
MACHTYPE=i686-pc-linux-gnu
OPTERR=1
OPTIND=1
OSTYPE=linux-gnu
PIPESTATUS=([0]="0")
PPID=10099
PS4='+
PWD_REAL='pwd
SHELLOPTS=braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor
THERE=/home/franky
UID=504

	Awk
	L'outil GNU Awk est expliqué au Chapitre 6, Le langage de programmation GNU awk.

Les variables sont sensibles à la casse et en majuscule par défaut. Donner des noms en minuscule aux variables locales est une convention parfois employée. Cependant, vous êtes libre de nommer comme vous voulez ou de mélanger la casse. Le nom peut aussi comprendre des chiffres, mais un nom commençant par un chiffre n'est pas admis :

prompt> export 1number=1
bash: export: `1number=1': not a valid identifier

Pour affecter une valeur dans un Shell, la commande est

Laisser des espaces autour du signe égal causera une erreur. Il est conseillé d'entourer la valeur avec des guillemets lors de l'assignation : ça réduit les risques d'erreurs.

Divers exemples avec minuscules et majuscules, chiffres et espaces :

franky ~> MYVAR1="2"

franky ~> echo $MYVAR1
2

franky ~> first_name="Franky"

franky ~> echo $first_name
Franky

franky ~> full_name="Franky M. Singh"

franky ~> echo $full_name
Franky M. Singh

franky ~> MYVAR-2="2"
bash: MYVAR-2=2: command not found

franky ~> MYVAR1 ="2"
bash: MYVAR1: command not found

franky ~> MYVAR1= "2"
bash: 2: command not found

franky ~> unset MYVAR1 first_name full_name

franky ~> echo $MYVAR1 $first_name $full_name
<--no output-->

franky ~>

Une variable créée comme celles ci-dessus est seulement visible par le Shell actif. C'est une variable locale: les processus enfants de ce Shell actif ne connaîtront pas cette variable. Afin de faire connaître ces variables à un sous-Shell, nous avons besoin de faire un export avec l'intégrée export. Les variables exportées sont appelées les variables d'environnement. Définir et exporter sont souvent 2 actions faites en même temps.

Un sous-Shell peut changer la valeur de variables héritées de son parent, mais cette modification n'affecte pas le parent. Cet exemple en fait la démonstration :

franky ~> full_name="Franky M. Singh"

franky ~> bash

franky ~> echo $full_name


franky ~> exit

franky ~> export full_name

franky ~> bash

franky ~> echo $full_name
Franky M. Singh

franky ~> export full_name="Charles the Great"

franky ~> echo $full_name
Charles the Great

franky ~> exit

franky ~> echo $full_name
Franky M. Singh

franky ~>

Quand d'abord on essaye de lire la valeur de full_name dans un sous-Shell, on n'a rien (echo affiche une chaîne nulle). Le sous-Shell finit, et full_name est exporté par le parent - une variable peut être exportée après qu'elle ait été assignée. Puis un nouveau sous-Shell est lancé, dans lequel la variable exportée par le parent est visible. Le contenu de la variable est changé, mais la valeur de cette variable pour le parent reste la même.

Le Shell considère certains paramètres spécifiquement. Ces paramètres ne peuvent qu'être référencés ; leur affectation n'est pas permise.

	$* versus $@
	L'implémentation de « $* » a toujours été un problème et aurait dû être remplacé pratiquement par le comportement de « $@ ». Dans presque tous les cas quand le programmeur utilise « $* », il veut dire « $@ ». « $* » peut être la cause de bugs et même de trou de sécurité dans votre programme.

Les paramètres positionnels sont les mots qui suivent le nom d'un script Shell. Ils définissent les variables $1, $2, $3 etc. Autant que nécessaire, ces variables sont ajoutées dans un tableau interne. $# mémorise le nombre de paramètres, comme démontré dans ce simple script :

#!/bin/bash

# positional.sh
# Ce script lit 3 paramètres positionnels et les affiche.

POSPAR1="$1"
POSPAR2="$2"
POSPAR3="$3"

echo "$1 est le premier paramètre positionnel, \$1."
echo "$2 est le deuxième paramètre positionnel, \$2."
echo "$3 est le troisième paramètre positionnel, \$3."
echo
echo "Le nombre total de paramètres positionnels est $#."

A l'exécution on peut donner autant de paramètres que l'on veut :

franky ~> positional.sh un deux trois quatre cinq
un est le premier paramètre positionnel, $1.
deux est le deuxième paramètre positionnel, $2
trois est le troisième paramètre positionnel, $3.

Le nombre total de paramètres positionnels est 5.

franky ~> positional.sh un deux
un est le premier paramètre positionnel, $1.
deux est le deuxième paramètre positionnel, $2
 est le troisième paramètre positionnel, $3.

Le nombre total de paramètres positionnels est 2

Plus de précisions sur l'évaluation de ces paramètres au Chapitre 7, Les instructions de condition et à la Section 7, « L'intégrée shift ».

Quelques exemples sur les autres paramètres spéciaux :

franky ~> grep dictionary /usr/share/dict/words
dictionary

franky ~> echo $_
/usr/share/dict/words

franky ~> echo $$
10662

franky ~> mozilla &
[1] 11064

franky ~> echo $!
11064

franky ~> echo $0
bash

franky ~> echo $?
0

franky ~> ls doesnotexist
ls: doesnotexist: No such file or directory

franky ~> echo $?
1

franky ~>

L'utilisateur franky lance la commande grep, qui a pour effet la valorisation de la variable _. L'ID du processus de son Shell est 10662. Après avoir mis un travail en tâche de fond, la variable ! renvoie l'ID du processus du travail en tâche de fond. Le Shell actif est bash. Quand une erreur se produit, ? renvoie un statut d'exécution différent de 0 (zéro).

En plus de rendre le script plus lisible, les variables vous permettent d'utiliser un même script dans divers environnements ou pour des finalités multiples. Prenez l'exemple suivant, un script très simple qui effectue une sauvegarde du répertoire racine de franky vers un serveur distant :

#!/bin/bash

# Ce script fait une sauvegarde de mon répertoire personnel.

cd /home

# Ceci crée le fichier archive
tar cf /var/tmp/home_franky.tar franky > /dev/null 2>&1

# Avant supprimer l'ancien fichier bzip2.  Redirige les erreurs parce que ceci en génère quand l'archive
# n'existe pas.  Puis crée un nouveau fichier compressé.
rm /var/tmp/home_franky.tar.bz2 2> /dev/null
bzip2 /var/tmp/home_franky.tar

# Copie le fichier vers un autre hôte - nous avons une clé ssh pour effectuer ce travail sans intervention.
scp /var/tmp/home_franky.tar.bz2 bordeaux:/opt/backup/franky > /dev/null 2>&1

# Crée un marqueur temporel dans un fichier journal..
date > /home/franky/log/home_backup.log
echo backup succeeded > /home/franky/log/home_backup.log

Avant tout, vous avez plus tendance à faire des erreurs si vous saisissez au clavier les noms de fichiers et de répertoires chaque fois que nécessaire. De plus supposez que franky veuille donner ce script à carol, alors carol aura à faire des modifications par l'éditeur avant de pouvoir sauvegarder son répertoire. De même si franky veut se servir du script pour sauvegarder d'autres répertoires. Pour une réutilisation aisée, transformer tous les fichiers, répertoires, nom d'utilisateur, nom d'hôte, etc. en variables. Ainsi, vous n'avez besoin que de modifier la variable une fois, et non pas de modifier chaque occurrence de la chaîne correspondante tout au long du script. Voici un exemple :

#!/bin/bash
                                                                                                 
# Ce script fait une sauvegarde de mon répertoire racine.

# Modifier les valeurs des variables pour que le script tourne pour vous :
BACKUPDIR=/home
BACKUPFILES=franky
TARFILE=/var/tmp/home_franky.tar
BZIPFILE=/var/tmp/home_franky.tar.bz2
SERVER=bordeaux
REMOTEDIR=/opt/backup/franky
LOGFILE=/home/franky/log/home_backup.log

cd $BACKUPDIR

# Ceci crée le fichier d'archive
tar cf $TARFILE $BACKUPFILES > /dev/null 2>&1
                                                                                                 
# D'abord supprimer l'ancien fichier bzip2.  Redirige les erreurs parce que ceci en génère quand l'archive
# n'existe pas.  Puis crée un nouveau fichier compressé.
rm $BZIPFILE 2> /dev/null
bzip2 $TARFILE

# Copie le fichier vers un autre hôte - nous avons une clé ssh pour effectuer ce travail sans intervention.
scp $BZIPFILE $SERVER:$REMOTEDIR > /dev/null 2>&1

# Crée un marqueur temporel dans un fichier journal..
date > $LOGFILE
echo backup succeeded > $LOGFILE

Répertoires volumineux et faible bande passante

Tout le monde peut comprendre l'exemple ci-dessus, en utilisant un répertoire réduit et un hôte de son sous-réseau. En fonction de votre bande passante, de la taille du répertoire et de l'endroit du serveur distant, cela peut prendre un temps terriblement long de faire la sauvegarde. Pour les répertoires les plus volumineux et une bande passante faible, employez rsync pour garder les répertoires synchronisés entre les 2 machines.

Certaines touches(NdT : séquence de caractères) ont un sens spécial dans un certain contexte. La protection - ou encore citation - est utilisée pour s'échapper du sens spécial de ces caractères ou mots : en d'autres termes l'échappement peut désactiver le comportement spécial de ces caractères, il peut empêcher les mots réservés d'être reconnus comme tel et il peut désactiver l'expansion de paramètres.

Le caractère Echap sert à inhiber la signification spéciale d'un caractère unique. Le slash inversé sans guillemets, \, est utilisé comme caractère Echap dans Bash. Il préserve le sens littéral du caractère le suivant, à l'exception de saut de ligne. Si un caractère 'saut de ligne' apparaît juste après le slash inversé, cela marque la continuation de la ligne quand elle est plus longue que la largeur du terminal ; le slash inversé est ôté du flot entré et donc en fait ignoré.

franky ~> date=20021226

franky ~> echo $date
20021226

franky ~> echo \$date
$date

Dans cet exemple, la variable date est définie avec une valeur. Le premier echo affiche la valeur de la variable, mais dans le second le signe $ est protégé.

Les apostrophes (') sont utilisées pour préserver la valeur littérale des caractères enfermés entre apostrophes. Une apostrophe ne peut pas être enfermée entre apostrophes, même si elle est précédée par un slash inversée.

Continuons avec l'exemple précédent :

franky ~> echo '$date'
$date

Avec les guillemets la valeur littérale de tous les caractères est préservée, sauf pour le $, les apostrophes inversées (``) et le slash inversé.

Le $ et `` conservent leur sens spécial à l'intérieur de guillemets.

Le slash inversé conserve son effet seulement quand il est suivi de $, ``, ", \, et 'saut de ligne'. Au sein de guillemets, les \ sont éliminés du flot entré quand il est suivi d'un de ces caractères. Le \ qui précède les caractères sans sens spécial est laissé en l'état pour être interprété par le Shell.

Un guillemet peut être protégé à l'intérieur de guillemets en le faisant précéder par \.

franky ~> echo "$date"
20021226

franky ~> echo "`date`"
Sun Apr 20 11:22:06 CEST 2003

franky ~> echo "I'd say: \"Go for it!\""
I'd say: "Go for it !"

franky ~> echo "\"
More input>"

franky ~> echo "\\"
\

Les mots de la forme « $'MOT' » sont traités d'une manière spéciale. Le mot se transforme en une chaîne, avec le caractère Echap slash inversé remplacé comme spécifié dans le standard ANSI-C. La séquence d'échappement du slash inversé peut être trouvée dans la documentation Bash.

Une chaîne entre guillemets précédée par un $ sera traitée selon la norme en vigueur. Si cette norme est celle de « C » ou de « POSIX », le $ est ignoré. Si la chaîne est transposée avec remplacement, le résultat est entre guillemets.

Après que la commande ait été décomposée en éléments (voir la Section 4.1.1, « La syntaxe Shell »), ces éléments ou mots sont interprétés ou autrement dit résolus. Il y a 8 sortes d'expansion effectuées, lesquelles vont être traitées dans les sections suivantes dans l'ordre où le processus opère.

Après toutes les sortes d'expansions effectuées, guillemets et apostrophes sont éliminés.

L'expansion d'accolade est un mécanisme par lequel des chaînes peuvent être arbitrairement générées. Les patrons sujets à expansion prennent la forme d'un préfixe optionnel, suivi d'une série de chaînes séparées par des virgules, le tout à l'intérieur d'accolades, suivi par un suffixe optionnel. Le préfixe enrichit chaque chaîne au début, puis à son tour le suffixe enrichit la fin, résultant en une expansion de gauche à droite.

L'expansion d'accolades peut être imbriquée. Le résultat des chaînes ainsi obtenues n'est pas trié ; l'ordre de gauche à droite est préservé.

franky ~> echo sp{el,il,al}l
spell spill spall

L'expansion d'accolade est effectuée avant tout autres, et tout caractère spécial en vue d'un autre type d'expansion est préservé dans ce résultat. C'est strictement textuel. Bash n'applique aucune interprétation syntaxique au contexte de l'expansion ou au texte entre accolades. Pour éviter des conflits avec l'expansion de paramètres, la chaîne « ${ » n'est pas éligible à l'expansion d'accolade.

Une forme correcte d'expansion d'accolades doit contenir une accolade ouvrante et fermante non protégée, et au moins une virgule non protégée. Toute forme d'expansion d'accolade incorrecte est laissée telle quelle.

Si un mot commence par un tilde non protégé (« ~ »), tous les caractères jusqu'au premier slash non-protégé (ou tous les caractères si il n'y a pas de slash non-protégé) sont considérés comme un préfixe tilde. Si aucun des caractères dans le préfixe tilde n'est protégé, ces caractères qui suivent le tilde sont considérés comme un nom de connection possible. Si ce nom de connection est la chaîne nulle, le tilde est remplacé par la valeur de la variable Shell HOME. Si HOME n'est pas défini, le répertoire racine de l'utilisateur exécutant le Shell est utilisé à la place. Sinon, le préfixe tilde est remplacé par le répertoire racine associé au nom de connection spécifié.

Si le préfixe tilde est « ~+ », la valeur de la variable Shell PWD remplace le préfixe tilde. Si le préfixe tilde est « ~- », la valeur de la variable Shell OLDPWD, si définie, s'y substitue.

Si les caractères suivant le tilde dans le préfixe consistent en un nombre N, optionnellement préfixé par « + » ou « - », le préfixe tilde est remplacé par l'élément correspondant dans la pile de répertoire, comme il serait affiché par l'intégrée dirs invoquée avec, comme argument, le caractère suivant le tilde dans le préfixe tilde. Si le préfixe tilde, sans le tilde, consiste en un nombre sans signe « + » ou « - », « + » est implicite.

Si le nom de connection est invalide, ou si l'expansion de tilde échoue, le mot est laissé tel quel.

Chaque assignation de variable donne lieu à un contrôle sur la présence d'un préfixe tilde non-protégé qui suit immédiatement un « : » ou un « = ». Dans ce cas l'expansion du tilde se produit. Par conséquent, on peut utiliser un nom de fichier avec tilde dans PATH, MAILPATH, et CDPATH, et le Shell utilise l'expansion du nom.

Exemple :

franky ~> export PATH="$PATH:~/testdir"

~/testdir sera interprété en $HOME/testdir, donc si $HOME est /var/home/franky, le répertoire /var/home/franky/testdir sera ajouté au contenu de la variable PATH.

Le caractère « $ » introduit l'expansion de paramètre, la substitution de commande ou l'expansion arithmétique. Le nom du paramètre - ou symbole - à interpréter peut être enchâssé entre accolades. Elles sont optionnelles mais utiles à la séparation des caractères du symbole à interpréter de ceux suivant immédiatement.

Quand l'accolade est utilisée, le premier « } » - non protégé par un slash inversé ou ni à l'intérieur d'une chaîne entre guillemet, ni à l'intérieur d'une expansion arithmétique incorporée ou d'une substitution de commande ou d'expansion de paramètre - est le signal fermant correspondant.

La forme basique de l'expansion de paramètre est « ${PARAMETRE} ». La valeur de « PARAMETRE » y est substituée. Les accolades sont requises quand « PARAMETRE » est un paramètre positionnel avec un symbole de plus de 1 caractère, ou quand « PARAMETRE » est suivi par un caractère qui ne doit pas être interprété comme faisant parti du symbole.

Si le premier caractère de « PARAMETRE » est un point d'exclamation, Bash considère les caractères suivants de « PARAMETRE » comme étant le symbole de la variable ; cette variable est alors interprétée et utilisée dans la suite de la substitution, plutôt que la valeur de « PARAMETRE » lui-même. Ceci est connu sous le nom d'expansion indirecte.

Vous êtes certainement familier avec l'expansion de paramètre directe, parce qu'elle est fréquente même dans les cas les plus simples, tel que celui ci-dessus ou le suivant :

franky ~> echo $SHELL
/bin/bash

Voici un exemple d'expansion indirecte :

franky ~> echo ${!N*}
NNTPPORT NNTPSERVER NPX_PLUGIN_PATH

Notez que cela ne donne pas la même chose que echo $N*.

La construction suivante permet la création du nom de variable si il n'existe pas :

Exemple :

franky ~> echo $FRANKY

franky ~> echo ${FRANKY:=Franky}
Franky

Cependant, les paramètres spéciaux, dont les paramètres positionnels, ne doivent pas être affectés par ce biais.

Nous approfondirons l'utilisation de l'accolade dans le traitement des variables au Chapitre 10, Un peu plus sur les variables. Les pages info de Bash fournissent aussi d'autres informations.

La substitution de commande permet de remplacer la commande elle-même par son résultat. La substitution de commande survient quand une commande est enchâssée ainsi :

ou ainsi avec les apostrophes inversées :

Bash effectue l'expansion en exécutant COMMANDE et en la remplaçant par son résultat, avec tous les sauts de lignes éliminés. Les sauts de ligne incorporés ne sont pas éliminés, mais ils peuvent l'avoir été pendant le découpage en mot.

franky ~> echo `date`
Thu Feb 6 10:06:20 CET 2003

Quand l'ancien signal de substitution - l'apostrophe inversée - est utilisé, le slash inversé conserve son sens littéral sauf si il est suivi de « $ », « ` », ou « \ ». La première apostrophe inversée non précédée d'un slash inversé termine la commande de substitution. Quand la forme « $(COMMANDE) » est utilisée, tous les caractères entre parenthèses font partie de la commande ; aucun n'est traité spécifiquement.

Une substitution de commande peut être incorporée à une autre. Pour en incorporer dans la forme apostrophes inversées, protéger l'apostrophe la plus interne avec des slashs inversés.

Si la substitution apparaît entre guillemets, le découpage en mots et l'expansion de noms de fichiers ne sont pas effectués sur les résultats.

L'expansion arithmétique permet l'évaluation d'une expression arithmétique et la substitution par le résultat. Le format pour l'expansion arithmétique est :

L'expression est traitée comme si elle était entre guillemets, mais un guillemet à l'intérieur des parenthèses n'est pas traité spécifiquement. Tous les mots de l'expression font l'objet d'expansion de paramètre, de substitution de commande, et d'élimination d'apostrophe. Une substitution arithmétique peut être incorporée à une autre.

L'évaluation d'une expression arithmétique est faite en entiers de taille fixe sans contrôle de dépassement - bien que la division par zéro soit détectée comme une erreur. Les opérateurs sont à peu près les mêmes que dans le langage de programmation C. Par ordre de priorité décroissante, la liste ressemble à ceci :

Les variables Shell sont autorisées comme opérandes ; l'expansion est effectuée avant l'évaluation de l'expression. Dans une expression, les variables Shell peuvent aussi être référencées par le nom sans utiliser la syntaxe d'expansion de paramètre. La valeur d'une variable est évaluée en tant qu'expression arithmétique quand elle est référencée. Une variable Shell doit avoir l'attribut 'entier' positionné pour être utilisée dans une expression.

Une constante commençant par un 0 (zéro) est considérée comme un chiffre octal. Un « 0x » ou « 0X » au début marque l'hexadécimal. Sinon, un nombre prend la forme « [BASE'#']N », où « BASE » est un nombre décimal entre 2 et 64 représentant la base arithmétique, et N un nombre dans cette base. Si « BASE'#' » est omis, alors la base 10 est utilisée. Les chiffres supérieurs à 9 sont représentés par les minuscules, les majuscules, « @ », et « _ », dans cet ordre. Si « BASE » est inférieur ou égale à 36, les minuscules et les majuscules sont interchangeables dans leur représentation des chiffres entre 10 et 35.

Les opérateurs sont évalués par ordre de priorité. Les sub-expressions entre parenthèses sont évaluées d'abord ce qui peut prévaloir sur l'ordre de priorité ci-dessus.

Autant que possible, les utilisateurs de Bash devraient essayer d'utiliser la syntaxe avec les crochets :

Cependant, ceci ne fait qu'évaluer l'EXPRESSION, et ne teste pas :

franky ~> echo $[365*24]
8760

Voir Section 1.2.2, « Comparaisons numériques », entre autres, pour des exemples pratiques de scripts.

La substitution de processus est effectuée par les systèmes qui admettent les tubes (pipes) nommés (FIFO : NdT=First In First Out=premier entré, premier sorti) ou la méthode /dev/fd de nommage de fichiers ouverts. Ca se présente sous la forme de

ou l'option

Le processus LIST est exécuté avec ses entrées et sorties connectées à un tube ou des fichiers dans /dev/fd. Le nom de ce fichier est passé en argument à la commande courante comme le résultat de l'expansion. Si la forme « >(LIST) » est employée, d'écrire dans le fichier alimente l'entrée de LIST. Si la forme « <(LIST) » est employée, le fichier passé en argument devrait être lu pour obtenir la sortie de LIST. Notez qu'aucun espace ne doit apparaître entre le signe < ou > et la parenthèse gauche, sinon la construction serait interprétée comme une redirection.

Quand la substitution de processus est possible, elle est effectuée simultanément avec l'expansion de variable, la substitution de commande, et l'expansion arithmétique.

Plus de détails à la Section 2.3, « Redirection et descripteurs de fichiers ».

Le Shell recherche dans le résultat de l'expansion de paramètre, de la substitution de commande, et de l'expansion arithmétique des mots qui n'ont pas été interprétés du fait des guillemets.

Le Shell traite chaque caractère de $IFS comme un délimiteur, et découpe le résultat des autres expressions en mots sur la base de ces caractères. Si IFS n'est pas déclaré, ou si il vaut exactement « '<space><tab><newline>' », sa valeur par défaut, alors toute suite de caractères IFS sert à délimiter les mots. Si IFS Si IFS a une valeur autre que celle par défaut, alors les suites d'« espace » et « Tab » sont ignorées au début et à la fin du mot, du moment que l'espace est inclut dans IFS (un caractère espace IFS). Tout caractère dans IFS qui n'est pas un espace IFS, accolé à un caractère espace IF, délimite un champ. Une suite de caractère espace IFS est aussi traitée comme un délimiteur. Si la valeur de IFS est nulle, le découpage en mots n'intervient pas.

Un argument vide (« "" » or « '' ») est conservé. Un argument ayant une valeur nulle, suite à l'expansion d'un paramètre, est éliminé. Si un paramètre non valorisé est interprété à l'intérieur de guillemets, il en résulte un argument nul qui est conservé.

	Expansion et découpage en mots
	Si aucune expansion ne se produit, aucun découpage n'est effectué

Après le découpage en mots, à moins que l'option -f ait été utilisée (voir Section 3.2, « Débugger qu'une partie du script »), Bash scanne chaque mot pour les caractères « * », « ? », et « [ » Si l'un de ces caractères apparaît, alors le mot est considéré comme étant un PATRON, et est remplacé par la liste des noms de fichiers correspondants au patron triée par ordre alphabétique. Si aucun nom de fichier ne correspond, et que l'option Shell nullglob est désactivée, le mot est laissé en l'état. Si l'option nullglob est activée, et qu'aucune correspondance n'est trouvée, le mot est éliminé. Si l'option Shell nocaseglob est activée, la correspondance est recherchée sans considérer la casse des caractères alphabétiques.

Quand un patron sert à la génération de noms de fichiers, le caractère « . » au début d'un nom de fichier ou immédiatement après un slash doit trouver une correspondance explicitement, à moins que l'option Shell dotglob soit activée. Lors de la recherche de correspondance de noms de fichiers, le caractère slash doit toujours être explicitement indiqué. Dans les autres cas, le caractère « . » n'est pas traité spécifiquement.

La variable Shell GLOBIGNORE peut être utilisée pour restreindre l'ensemble de fichiers en correspondance avec le patron. Si GLOBIGNORE est activé, les noms qui correspondent à l'un des patrons dans GLOBIGNORE sont retirés de la liste de correspondance. Les noms de fichiers . et .. sont toujours ignorés, même si GLOBIGNORE est désactivé. Cependant, déclarerGLOBIGNORE a pour effet d'activer l'option Shell dotglob, donc tous les autres fichiers commençant par « . » correspondront. Pour garder la possibilité d'ignorer les fichiers commençant par « . », indiquer « .* » comme étant un des patrons à ignorer dans GLOBIGNORE. L'option dotglob est désactivé quand GLOBIGNORE n'est pas déclaré.

Un alias permet de substituer un mot à une chaîne de caractère quand il est utilisé comme premier mot d'une commande simple. Le Shell maintient une liste d'alias qui sont déclarés ou invalidés avec les intégrées alias et unalias . Saisir alias sans options pour afficher une liste des alias connus du Shell courant.

franky: ~> alias
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias PAGER='less -r'
alias Txterm='export TERM=xterm'
alias XARGS='xargs -r'
alias cdrecord='cdrecord -dev 0,0,0 -speed=8'
alias e='vi'
alias egrep='grep -E'
alias ewformat='fdformat -n /dev/fd0u1743; ewfsck'
alias fgrep='grep -F'
alias ftp='ncftp -d15'
alias h='history 10'
alias fformat='fdformat /dev/fd0H1440'
alias j='jobs -l'
alias ksane='setterm -reset'
alias ls='ls -F --color=auto'
alias m='less'
alias md='mkdir'
alias od='od -Ax -ta -txC'
alias p='pstree -p'
alias ping='ping -vc1'
alias sb='ssh blubber'
alias sl='ls'
alias ss='ssh octarine'
alias sss='ssh -C server1.us.xalasys.com'
alias sssu='ssh -C -l root server1.us.xalasys.com'
alias tar='gtar'
alias tmp='cd /tmp'
alias unaliasall='unalias -a'
alias vi='eval `resize`;vi'
alias vt100='export TERM=vt100'
alias which='type'
alias xt='xterm -bg black -fg white &'

franky ~>

Les alias sont utiles pour spécifier une version par défaut d'une commande qui existe en plusieurs versions sur le système, ou pour spécifier les options par défaut d'une commande. Un autre emploi des alias est de permettre la correction des fautes de frappes.

Le premier mot de chaque commande simple, si il n'est pas entre guillemets, est recherché dans la liste des alias. Si il y est, ce mot est remplacé par le texte correspondant. Le nom d'alias et le texte correspondant peut contenir tout caractère Shell valide, y compris les métacaractères, avec l'exception que le nom d'alias ne doit pas contenir « = ». Le premier mot du texte correspondant est recherché dans les alias, mais si ce mot est le même que celui traité il n'est pas remplacé une deuxième fois. Ceci signifie qu'on peut déclarer ls équivalent à ls -F, par exemple, et Bash n'essayera pas de remplacer récursivement l'alias trouvé. Si le dernier caractère de la valeur de l'alias est un espace ou une tabulation, alors le mot suivant de la commande après l'alias est aussi recherché dans les alias.

Les alias ne sont pas remplacés quand le Shell n'est pas interactif, sauf si l'option expand_aliases est activée par l'intégrée shopt shell.

Un alias est créé par l'intégrée alias . Pour une déclaration permanente, ajouter la commande alias dans l'un de vos scripts d'initialisation ; si vous l'entrez seulement sur la ligne de commande, il sera connu que durant la session.

franky ~> alias dh='df -h'

franky ~> dh
Filesystem            Size  Used Avail Use% Mounted on
/dev/hda7             1.3G  272M 1018M  22% /
/dev/hda1             121M  9.4M  105M   9% /boot
/dev/hda2              13G  8.7G  3.7G  70% /home
/dev/hda3              13G  5.3G  7.1G  43% /opt
none                  243M     0  243M   0% /dev/shm
/dev/hda6             3.9G  3.2G  572M  85% /usr
/dev/hda5             5.2G  4.3G  725M  86% /var

franky ~> unalias dh

franky ~> dh
bash: dh: command not found

franky ~>

Bash lit toujours au moins une ligne complète saisie avant d'exécuter une des commandes de cette ligne. L'alias est interprété quand la commande est lue, non pas quand elle est exécutée. De ce fait, une définition d'alias apparaissant sur la même ligne qu'une autre commande ne prendra effet qu'à la lecture de la ligne suivante. Les commandes suivant la définition de l'alias sur la ligne ne seront pas affectées par le nouvel alias. Ce comportement joue aussi quand une fonction est exécutée. Un alias est interprété quand la définition d'une fonction est lue, pas quand la fonction est exécutée, parce que la définition de fonction est elle-même une commande composée. En conséquence, l'alias définit dans une fonction n'est pas utilisable tant que la fonction n'a pas été exécutée. En toute sécurité, toujours définir les alias sur des lignes séparées, et ne pas employer alias dans des commandes composées.

Les processus enfants n'héritent pas des alias. Bourne shell (sh) ne reconnaît pas les alias.

Plus sur les fonctions au Chapitre 11, Fonctions.

	Les fonctions sont plus rapides
	Les alias sont recherchés après les fonctions et donc leur résolution est plus lente. Alors que les alias sont plus faciles à comprendre, les fonctions Shell sont préférées aux alias pour la plupart des usages.

Nous avons déjà abordé un certain nombre d'options Bash utiles à la correction des scripts. Dans cette section, nous aurons une vue plus approfondie des options Bash.

Utilisez l'option -o de set pour afficher toutes les options Shell :

willy:~> set -o
allexport		off
braceexpand		on
emacs			on
errexit			off
hashall			on
histexpand		on
history			on
ignoreeof		off
interactive-comments	on
keyword			off
monitor			on
noclobber		off
noexec			off
noglob			off
nolog			off
notify			off
nounset			off
onecmd			off
physical		off
posix			off
privileged		off
verbose			off
vi			off
xtrace			off

Voir les pages Bash info, section Shell Built-in Commands \u2192 The Set Built-in pour une description de chaque option. Beaucoup d'options ont un raccourci de un caractère : l'option xtrace , par exemple, équivaut à spécifier set -x.

Les options Shell peuvent être modifiées soit par rapport à celles par défaut à l'appel du Shell, soit au cours des traitements Shell. Elles peuvent être aussi intégrées aux fichiers de configuration des ressources Shell.

La commande suivante exécute un script en mode compatible POSIX :

willy:~/scripts> bash --posix script.sh

Pour changer l'environnement temporairement, ou à l'usage d'un script, nous utiliserions plutôt set. Employez - (moins) pour activer l'option, + pour la désactiver :

willy:~/test> set -o noclobber

willy:~/test> touch test

willy:~/test> date > test
bash: test: cannot overwrite existing file

willy:~/test> set +o noclobber

willy:~/test> date > test

L'exemple ci-dessus montre l'usage de l'option noclobber , qui évite que les fichiers existants soient écrasés par les opérations de redirection. La même chose joue pour les options à 1 caractère, par exemple -u, qui, activée, traite les variables non déclarées comme des erreurs, et quitte un Shell non-interactif quand survient une telle erreur :

willy:~> echo $VAR


willy:~> set -u

willy:~> echo $VAR
bash: VAR: unbound variable

Cette option est aussi utile pour détecter des valeurs incorrectes affectées à des variables : la même erreur se produira aussi, par exemple, quand une chaîne de caractère est affectée à une variable qui a été déclarée explicitement comme devant contenir une valeur numérique.

Voici un dernier exemple qui illustre l'option noglob , laquelle empêche les caractères spéciaux d'être interprétés :

willy:~/testdir> set -o noglob

willy:~/testdir> touch *

willy:~/testdir> ls -l *
-rw-rw-r--    1 willy    willy		0 Feb 27 13:37 *

Une expression régulière est un patron qui recouvre un ensemble de chaînes de caractères. Les expressions régulières sont construites de façon analogique aux expressions arithmétiques par l'emploi de diverses opérateurs qui combinent d'autres expressions réduites.

Les briques de base sont les expressions régulières qui correspondent à un seul caractère. La plupart des caractères, incluant toutes les lettres et les chiffres, sont des expressions régulières qui correspondent exactement à elle même. Tout métacaractère portant un sens spécial peut être protégé en le précédant d'un slash inversé.

Une expression régulière peut être suivi par un ou plusieurs opérateurs de répétition (métacaractère) :

2 expressions régulières peuvent être concaténées ; l'expression régulière résultant correspond à toute chaîne formée par 2 sous-chaînes concaténées qui respectivement correspondent aux sous-expressions.

2 expressions régulières peuvent être jointes par l'opérateur « | » ; l'expression régulière résultant correspond à toute chaîne qui correspond à l'une ou l'autre des sous-expressions.

La répétition a la préséance sur la concaténation, laquelle a la préséance sur la jointure. Toute une expression peut être mise entre parenthèses pour éviter ces règles de préséance.

Dans les expressions régulières basiques les métacaractères « ? », « + », « { », « | », « ( », et « ) » perdent leur sens spécial ; à la place employez la version avec slash inversé « \? », « \+ », « \{ », « \| », « \( », et « \) ».

Vérifiez dans la documentation de votre système si les commandes admettent les expressions étendues dans les expressions régulières.

grep cherche dans les fichiers en entrée les lignes qui contiennent une correspondance dans une liste donnée de patrons. Quand il trouve une correspondance dans une ligne, il copie la ligne sur la sortie standard (par défaut), ou sur tout autre type de sortie que vous avez requise par les options.

Bien que grep s'attende à établir une correspondance sur du texte, il n'a pas de limite sur la longueur de la ligne lue autre que celle de la mémoire disponible, et il trouve la correspondance sur n'importe quel caractère dans la ligne. Si le dernier octet d'un fichier en entrée n'est pas un saut de ligne, grep discrètement en ajoute un. Parce que le saut de ligne est aussi un séparateur dans la liste des patrons, il n'y a pas moyen de repérer les caractères saut de ligne dans le texte.

Quelques exemples :

cathy ~> grep root /etc/passwd
root:x:0:0:root:/root:/bin/bash
operator:x:11:0:operator:/root:/sbin/nologin

cathy ~> grep -n root /etc/passwd
1:root:x:0:0:root:/root:/bin/bash
12:operator:x:11:0:operator:/root:/sbin/nologin

cathy ~> grep -v bash /etc/passwd | grep -v nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
news:x:9:13:news:/var/spool/news:
mailnull:x:47:47::/var/spool/mqueue:/dev/null
xfs:x:43:43:X Font Server:/etc/X11/fs:/bin/false
rpc:x:32:32:Portmapper RPC user:/:/bin/false
nscd:x:28:28:NSCD Daemon:/:/bin/false
named:x:25:25:Named:/var/named:/bin/false
squid:x:23:23::/var/spool/squid:/dev/null
ldap:x:55:55:LDAP User:/var/lib/ldap:/bin/false
apache:x:48:48:Apache:/var/www:/bin/false

cathy ~> grep -c false /etc/passwd
7

cathy ~> grep -i ps ~/.bash* | grep -v history
/home/cathy/.bashrc:PS1="\[\033[1;44m\]$USER is in \w\[\033[0m\] "

Avec la première commande, l'utilisateur cathy affiche les lignes de /etc/passwd contenant la chaîne root.

Puis elle affiche le numéro des lignes contenant cette chaîne.

Avec la troisième commande elle vérifie quels utilisateurs n'utilisent pas bash, mais les comptes avec nologin ne sont pas affichés.

Puis elle compte le nombre de comptes qui ont /bin/false comme Shell.

La dernière commande affiche les lignes de tous les fichiers dans son répertoire racine qui commencent par ~/.bash, excluant les correspondances avec history, afin d'exclure des correspondances de ~/.bash_history qui pourrait contenir la même chaîne en majuscule et minuscule. Remarquez que la recherche se fait sur la chaîne « ps », et pas sur la commande ps.

Maintenant voyons ce que nous pouvons faire d'autre avec grep et des expressions régulières.

En plus de grep et des expressions régulières, il y a un bon paquet de correspondances que vous pouvez faire directement dans le Shell, sans avoir besoin d'un programme externe.

Comme vous savez déjà, l'astérisque (*) et le point d'interrogation (?) ciblent toute chaîne ou tout caractère, respectivement. Protégez ces caractères spéciaux pour les cibler littéralement :

cathy ~> touch "*"

cathy ~> ls "*"
*

Mais vous pouvez aussi employer les crochets pour cibler tout caractère ou intervalle de caractères compris, si la paire de caractères est séparée par un tiret. Un exemple :

cathy ~> ls -ld [a-cx-z]*
drwxr-xr-x    2 cathy	 cathy		4096 Jul 20  2002 app-defaults/
drwxrwxr-x    4 cathy    cathy          4096 May 25  2002 arabic/
drwxrwxr-x    2 cathy    cathy          4096 Mar  4 18:30 bin/
drwxr-xr-x    7 cathy    cathy          4096 Sep  2  2001 crossover/
drwxrwxr-x    3 cathy    cathy          4096 Mar 22  2002 xml/

Ceci liste tous les fichiers dans le répertoire racine de cathy, commençant par « a », « b », « c », « x », « y » ou « z ».

Si le premier caractère entre crochet est « ! » ou « ^ », tout caractère non inclus sera ciblé. Pour cibler le (« - »), l'inclure en premier ou dernier caractère de l'ensemble. L'ordre dépend du paramétrage local et de la valeur de la variable LC_COLLATE, si elle est définie. Rappelez-vous que d'autres paramétrages pourraient interpréter « [a-cx-z] » comme « [aBbCcXxYyZz] » si le tri est fait selon l'ordre du dictionnaire. Si vous voulez être sûr d'avoir l'interprétation classique des intervalles, forcer ce paramétrage en définissant LC_COLLATE ou LC_ALL à « C ».

Les jeux de caractères peuvent être spécifiés entre crochets, avec la syntaxe [:CLASS:], où CLASS est une classe définie dans le standard POSIX et a une des valeurs

« alnum », « alpha », « ascii », « blank », « cntrl », « digit », « graph », « lower », « print », « punct », « space », « upper », « word » or « xdigit ».

Quelques exemples :

cathy ~> ls -ld [[:digit:]]*
drwxrwxr-x    2 cathy	cathy		4096 Apr 20 13:45 2/

cathy ~> ls -ld [[:upper:]]*
drwxrwxr--    3 cathy   cathy           4096 Sep 30  2001 Nautilus/
drwxrwxr-x    4 cathy   cathy           4096 Jul 11  2002 OpenOffice.org1.0/
-rw-rw-r--    1 cathy   cathy         997376 Apr 18 15:39 Schedule.sdc

Quand l'option Shell extglob est activée (par l'intégrée shopt), plusieurs autres opérateurs de correspondance sont reconnus. Plus dans les pages Bash info, section Basic shell features \u2192 Shell Expansions \u2192 Filename Expansion \u2192 Pattern Matching.

Un éditeur de flot (Stream EDitor) est utilisé pour effectuer des transformations simples sur du texte lu depuis un fichier ou un tube (NdT : pipe). Le résultat est envoyé sur la sortie standard. La syntaxe de la commande sed ne spécifie pas de fichier de sortie, mais les résultats peuvent être mémorisés dans un fichier par le biais de redirection. L'éditeur ne modifie pas le flot d'entrée.

Ce qui distingue sed d'autres éditeurs tel vi et ed, c'est sa faculté de filtrer le texte qu'il obtient par un tube. Vous n'avez pas à interagir avec l'éditeur pendant qu'il travaille ; c'est pourquoi sed est parfois appelé un éditeur par lot. Cette caractéristique vous permet d'utiliser des commandes d'édition dans un script, ce qui facilite grandement les tâches d'édition répétitives. Quand vous devez effectuer un remplacement de texte dans un grand nombre de fichiers, sed est d'une grande aide.

Le programme sed peut effectuer substitutions et suppressions avec des expressions régulières, comme celles utilisées avec la commande grep ; voir Section 2, « Exemples en utilisant grep ».

Les commandes d'édition sont similaires à celles utilisées dans l'éditeur vi :

A part les commandes d'édition, vous pouvez donner des options à sed. Un aperçu se trouve dans le tableau ci-dessous :

Les pages info de sed contiennent plus d'informations ; nous ne listons ici que les commandes et les options le plus fréquemment utilisé.

Vous pouvez le faire avec grep, bien sûr, mais vous ne pouvez faire un « chercher-remplacer » avec cette commande. Ceci est juste un début.

Voici notre fichier texte d'exemple :

sandy ~> cat -n exemple
     1  This is the first line of an example text.
     2  It is a text with erors.
     3  Lots of erors.
     4  So much erors, all these erors are making me sick.
     5  This is a line not containing any errors.
     6  This is the last line.

sandy ~>

Nous voulons que sed trouve toutes les lignes contenant le patron ciblé, dans ce cas « erors ». Nous employons le p pour obtenir le resultat :

sandy ~> sed  '/erors/p' exemple
This is the first line of an example text.
It is a text with erors.
It is a text with erors.
Lots of erors.
Lots of erors.
So much erors, all these erors are making me sick.
So much erors, all these erors are making me sick.
This is a line not containing any errors.
This is the last line.

sandy ~>

Comme vous l'avez remarqué, sed affiche le fichier entier, mais les lignes contenant la cible sont affichées 2 fois. Ce n'est pas ce qu'on veut. De sorte à n'afficher que les lignes contenant la cible, employez l'option -n :

sandy ~> sed -n '/erors/p' exemple
It is a text with erors.
Lots of erors.
So much erors, all these erors are making me sick.

sandy ~>

Nous utilisons le même exemple de fichier texte. Maintenant nous voulons seulement voir les lignes qui ne contiennent pas la chaîne cible :

sandy ~> sed '/erors/d' exemple
This is the first line of an example text.
This is a line not containing any errors.
This is the last line.

sandy ~>

La commande d a pour effet d'exclure des lignes de l'affichage.

Les lignes dont le début correspond à un patron donné et la fin à un autre sont affichées comme ça :

sandy ~> sed -n '/^This.*errors.$/p' exemple
This is a line not containing any errors.

sandy ~>

Cette fois nous voulons supprimer les lignes contenant les erreurs. Dans l'exemple ce sont les lignes 2 à 4. Spécifier cet intervalle avec la commande d :

sandy ~> sed '2,4d' exemple
This is the first line of an example text.
This is a line not containing any errors.
This is the last line.

sandy ~>

Pour afficher le fichier à partir d'une certaine ligne jusqu'à la fin, employez une commande de la sorte :

sandy ~> sed '3,$d' exemple
This is the first line of an example text.
It is a text with erors.

sandy ~>

Ceci affiche seulement les 2 premières lignes du fichier exemple.

Les commandes suivantes affichent la première ligne contenant le patron « a text », jusqu'à et inclus la prochaine ligne contenant « a line » :

sandy ~> sed -n '/a text/,/This/p' exemple
It is a text with erors.
Lots of erors.
So much erors, all these erors are making me sick.
This is a line not containing any errors.

sandy ~>

Dans cet exemple de fichier, nous allons maintenant chercher et remplacer les erreurs au lieu de seulement sélectionner les lignes contenant la cible.

sandy ~> sed 's/erors/errors/' exemple
This is the first line of an example text.
It is a text with errors.
Lots of errors.
So much errors, all these erors are making me sick.
This is a line not containing any errors.
This is the last line.

sandy ~>

Comme vous le constatez, ce n'est pas exactement l'effet désiré : en ligne 4, seulement la première occurrence de la chaîne a été remplacée, et il reste encore un 'eror'. Employer la commande g pour indiquer à sed qu'il doit traiter la ligne entière plutôt que de stopper à la première occurrence trouvée :

sandy ~> sed 's/erors/errors/g' exemple
This is the first line of an example text.
It is a text with errors.
Lots of errors.
So much errors, all these errors are making me sick.
This is a line not containing any errors.
This is the last line.

sandy ~>

Pour insérer une chaîne au début de chaque ligne du fichier, par exemple pour citer :

sandy ~> sed 's/^/> /' exemple
> This is the first line of an example text.
> It is a text with erors.
> Lots of erors.
> So much erors, all these erors are making me sick.
> This is a line not containing any errors.
> This is the last line.

sandy ~>

Insérer une chaîne à la fin de chaque ligne :

sandy ~> sed 's/$/EOL/' exemple
This is the first line of an example text.EOL
It is a text with erors.EOL
Lots of erors.EOL
So much erors, all these erors are making me sick.EOL
This is a line not containing any errors.EOL
This is the last line.EOL

sandy ~>

Commandes de recherche et remplacement multiples sont séparées avec l'option -e :

sandy ~> sed -e 's/erors/errors/g' -e 's/last/final/g' exemple
This is the first line of an example text.
It is a text with errors.
Lots of errors.
So much errors, all these errors are making me sick.
This is a line not containing any errors.
This is the final line.

sandy ~>

Garder à l'esprit que sed par défaut affiche les résultats sur la sortie standard, le plus souvent sur la fenêtre de votre terminal. Si vous voulez sauvegarder le résultat dans un fichier, le rediriger :

	Plus d'exemples
	Plein d'exemples sed se trouvent dans les scripts de démarrage de votre machine, lesquels sont d'ordinaire dans /etc/init.d ou /etc/rc.d/init.d. Placez-vous dans le répertoire contenant les scripts d'initialisation de votre système et lancer la commande suivante : grep sed *

De multiples commandes sed peuvent être mémorisées dans un fichier et exécutées avec l'option -f. Quand un tel fichier est créé, assurez-vous que :

Produire ce fichier se fait avec l'opérateur de redirection de sortie >. Ceci est un script d'exemple utile à la création de fichier HTML très simple à partir de fichiers texte simples.

sandy ~> cat script.sed
1i\
<html>\
<head><title>sed generated html</title></head>\
<body bgcolor="#ffffff">\
<pre>
$a\
</pre>\
</body>\
</html>

sandy ~> cat txt2html.sh
#!/bin/bash

# Ceci est un script simple pour convertir du texte en HTML.
# D'abord nous éliminons tous les caractères de saut de ligne, de sorte que l'ajout
# ne se produise qu'une fois, puis nous remplaçons les sauts de ligne.

echo "converting $1..."

SCRIPT="/home/sandy/scripts/script.sed"
NAME="$1"
TEMPFILE="/var/tmp/sed.$PID.tmp"
sed "s/\n/^M/" $1 | sed -f $SCRIPT | sed "s/^M/\n/" > $TEMPFILE
mv $TEMPFILE $NAME

echo "done."

sandy ~>

$1 stocke le premier paramètre d'une commande donnée, dans ce cas le nom du fichier à convertir :

sandy ~> cat test
line1
line2
line3

Plus sur les paramètres positionnels au Chapitre 7, Les instructions de condition.

sandy ~> txt2html.sh test
converting test...
done.

sandy ~> cat test
<html>
<head><title>sed generated html</title></head>
<body bgcolor="#ffffff">
<pre>
line1
line2
line3
</pre>
</body>
</html>

sandy ~>

Ce n'est pas vraiment la bonne méthode ; c'est juste un exemple pour démontrer le potentiel de sed. Voir la Section 3, « Les variables Gawk » pour une solution plus décente à ce problème, avec les constructions awk BEGIN et END.

	sed facile
	Les éditeurs sophistiqués, permettant la mise en relief de la syntaxe, reconnaissent la syntaxe sed. Cela peut être d'une grande aide si vous avez tendance à oublier des slashs inversés.

Gawk est la version GNU du programme couramment disponible sous UNIX awk , un autre éditeur par lot populaire. Du fait que le programme awk n'est souvent qu'un lien vers gawk, nous nous y référerons en tant que awk.

La fonction de base de awk est de chercher dans des fichiers des lignes ou portion de texte contenant un ou des patrons. Quand on trouve dans la ligne un des patrons, des actions sont effectuées sur cette ligne.

Un programme en awk est différent de la plupart des programmes en d'autres langages parce que un programme awk est « construit sur les données » : vous décrivez les données que vous voulez traiter puis le traitement à effectuer si elles sont trouvées. La plupart des langages sont « procéduraux. » Vous devez décrire en détail chacune des étapes du processus. En travaillant avec des langages procéduraux, il est généralement plus difficile de clairement décrire les données que le programme traitera. Pour cette raison, un programme awk est souvent agréablement facile à lire et à écrire.

	Qu'est-ce que cela veut dire ?
	dans les années 1970, 3 programmeurs se sont joints pour créer le langage. Leurs noms étaient Aho, Kernighan et Weinberger. Ils prirent la première lettre de chacun de leur nom pour nommer ce langage. Donc le nom du langage aurait aussi bien pu être « wak ».

Quand vous lancez awk, vous spécifiez un programme awk qui indique à awk quoi faire. Le programme consiste en une série de règles. (Il peut aussi contenir des définitions de fonctions, de boucles, des conditions et autres possibilités que nous ignorerons pour l'instant.) Chaque règle spécifie un patron à cibler et une action à effectuer sur les cibles trouvées.

Il y a plusieurs façons de lancer awk. Si le programme est court, il est plus facile de le lancer depuis la ligne de commande :

Si de multiples changements doivent être fait, peut-être régulièrement sur de multiples fichiers, il est plus facile de mémoriser les commandes awk dans un script. Ce qui se lit comme ceci :

La commande print de awk affiche les données sélectionnées depuis le fichier d'entrée.

Quand awk lit une ligne d'un fichier, il divise la ligne en champs basé sur le séparateur de champs en entrée, FS, qui est une variable awk (voir Section 3.2, « Les séparateurs de résultat »). Cette variable est prédéfinie avec un ou plusieurs espaces et tabulations.

Les variables $1, $2, $3, ..., $N stockent les valeurs du premier, second, troisième jusqu'au dernier champ de la ligne traitée. La variable $0 (zéro) stocke la valeur de la ligne entière. Ceci est illustré dans l'image ci-dessous, où nous voyons 6 colonnes dans l'affichage de la commande df  :

Figure 6.1. Les champs dans awk

Dans le résultat de ls -l, il y a 9 colonnes. L'instruction print utilise ces champs comme ceci :

kelly@octarine ~/test> ls -l | awk '{ print $5 $9 }'
160orig
121script.sed
120temp_file
126test
120twolines
441txt2html.sh

kelly@octarine ~/test>

Cette commande a affiché la 5ème colonne d'une longue liste de fichiers, contenant la taille du fichier, et la dernière colonne, contenant le nom du fichier. Ce résultat est peu lisible à moins d'utiliser le moyen ad hoc qui est de séparer les colonnes que vous voulez voir afficher par une virgule. Dans ce cas, le caractère séparateur d'affichage par défaut, souvent un espace, sera inséré entre chaque champs de résultat.

Sans formater, avec seulement le séparateur de résultat, l'affichage est peu lisible. En insérant quelques tabulations et une chaîne pour indiquer la nature du champs ce sera bien mieux :

kelly@octarine ~/test> ls -ldh * | grep -v total | \ 
awk '{ print "Size is " $5 " bytes for " $9 }'
Size is 160 bytes for orig
Size is 121 bytes for script.sed
Size is 120 bytes for temp_file
Size is 126 bytes for test
Size is 120 bytes for twolines
Size is 441 bytes for txt2html.sh

kelly@octarine ~/test>

Notez l'effet du slash inversé, qui permet de continuer une entrée trop longue sur la ligne suivante sans que le Shell interprète cela comme des commandes distinctes. Alors qu'une ligne de commande peut être en théorie de taille illimitée, celle du moniteur ne l'est pas, et encore moins celle du papier. L'usage du slash inversé permet aussi le copier/coller de la ligne dans une fenêtre de terminal.

L'option -h de ls permet d'obtenir un format lisible de la taille des gros fichiers. L'affichage d'une longue liste avec la somme des blocs du répertoire indiquée est produite quand un répertoire est le paramètre. Cette ligne est inutile pour nous, donc nous avons mis un astérisque. Nous avons aussi ajouté l'option -d pour la même raison, dans le cas où l'expansion de l'astérisque donne un répertoire.

Le slash inversé dans cet exemple marque la continuation de la ligne. Voir Section 3.2, « Le caractère Echap (escape) ».

On peut prendre en compte autant de colonnes que l'on veut et même bouleverser l'ordre. Dans l'exemple ci-dessous on en trouve la démonstration qui affiche les partitions les plus critiques :

kelly@octarine ~> df -h | sort -rnk 5 | head -3 | \ 
awk '{ print "Partition " $6 "\t: " $5 " full!" }'
Partition /var  : 86% full!
Partition /usr  : 85% full!
Partition /home : 70% full!

kelly@octarine ~>

Le tableau ci-dessous donne un aperçu des caractères spéciaux de formatage :

L'apostrophe, le signe Dollar et autres métacaractères devraient être protégés avec un slash inversé .

Une expression régulière peut être utilisée comme patron en l'enfermant entre slashs. L'expression régulière est alors comparée à chaque enregistrement de texte. La syntaxe est celle-ci :

L'exemple suivant affiche seulement les informations des disques locaux, les systèmes de fichiers réseaux n'y sont pas :

kelly is in ~> df -h | awk '/dev\/hd/ { print $6 "\t: " $5 }'
/       : 46%
/boot   : 10%
/opt    : 84%
/usr    : 97%
/var    : 73%
/.vol1  : 8%

kelly is in ~>

Le Slash doit être protégé, parce qu'il a un sens spécial pour le programme awk.

Ci-dessous un autre exemple où nous cherchons dans le répertoire /etc les fichiers qui se terminent par « .conf » et qui commencent par « a » ou « x », en employant des expressions régulières étendues :

kelly is in /etc> ls -l | awk '/\<(a|x).*\.conf$/ { print $9 }'
amd.conf
antivir.conf
xcdroast.conf
xinetd.conf

kelly is in /etc>

Cet exemple illustre le sens spécial du point dans les expressions régulières : le premier indique que nous voulons cibler tout caractère après la première chaîne ciblée, le second est protégé parce que il fait partie d'une chaîne à cibler (la fin du nom de fichier).

Afin de faire précéder le résultat par un commentaire, employer l'instruction BEGIN :

kelly is in /etc> ls -l | \
awk 'BEGIN { print "Files found:\n" } /\<[a|x].*\.conf$/ { print $9 }'
Files found:
amd.conf
antivir.conf
xcdroast.conf
xinetd.conf

kelly is in /etc>

L'instruction END peut être ajoutée pour insérer du texte après que le flot en entrée ait été entièrement traité :

kelly is in /etc> ls -l | \
awk '/\<[a|x].*\.conf$/ { print $9 } END { print \
"Can I do anything else for you, mistress?" }'
amd.conf
antivir.conf
xcdroast.conf
xinetd.conf
Can I do anything else for you, mistress?

kelly is in /etc>

Au fur et à mesure que les commandes deviennent complexes, vous voudrez les mémoriser dans un script, pour être réemployées. Un script awk contient des instructions awk définissant des patrons et des actions.

Pour illustrer nous allons produire un rapport qui affiche nos partitions les plus pleines. Voir Section 2.2, « Formater les champs ».

kelly is in ~> cat diskrep.awk
BEGIN { print "*** WARNING WARNING WARNING ***" }
/\<[8|9][0-9]%/ { print "Partition " $6 "\t: " $5 " full!" }
END { print "*** Donnez de l'argent pour un nouveau disque VITE ! ***" }

kelly is in ~> df -h | awk -f diskrep.awk
*** WARNING WARNING WARNING ***
Partition /usr  : 97% full!
*** Donnez de l'argent pour un nouveau disque VITE ! ***

kelly is in ~>

awk d'abord affiche le message de début, puis formate toutes les lignes qui contiennent un 8 ou un 9 au début de chaque mot, suivi par un autre chiffre et le signe de pourcentage. Un message final est ajouté.

	Mise en relief de la syntaxe
	Awk est un langage de programmation . Sa syntaxe est reconnue par la plupart des éditeurs qui font la mise en relief de la syntaxe comme pour d'autres langages tel que C, Bash, HTML, etc.

Le séparateur de champs, qui est soit un simple caractère, soit une expression régulière, contrôle la façon dont awk découpe l'enregistrement entré en champs. L'enregistrement en entrée est examiné à la recherche de séquences de caractères qui correspondent au séparateur défini ; les champs eux-mêmes sont les textes entre chaque séparateur.

Le séparateur de champs est défini par la variable intégrée FS. Notez que cette variable et IFS utilisée par les Shell compatible POSIX sont distinctes.

La valeur de la variable de séparateur de champs peut être changée dans le programme awk avec l'opérateur d'assignement =. Souvent le bon moment pour faire ce changement c'est au début de l'exécution avant qu'aucune entrée n'ait été traitée, de sorte que le tout premier enregistrement est lu avec le séparateur idoine. Pour ce faire employer le patron spécial BEGIN.

Dans l'exemple ci-dessous, nous écrivons une commande qui affiche tous les utilisateurs de votre système avec une description :

kelly is in ~> awk 'BEGIN { FS=":" } { print $1 "\t" $5 }' /etc/passwd
--output omitted--
kelly	Kelly Smith
franky	Franky B.
eddy	Eddy White
willy	William Black
cathy	Catherine the Great
sandy	Sandy Li Wong

kelly is in ~>

Dans un script awk, cela ressemblerait à ça :

kelly is in ~> cat printnames.awk
BEGIN { FS=":" }
{ print $1 "\t" $5 }

kelly is in ~> awk -f printnames.awk /etc/passwd
--output omitted--

Choisir un séparateur de champs d'entrée soigneusement pour éviter des soucis. Un exemple pour illustrer ceci : disons que vous obtenez l'entrée sous la forme de lignes qui ressemble à ça :

« Sandy L. Wong, 64 Zoo St., Antwerp, 2000X »

Vous écrivez une commande ou un script, qui affiche le nom de la personne dans cet enregistrement :

Mais une personne pourrait avoir un doctorat, et ça pourrait s'écrire comme ça :

« Sandy L. Wong, Doctorat, 64 Zoo St., Antwerp, 2000X »

Votre awk donnera un mauvais résultat sur cette ligne. Au besoin faire un awk supplémentaire ou un sed pour uniformiser le format des données en entrée.

Le séparateur de champs en entrée est par défaut un ou des espaces ou des tabulations.

L'intégré NR stocke le nombre d'enregistrements qui sont traités. Il est incrémenté après la lecture d'une nouvelle ligne d'entrée. Vous pouvez l'utiliser à la fin pour compter le nombre total d'enregistrements, ou à chaque enregistrement de résultat :

kelly@octarine ~/test> cat processed.awk
BEGIN { OFS="-" ; ORS="\n--> done\n" }
{ print "Record number " NR ":\t" $1,$2 }
END { print "Number of records processed: " NR }

kelly@octarine ~/test> awk -f processed.awk test
Record number 1:        record1-data1
--> done
Record number 2:        record2-data2
--> done
Number of records processed: 2
--> done

kelly@octarine ~/test>

En plus des variables intégrées, vous pouvez définir les vôtres. Quand awk rencontre une référence à une variable qui n'existe pas (qui n'est pas prédéfinie), la variable est créée et initialisée à une chaîne nulle. Pour toutes les références suivantes, la valeur de la variable est la dernière valeur affectée. Une variable peut être une chaîne ou une valeur numérique. Le contenu des champs en entrée peut aussi être affecté à une variable.

Une valeur peut être assignée directement par l'opérateur =, ou vous pouvez utiliser la valeur courante de la variable combinée avec d'autres opérateurs :

kelly@octarine ~> cat revenues
20021009        20021013        consultancy     BigComp         2500
20021015        20021020        training        EduComp         2000
20021112        20021123        appdev          SmartComp       10000
20021204        20021215        training        EduComp         5000

kelly@octarine ~> cat total.awk
{ total=total + $5 }
{ print "Send bill for " $5 " dollar to " $4 }
END { print "---------------------------------\nTotal revenue: " total }

kelly@octarine ~> awk -f total.awk test
Send bill for 2500 dollar to BigComp
Send bill for 2000 dollar to EduComp
Send bill for 10000 dollar to SmartComp
Send bill for 5000 dollar to EduComp
---------------------------------
Total revenue: 19500

kelly@octarine ~>

Les raccourcis de type C comme VAR+= value sont aussi acceptés.

L'exemple de la Section 3.2, « Ecrire des fichiers de résultat » devient bien plus facile quand on utilise un script awk :

kelly@octarine ~/html> cat make-html-from-text.awk
BEGIN { print "<html>\n<head><title>Awk-generated HTML</title></head>\n<body bgcolor=\"#ffffff\">\n<pre>" }
{ print $0 }
END { print "</pre>\n</body>\n</html>" }

Et les commandes à exécuter sont aussi bien plus directe quand on utilise awk plutôt que sed :

kelly@octarine ~/html> awk -f make-html-from-text.awk testfile > file.html

	Exemples d'Awk sur votre système
	Nous nous référons encore au répertoire qui contient les scripts d'initialisation de votre système. Entrez une commande similaire à la suivante pour voir d'autres exemples pratiques de l'usage très répandu de la commande awk : grep awk /etc/init.d/*

Pour un contrôle du format du résultat plus précis que celui fournit par print, employez printf. La commande printf peut spécifier une largeur de champs pour chaque élément, de même que divers choix de formatage des nombres (tel que la base de calcul à considérer, si il faut afficher un exposant, si le signe est à afficher, et combien de chiffres à afficher après la virgule). Ceci est fait en ajoutant une chaîne appelée chaîne de formatage, qui contrôle comment et où afficher les autres arguments.

La syntaxe est la même que celle de l'instruction du langage C printf ; voir votre guide d'instruction C. Les pages info de gawk contiennent plein d'explications.

A certains moments vous pouvez vouloir donner une alternative au traitement effectué par le script, en fonction de l'échec ou la réussite d'une commande. Le bloc if permet de spécifier de telles conditions.

La syntaxe la plus compacte de la commande if est :

La liste TEST-COMMAND est exécutée, et si elle retourne le statut zéro, la liste CONSEQUENT-COMMANDS est exécutée. Le statut retourné est le statut d'exécution de la dernière commande exécutée, ou zéro si aucune condition n'est vraie.

Le TEST-COMMAND souvent comprend des comparaisons de numériques ou de chaînes, mais cela peut être aussi toute commande qui retourne un statut à zéro quand elle s'est bien exécutée et d'autres valeurs en cas d'échec. Une expression unaire est souvent utilisée pour examiner le statut d'un fichier. Si l'argument FILE d'une de ces primitives est de la forme /dev/fd/N, alors le descripteur de fichier « N » est contrôlé. stdin, stdout et stderr et leur descripteur de fichier respectif peuvent aussi être employés dans les tests.

anny ~> cat msgcheck.sh
#!/bin/bash

echo "Ce script vérifie si le fichier des messages existe."
echo "Vérification..."
if [ -f /var/log/messages ]
  then
    echo "/var/log/messages existe."
fi
echo
echo "...fait."

anny ~> ./msgcheck.sh
Ce script vérifie si le fichier des messages existe.
Vérification...
/var/log/messages existe.

...fait.

1.1.4. Vérifier des options Shell

A ajouter dans vos fichier de configuration Bash :

# Ces lignes affichent un message si l'option noclobber option est positionnée :

if [ -o noclobber ]
  then
	echo "Vos fichiers sont protégés contre une réécriture accidentelle du fait d'une redirection."
fi

L'environnement

L'exemple ci-dessus fonctionnera si il est soumis à la ligne de commande : anny ~> if [ -o noclobber ] ; then echo ; echo "Vos fichiers sont protégés contre une réécriture." ; echo ; fi Vos fichiers sont protégés contre une réécriture. anny ~> Cependant, si vous employez les tests de conditions qui dépendent de l'environnement, vous pourriez obtenir des résultats variables alors que vous exécutez la même commande dans un script, parce que le script ouvrira un nouveau Shell, dans lequel les variables et options attendues pourraient ne pas être définies automatiquement.