programation Bash

8/14/2019 programation Bash

1/107

Introduction

la programmation en Bash

Version 0.1

Eric Sanchis

IUT de Rodez, 33 avenue du 8 mai 1945, 12000 Rodez

Tl : 05.65.77.10.80 Fax : 05.65.77.10.81 Internet : www.iut-rodez.fr
http://www.iut-rodez.fr/http://www.iut-rodez.fr/


2/107

Prface

Interprteur de commandes par dfaut des systmes GNU/Linux, bash est devenu pour les

administrateurs systme, un outil incontournable. Ce document prsente les principalesconstructions syntaxiques de bash utilises dans lcriture des programmes shell (scripts shell).Lobjectif premier a t de laisser de ct les redondances syntaxiques de ce langage de

programmation, la subtilit des mcanismes de linterprteur, afin dinsister sur quelques conceptssynthtiques tels que la substitution, la redirection ou lefiltrage.

Cet crit tant destin principalement aux tudiants de premier et deuxime cycle en informatique,jai choisi de le rdiger en adoptant un style 2Ex (1 Explication, 1 Exemple) qui devrait permettreau lecteur de mieux sapproprier chaque notion prsente. Ce dernier pourra ensuite aborder des

publications plus extensives ou plus spcialises.

Cette publication tant loin dtre parfaite1

, jencourage le lecteur me faire parvenir sesremarques ou suggestions, ainsi qu me signaler toute inexactitude ([email protected]).

Pour en savoir plus :

[1] Mendel Cooper, Advanced Bash Scripting Guide (http://tldp.org/LDP/abs/html).Une traduction en franais est disponible (http://abs.traduc.org).

[2] Arnold Robbins, Nelson H. F. Beebe, Introduction aux scripts shell,Ed. OReilly, Paris,2005.

[3] Cameron Newham, Bill Rosenblatt, Le shell bash, 3me dition, Ed. OReilly, Paris, 2006.

Plate-forme logicielle utilise :

Interprteurbash 3.1, systme PC/Debian

Licence :

GNU Free Documentation License

1 Les exemples figurant dans ce document ont pour but dillustrer les notions traites. Il nest donn aucune garantiequant leur fonctionnement ou leurs effets.
mailto:[email protected]://tldp.org/LDP/abs/htmlhttp://abs.traduc.org/http://abs.traduc.org/http://tldp.org/LDP/abs/htmlmailto:[email protected]


3/107

Table des matires

1. Introduction bash ---------------------------------------------------------------------------------------------------------- 5

1.1.

Les shells --------------------------------------------------------------------------------------------------------------- 5

1.2. Syntaxe dune commande -------------------------------------------------------------------------------------------- 8

1.3. Commandes internes et externes ------------------------------------------------------------------------------------ 9

1.4. Modes dexcution dune commande------------------------------------------------------------------------------ 11

1.5. Commentaires --------------------------------------------------------------------------------------------------------12

1.6. Fichiers shell ---------------------------------------------------------------------------------------------------------13

2. Substitution de paramtres ------------------------------------------------------------------------------------------------15

2.1. Variables --------------------------------------------------------------------------------------------------------------15

2.2. Paramtres de position et paramtres spciaux------------------------------------------------------------------18

2.3. Suppression des ambiguts-----------------------------------------------------------------------------------------24

2.4. Paramtres non dfinis ---------------------------------------------------------------------------------------------- 24

2.5. Suppression de variables--------------------------------------------------------------------------------------------26

3. Substitution de commandes------------------------------------------------------------------------------------------------27

3.1. Prsentation ----------------------------------------------------------------------------------------------------------27

3.2. Substitutions de commandes et paramtres rgionaux ----------------------------------------------------------29

4. Caractres et expressions gnriques------------------------------------------------------------------------------------31

4.1. Caractres gnriques-----------------------------------------------------------------------------------------------324.2. Expressions gnriques----------------------------------------------------------------------------------------------35

5. Redirections lmentaires--------------------------------------------------------------------------------------------------37

5.1. Descripteurs de fichiers --------------------------------------------------------------------------------------------- 37

5.2. Redirections lmentaires------------------------------------------------------------------------------------------- 37

5.3. Tubes-------------------------------------------------------------------------------------------------------------------42

6. Groupement de commandes-----------------------------------------------------------------------------------------------44

7. Code de retour ---------------------------------------------------------------------------------------------------------------47

7.1. Paramtre spcial ?-------------------------------------------------------------------------------------------------47

7.2. Code de retour d'un programme shell-----------------------------------------------------------------------------50

7.3. Commande interne exit----------------------------------------------------------------------------------------------50

7.4. Code de retour d'une suite de commandes------------------------------------------------------------------------51

7.5. Rsultats et code de retour------------------------------------------------------------------------------------------52

7.6. Oprateurs && et || sur les codes de retour-------------------------------------------------------------------52

8. Structures de contrle case et while--------------------------------------------------------------------------------------55

8.1. Choix multiple case --------------------------------------------------------------------------------------------------55

8.2. Itration while -------------------------------------------------------------------------------------------------------- 56

9. Chanes de caractres-------------------------------------------------------------------------------------------------------61

3


4/107

9.1. Protection de caractres --------------------------------------------------------------------------------------------61

9.2. Longueur d'une chane de caractres ----------------------------------------------------------------------------- 62

9.3. Modificateurs de chanes-------------------------------------------------------------------------------------------- 62

9.4. Extraction de sous-chanes ----------------------------------------------------------------------------------------- 64

9.5. Remplacement de sous-chanes------------------------------------------------------------------------------------- 65

10. Structures de contrle for et if-----------------------------------------------------------------------------------------67

10.1. Itration for ----------------------------------------------------------------------------------------------------------67

10.2. Choix if ---------------------------------------------------------------------------------------------------------------69

11. Entiers et expressions arithmtiques ---------------------------------------------------------------------------------75

11.1. Variables de type entier ---------------------------------------------------------------------------------------------75

11.2. Commande interne ((------------------------------------------------------------------------------------------------75

11.3. Valeur d'une expression arithmtique ----------------------------------------------------------------------------- 77

11.4. Oprateurs ------------------------------------------------------------------------------------------------------------78

11.5. Structure for pour les expressions arithmtiques ---------------------------------------------------------------- 83

11.6. Exemple : les tours de Hanoi --------------------------------------------------------------------------------------- 84

12. Tableaux -------------------------------------------------------------------------------------------------------------------86

12.1. Dfinition et initialisation dun tableau--------------------------------------------------------------------------- 86

12.2. Valeur d'un lment d'un tableau ----------------------------------------------------------------------------------87

12.3. Caractristiques d'un tableau --------------------------------------------------------------------------------------88

12.4. Suppression d'un tableau--------------------------------------------------------------------------------------------89

13. Alias-------------------------------------------------------------------------------------------------------------------------90

13.1. Cration dun alias --------------------------------------------------------------------------------------------------90

13.2. Suppression dun alias ----------------------------------------------------------------------------------------------92

14. Fonctions shell ------------------------------------------------------------------------------------------------------------93

14.1. Dfinition dune fonction--------------------------------------------------------------------------------------------93

14.2. Suppression dune fonction -----------------------------------------------------------------------------------------96

14.3. Trace des appels aux fonctions-------------------------------------------------------------------------------------96

14.4. Arguments dune fonction------------------------------------------------------------------------------------------- 97

14.5. Variables locales une fonction -----------------------------------------------------------------------------------99

14.6. Exporter une fonction---------------------------------------------------------------------------------------------- 101

14.7. Commande interne return----------------------------------------------------------------------------------------- 103

14.8. Substitution de fonction ------------------------------------------------------------------------------------------- 104

14.9. Fonctions rcursives----------------------------------------------------------------------------------------------- 104

14.10. Appels de fonctions disperses dans plusieurs fichiers-------------------------------------------------------- 105

4


5/107

1. Introduction bash

1.1.

Les shellsSous Unix, on appelle shell linterprteur de commandes qui fait office d'interface entrel'utilisateur et le systme dexploitation. Les shells sont des interprteurs : cela signifie que chaquecommande saisie par lutilisateur (ou lue partir dun fichier) est syntaxiquement vrifie puisexcute.

Il existe de nombreux shells qui se classent en deux grandes familles :- la famille C shell (ex : csh, tcsh)- la familleBourne shell (ex : sh, bash, ksh).

zsh est un shell qui contient les caractristiques des deux familles prcdentes. Nanmoins, le

choix dutiliser un shell plutt quun autre est essentiellement une affaire de prfrencepersonnelle ou de circonstance. En connatre un, permet daccder aisment aux autres. Lorsquelon utilise le systme GNU/Linux (un des nombreux systmes de la galaxie Unix), le shell pardfaut est bash(Bourne Again SHell). Ce dernier a t conu en 1988 par Brian Fox dans le cadredu projet GNU2. Aujourdhui, les dveloppements de bash sont mens par Chet Ramey.

Un shell possde un double aspect :- un aspect environnement de travail- un aspect langage de programmation.

1.1.1.

Un environnement de travail

En premier lieu, un shell doit fournir un environnement de travail agrable et puissant. Parexemple, bashpermet (entre autres) :

- le rappel des commandes prcdentes (gestion de lhistorique) ; cela vite de taperplusieurs fois la mme commande

- la modification en ligne du texte de la commande courante (ajout, retrait, remplacementde caractres) en utilisant les commandes ddition de lditeur de texte vi ou emacs

- la gestion des travaux lancs en arrire-plan (appels jobs) ; ceux-ci peuvent tredmarrs, stopps ou repris suivant les besoins

- linitialisation adquate de variables de configuration (chane dappel de linterprteur,

chemins de recherche par dfaut) ou la cration de raccourcis de commandes (commande alias).

Illustrons cet ajustement de configuration par un exemple. Le shell permet dexcuter unecommande en mode interactif ou bien par l'intermdiaire de fichiers de commandes (scripts). Enmode interactif, bash affiche lcran une chane dappel (appele galementpromptou invite),qui se termine par dfaut par le caractre # suivi dun caractre espace pour ladministrateursystme (utilisateur root) et par le caractre $ suivi dun caractre espace pour les autresutilisateurs. Cette chane dappel peut tre relativement longue.

Ex : sanchis@jade:/bin$

2 http://www.gnu.org

5


6/107

Celle-ci est constitue du nom de connexion de lutilisateur (sanchis), du nom de la machine surlaquelle lutilisateur travaille (jade) et du chemin absolu du rpertoire courant de lutilisateur(/bin). Elle indique que le shell attend que lutilisateur saisisse une commande et la valide enappuyant sur la touche entre. Bash excute alors la commande puis raffiche la chane dappel.Si lon souhaite raccourcir cette chane dappel, il suffit de modifier la valeur de la variable

prdfinie du shell PS1 (Prompt Shell 1).

Ex : sanchis@jade:/bin$ PS1='$ '$pwd

/home/sanchis =>pwdaffiche le chemin absolu du rpertoire courant$

La nouvelle chane dappel est constitue par le caractre $ suivi dun caractre espace.

1.1.2. Un langage de programmation

Les shells ne sont pas seulement des interprteurs de commandes mais galement de vritableslangages de programmation. Un shell comme bash intgre :- les notions de variable, doprateur arithmtique, de structure de contrle, defonction,

prsentes dans tout langage de programmation classique, mais aussi- des oprateurs spcifiques (ex : |, ;)

Ex : $ a=5 => affectation de la valeur5 la variable a$

$ echo $((a +3 )) => affiche la valeur de lexpression a+38$

Loprateur |, appel tube, est un oprateur caractristique des shells et connecte la sortie dunecommande lentre de la commande suivante.

Ex : $ ruptimeiutbis up 56+22:50, 0 users, load 0.47, 0.48, 0.34jade up 39+16:17, 2 users, load 0.00, 0.00, 0.00mobile1 up 3+02:19, 0 users, load 0.00, 0.00, 0.00mobile2 up 2+18:43, 0 users, load 0.00, 0.00, 0.00quartz up 40+15:35, 2 users, load 0.00, 0.00, 0.00sigma up 56+23:46, 1 user, load 0.00, 0.00, 0.00$$ ruptime | wc -l6$

La commande unix ruptime3 affiche les noms et autres informations relatives aux machinesvisibles sur le rseau. La commande unix wc munie de loption l affiche le nombre de lignesquelle a t en mesure de lire.En connectant avec un tube la sortie de ruptime lentre de la commande wc l, on obtient lenombre de machines visibles du rseau.

Mme si au fil du temps de nouveaux types de donnes comme les entiers ou les tableaux ont tintroduits dans certains shells, ces derniers manipulent essentiellement des chanes de caractres :

3 La commande ruptime est contenue dans le paquetage rwho. Ce paquetage nest pas systmatiquement install parles distributions Linux.

6


7/107

ce sont des langages de programmation orients chanes de caractres. Cest ce qui rend les shells la fois si puissants et si dlicats utiliser.

Lobjet de ce document est de prsenter de manire progressive les caractristiques de bashcomme langage de programmation.

1.1.3. Atouts et inconvnients des shells

Ltude dun shell tel que bash en tant que langage de programmation possde plusieursavantages :

- cest un langage interprt : les erreurs peuvent tre facilement localises et traites ;dautre part, des modifications de fonctionnalits sont facilement apportes lapplication sansquil soit ncessaire de recompiler et faire ldition de liens de lensemble

- le shell manipule essentiellement des chanes de caractres: on ne peut donc construiredes structures de donnes complexes laide de pointeurs, ces derniers nexistant pas en shell.Ceci a pour avantage dviter des erreurs de typage et de pointeurs mal grs. Le dveloppeur

raisonne de manire uniforme en termes de chanes de caractres- le langage est adapt au prototypage rapide dapplications : les tubes, les substitutions

de commandes et de variables favorisent la construction dune application par assemblage decommandes prexistantes dans lenvironnement Unix

- cest un langage glu : il permet de connecter des composants crits dans deslangages diffrents. Ces derniers doivent uniquement respecter quelques rgles particulirementsimples. Le composant doit tre capable :

de lire sur lentre standard,

daccepter des arguments et options ventuels,

dcrire ses rsultats sur la sortie standard,

dcrire les messages derreur sur la sortie standard ddie aux messagesderreur.

Cependant, bash et les autres shells en gnral ne possdent pas que des avantages :- issus dUnix, systme dexploitation crit lorigine par des dveloppeurs pour des

dveloppeurs, les shells utilisent une syntaxe sotrique daccs difficile pour le dbutant- loubli ou lajout dun caractre espace provoque facilement une erreur de syntaxe- bash possde plusieurs syntaxes pour implanter la mme fonctionnalit, comme la

substitution de commande ou lcriture dune chane lcran. Cela est principalement d lavolont de fournir une compatibilit ascendante avec leBourne shell, shell historique des systmesUnix

-

certains caractres spciaux, comme les parenthses, ont des significations diffrentessuivant le contexte ; en effet, les parenthses peuvent introduire une liste de commandes, unedfinition de fonction ou bien imposer un ordre dvaluation dune expression arithmtique.Toutefois, afin de rendre ltude de bash plus aise, nous naborderons pas sa syntaxe de manireexhaustive ; en particulier, lorsquil existera plusieurs syntaxes pour mettre en oeuvre la mmefonctionnalit, une seule dentre elles sera prsente.

1.1.4. Shell utilis

La manire la plus simple de connatre le shell que lon utilise est dexcuter la commande unix ps

qui liste les processus de lutilisateur :

Ex : $ps

7


8/107

PID TTY TIME CMD

6908 pts/4 00:00:00 bash => linterprteur utilis est bash6918 pts/4 00:00:00 ps

$

Comme il existe plusieurs versions de bash prsentant des caractristiques diffrentes, il est

important de connatre la version utilise. Pour cela, on utilise l'option-version de bash.

Ex : $bash --versionGNU bash, version 3.1.14(1)-release (i486-pc-linux-gnu)Copyright (C) 2005 Free Software Foundation, Inc.$

La dernire version majeure de bash est la version 3. Cest celle qui sera tudie.

1.2. Syntaxe dune commande

La syntaxe gnrale d'une commande (unix ou de bash) est la suivante :

[ chemin/]nom_cmd [ option ... ] [ argument... ]

C'est une suite de mots spars par un ou plusieurs blancs. On appelle blanc un caractre tab(tabulation horizontale) ou un caractre espace.Un mot est une suite de caractres non blancs. Cependant, plusieurs caractres ont unesignification spciale pour le shell et provoquent la fin d'un mot : ils sont appels mta-caractres(ex : |,


9/107

1.3. Commandes internes et externes

Le shell distingue deux sortes de commandes :- les commandes internes

- les commandes externes.

1.3.1. Commandes internes

Une commande interne est une commande dont le code est implant au sein de linterprteur decommande. Cela signifie que, lorsquon change de shell courant ou de connexion, par exemple en

passant de bash au C-shell, on ne dispose plus des mmes commandes internes.

Exemples de commandes internes : cd , echo , for , pwd

Sauf dans quelques cas particuliers, linterprteur ne cre pas de processus pour excuter unecommande interne.

Les commandes internes de bash peuvent se dcomposer en deux groupes :- les commandes simples (ex : cd, echo)- les commandes composes (ex : for, ((, {).

Commandes simples

Parmi lensemble des commandes internes, echo est lune des plus utilise :

echo :

Cette commande interne affiche ses arguments sur la sortie standard en les sparant par un espaceet va la ligne.

Ex : $ echo bonjour tout le mondebonjour tout le monde$

Dans cet exemple, echo est invoque avec quatre arguments : bonjour, tout, le et monde.On remarquera que les espacements entre les arguments ne sont pas conservs lors de laffichage :

un seul caractre espace spare les mots affichs. En effet, le shell prtraite la commande,liminant les blancs superflus.

Pour conserver les espacements, il suffit dentourer la chane de caractres par une paire deguillemets :

Ex : $ echo bonjour tout le mondebonjour tout le monde$

On dit que les blancs ont t protgs de l'interprtation du shell.

9


10/107

Pour afficher les arguments sans retour la ligne, on utilise loption -nde echo.

Ex : $echo -n bonjourbonjour$

La chane dappel $est crite sur la mme ligne que largument bonjour.

Commandes composes

Les commandes composes de bash sont :

case ... esac if ... fi for ... done select ... doneuntil ... done while... done [[ ... ]] ( ... ){ ... } (( ))

Seuls le premier et le dernier mot de la commande compose sont indiqus. Les commandescomposes sont principalement des structures de contrle.

1.3.2. Commandes externes

Une commande externe est une commande dont le code se trouve dans un fichier ordinaire. Leshell cre un processus pour excuter une commande externe. Parmi lensemble des commandesexternes que lon peut trouver dans un systme, nous utiliserons principalement les commandesunix (ex : ls, mkdir, vi, sleep) et lesfichiers shell.

La localisation du code d'une commande externe doit tre connue du shell pour qu'il puisseexcuter cette commande. A cette fin, bash utilise la valeur de sa variable prdfinie PATH.Celle-ci contient une liste de chemins spars par le caractre :(ex :/bin:/usr/bin).Par exemple, lorsque lutilisateur lance la commande unix cal, le shell est en mesure de lexcuteret dafficher le calendrier du mois courant car le code de cal est situ dans le rpertoire /usr/bin

prsent dans PATH.

Ex : $ calseptembre 2006

di lu ma me je ve sa1 2

3 4 5 6 7 8 910 11 12 13 14 15 1617 18 19 20 21 22 2324 25 26 27 28 29 30

$

Remarque : pour connatre le statut dune commande, on utilise la commande interne type.

Ex : $ type sleep

sleep is /bin/sleep => sleep est une commande externe$ type echo

echo is a shell builtin$

10


11/107

1.4. Modes dexcution dune commande

Deux modes dexcution peuvent tre distingus :- lexcution squentielle- lexcution en arrire-plan.

1.4.1. Excution squentielle

Le mode dexcution par dfaut dune commande est lexcution squentielle : le shell lit lacommande entre par lutilisateur, lanalyse, la prtraite et si elle est syntaxiquement correcte,lexcute.Une fois lexcution termine, le shell effectue le mme travail avec la commande suivante.Lutilisateur doit donc attendre la fin de lexcution de la commande prcdente pour que lacommande suivante puisse tre excute : on dit que lexcution est synchrone.

Si on tape la suite de commandes :

sleep 3 entre dateentreo entre dsigne la touche entre, lexcution de date dbute aprs que le dlai de 3 secondes sesoit coul.

Pour lancer lexcution squentielle de plusieurs commandes sur la mme ligne de commande, ilsuffit de les sparer par un caractre ;

Ex : $ cd /tmp ; pwd; echo bonjour; cd; pwd

/tmp => affiche par lexcution depwd

bonjour => affiche par lexcution de echo bonjour

/home/sanchis => affiche par lexcution depwd$

Pour terminer lexcution dune commande lance en mode synchrone, on appuie simultanmentsur les touches CTRL et C (notes control-C ou ^C).En fait, la combinaison de touches approprie pour arrter lexcution dune commande en modesynchrone est indique par la valeur du champ intrlorsque la commande unix stty est lance :

Ex : $ stty -aspeed 38400 baud; rows 24; columns 80; line = 0;intr = ^C; quit = ^\; erase = ^?; kill = ^U; eof = ^D; eol = ;

. . .

$

Supposons que la commande cat soit lance sans argument, son excution semblera fige unutilisateur qui dbute dans lapprentissage dun systme Unix. Il pourra utiliser la combinaison detouches mentionne prcdemment pour terminer lexcution de cette commande.

Ex : $ cat^C$

11


12/107

1.4.2. Excution en arrire-plan

Lexcution en arrire-plan permet un utilisateur de lancer une commande et de rcuprerimmdiatement la main pour lancer en parallle la commande suivante (paralllisme logique).On utilise le caractre & pour lancer une commande en arrire-plan.

Dans lexemple ci-dessous, la commande sleep 5 (suspendre lexcution pendant 5 secondes) estlance en arrire-plan. Le systme a affect le numro didentification 696 au processuscorrespondant tandis que bash a affect un numro de travail (ou numro de job) gal 1 etaffich [1]. Lutilisateur peut, en parallle, excuter dautres commandes (dans cet exemple, ilsagit de la commande ps). Lorsque la commande en arrire-plan se termine, le shell le signale l'utilisateur aprs que ce dernier ait appuy sur la touche entre.

Ex : $ sleep 5 &[1 696]$psPID TTY TIME CMD683 pts/0 00:00:00 bash696 pts/0 00:00:00 sleep697 pts/0 00:00:00 ps

$ => lutilisateur a appuy sur la touche entre mais sleep ntait pas termine

$ => lutilisateur a appuy sur la touche entre et sleep tait termine[1]+ Done sleep 5$

Ainsi, outre la gestion des processus spcifique Unix, bash introduit un niveau supplmentairede contrle de processus. En effet, bash permet de stopper, reprendre, mettre en arrire-plan un

processus, ce qui ncessite une identification supplmentaire (numro de job).Lexcution en arrire-plan est souvent utilise lorsquune commande est gourmande en temps

CPU (ex : longue compilation dun programme).

1.5. Commentaires

Un commentaire dbute avec le caractre # et se termine avec la fin de la ligne. Un commentaireest ignor par le shell.

Ex : $ echo bonjour # lamibonjour$ echo coucou #l ami

coucou$ # echo coucou$

Pour que le caractre # soit reconnu en tant que dbut de commentaire, il ne doit pas tre insr lintrieur dun mot ou terminer un mot.

Ex : $ echo il est#10 heuresil est#10 heures$$ echo bon# jourbon# jour

$

12


13/107

1.6. Fichiers shell

Lorsquun traitement ncessite lexcution de plusieurs commandes, il est prfrable de lessauvegarder dans un fichier plutt que de les retaper au clavier chaque fois que le traitement doittre lanc. Ce type de fichier est appel fichier decommandes ou fichier shell ou encore scriptshell.

Exercice1 :

1.) A laide dun diteur de texte, crer un fichierpremiercontenant les lignes suivantes :

#!/bin/bash# premier

echo -n "La date du jour est: "date

La notation #! en premire ligne d'un fichier interprt prcise au shell courant quelinterprteur doit tre utilis pour excuter le script shell (dans cet exemple, il sagit de/bin/bash).La deuxime ligne est un commentaire.

2.) Vrifier le contenu de ce fichier.

Ex : $ cat premier#!/bin/bash# premier

echo -n "La date du jour est: "date$

3.) Pour lancer lexcution dun fichier shell fich, on peut utiliser la commande : bashfich

Ex : $bash premierla date du jour est : dimanche 3 septembre 2006, 15:41:26 (UTC+0200)$

4.) Il est plus simple de lancer lexcution dun programme shell en tapant directementson nom, comme on le ferait pour une commande unix ou une commande interne.Pour que cela soit ralisable, deux conditions doivent tre remplies :- lutilisateur doit possder les permissions r (lecture) et x (excution) sur le fichier shell- le rpertoire dans lequel se trouve le fichier shell doit tre prsent dans la liste des

chemins contenue dans PATH.

Ex : $ ls -l premier-rw-r--r-- 1 sanchis sanchis 63 sep 3 15:39 premier$

Seule la permission r est possde par lutilisateur.

13


14/107

Pour ajouter la permission x au propritaire du fichierfich, on utilise la commande :chmod u+xfich

Ex : $ chmod u+x premier$

$ ls -l premier-rwxr--r-- 1 sanchis sanchis 63 sep 3 15:39 premier$

Si on excutepremieren ltat, une erreur dexcution se produit.

Ex : $premier

-bash: premier: command not found => Problme !$

Cette erreur se produit carbash ne sait pas o se trouve le fichierpremier.

Ex : $ echo $PATH => affiche la valeur de la variable PATH/bin:/usr/bin:/usr/bin/X11$$pwd/home/sanchis$

Le rpertoire dans lequel se trouve le fichierpremier(rpertoire /home/sanchis) nest pasprsent dans la liste de PATH. Pour que le shell puisse trouver le fichierpremier, il suffitde mentionner le chemin permettant daccder celui-ci.

Ex : $ ./premierla date du jour est : dimanche 3 septembre 2006, 15:45:28 (UTC+0200)$

Pour viter davoir saisir systmatiquement ce chemin, il suffit de modifier la valeur dePATH en y incluant, dans notre cas, le rpertoire courant (.).

Ex : $ PATH=$PATH:. => ajout du rpertoire courant dans PATH$$ echo $PATH/bin:/usr/bin:/usr/bin/X11:.$

$premierla date du jour est : dimanche 3 septembre 2006, 15:47:38 (UTC+0200)$

Exercice2 : Ecrire un programme shell repcourqui affiche le nom de connexion de l'utilisateuret le chemin absolu de son rpertoire courant de la manire suivante :

Ex : $ repcourmon nom de connexion est : sanchismon repertoire courant est : /home/sanchis$

14


15/107

2. Substitution de paramtres

Dans la terminologie du shell, unparamtre dsigne toute entit pouvant contenir une valeur.

Le shell distingue trois classes de paramtres : les variables, identifies par un nom

Ex : a , PATH lesparamtres de position, identifis par un numro

Ex : 0 , 1 , 12 lesparamtres spciaux, identifis par un caractre spcial

Ex : # , ? , $

Le mode daffectation d'une valeur est spcifique chaque classe de paramtres. Suivant celle-ci,laffectation sera effectue par lutilisateur, par bash ou bien par le systme. Par contre, pour

obtenir la valeur d'un paramtre, on placera toujours le caractre $ devant sa rfrence, et celaquelle que soit sa classe.

Ex : $ echo $PATH => affiche la valeur de la variable PATH/usr/local/bin:/usr/bin:/bin:/usr/bin/X11:/usr/games:.:/home/sanchis/bin

$ echo $$ => affiche la valeur du paramtre spcial $17286$

2.1. Variables

Une variable est identifie par un nom, c'est--dire une suite de lettres, de chiffres ou de caractresespace soulign ne commenant pas par un chiffre. Les lettres majuscules et minuscules sontdiffrencies.

Les variables peuvent tre classes en trois groupes :- les variables utilisateur (ex : a, valeur)- les variables prdfinies du shell (ex : PS1, PATH, REPLY, IFS)- les variables prdfinies de commandes unix (ex : TERM).

En gnral, les noms des variables utilisateur sont en lettres minuscules tandis que les noms desvariables prdfinies (du shell ou de commandes unix) sont en majuscules.

Lutilisateur peut affecter une valeur une variable en utilisant- loprateur daffectation =- la commande interne read.

Affectation directe

Syntaxe : nom=[valeur] [nom=[valeur] ... ]

Il est impratif que le nom de la variable, le symbole = et la valeur affecter ne forment quune

seule chane de caractres.

15


16/107

Plusieurs affectations peuvent tre prsentes dans la mme ligne de commande.

Ex : $ x=coucou y=bonjour => la variablex contient la chane de caractres coucou

$ => la variabley contient la chane bonjour

ATTENTION : les syntaxes daffectation errones les plus frquentes contiennent

- un ou plusieurs caractres espace entre le nom de la variable et le symbole =.

Ex : $b =coucou-bash: b: command not found$

Le shell interprte b comme une commande excuter ; ne la trouvant pas, il signale une erreur.

- un ou plusieurs caractres espace entre le symbole = et la valeur de la variable.

Ex : $ y= coucou-bash: coucou: command not found$

La chane coucou est interprte comme la commande excuter.

Lorsque le shell rencontre la chane $x, il la remplace textuellement par la valeur de la variablex,c.--d. coucou ; la commande excute parbash est : echo x est coucou

Ex : $ echo x est $xx est coucou$

Il est important de remarquer que le nom dun paramtre et la valeur de ce paramtre ne sedsignent pas de la mme manire.

Ex : $ x=$x$y => x : contenant, $x : contenu$ echo $xcoucoubonjour$

Affectation par lecture

Elle seffectue l'aide de la commande interne read. Celle-ci lit une ligne entire sur lentre

standard.

Syntaxe : read [ var1 ... ]

Ex : $ reada b

bonjour Monsieur => chanes saisies par lutilisateur et enregistres

$ => respectivement dans les variables a et b$ echo $bMonsieur$

16


17/107

Lorsque la commande interne read est utilise sans argument, la ligne lue est enregistre dans lavariable prdfinie du shell REPLY.

Ex : $ readbonjour tout le monde$

$ echo $REPLYbonjour tout le monde$

Loption p de read affiche une chane dappel avant deffectuer la lecture ; la syntaxe utiliserest : read pchane_d_appel [var ]

Ex : $ read -p "Entrez votre prenom : " prenomEntrez votre prenom : Eric$$ echo $prenomEric

$

Remarques sur la commande interne read

-Sil y a moins de variables que de mots dans la ligne lue, le shell affecte le premier mot lapremire variable, le deuxime mot la deuxime variable, etc., la dernire variable reoit tous lesmots restants.

Ex : $ reada b cun bon jour coucou$$ echo $a

un$ echo $cjour coucou$

-Sil y a davantage de variables que de mots dans la ligne lue, chaque variable reoit un motet aprs puisement de ces derniers, les variables excdentaires sont vides (c.--d. initialises lavaleur null).

Ex : $ reada bUn$$ echo $aUn$$ echo $b

=> valeurnull$

Exercice1 : Ecrire un programme shell deuxfois qui affiche le message "Entrez un mot : ", lit lemot saisi par l'utilisateur puis affiche ce mot deux fois sur la mme ligne.

Ex : $ deuxfois

Entrez un mot : totototo toto$

17


18/107

Exercice2 : Ecrire un programme shell untrois qui demande l'utilisateur de saisir une suite demots constitue d'au moins trois mots et qui affiche sur la mme ligne le premier etle troisime mot saisis.

Ex : $ untroisEntrez une suite de mots : un petit coucou de Rodez

un coucou$

Variable en lecture seule

Pour dfinir une variable dont la valeur ne doit pas tre modifie (appele constante dans dautreslangages de programmation), on utilise la syntaxe :

declare r nom=valeur[ nom=valeur ]

Ex : $ declare -r mess=bonjour$

On dit que la variable mess possde lattribut r.

Une tentative de modification de la valeur dune constante provoque une erreur.

Ex : $mess=salut-bash: mess: readonly variable$

Pour connatre la liste des constantes dfinies : declare r

Ex : $ declare -rdeclare -ar BASH_VERSINFO='([0]="3" [1]="1" [2]="17" [3]="1"[4]="release" [5]="i486-pc-linux-gnu")'declare -ir EUID="1002"declare -ir PPID="25165"declare -r SHELLOPTS="braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor"declare -ir UID="1002"declare -r mess="bonjour"$

Plusieurs constantes sont prdfinies : le tableau BASH_VERSINFO (attribut a), les entiersEUID, PPID et UID (attribut i) et la chane SHELLOPTS.

2.2. Paramtres de position et paramtres spciaux

2.2.1. Paramtres de position

Un paramtre de position est rfrenc par un ou plusieurs chiffres : 8 , 0 , 23

Lassignation de valeurs des paramtres de position seffectue :- soit laide de la commande interne set- soit lors de lappel dun fichier shell ou dune fonction shell.

18


19/107

ATTENTION : on ne peut utiliser ni le symbole =, ni la commande interne read pour affecter directement une valeur un

paramtre de position.

Ex : $ 23=bonjour-bash: 23=bonjour: command not found$$ read 4

aa-bash: read: `4': not a valid identifier$

Commande interne set :

La commande interne set affecte une valeur un ou plusieurs paramtres de position ennumrotant ses arguments suivant leur position. La numrotation commence 1.

Syntaxe : set arg1 ...

Ex : $ set alpha beta gamma => alpha est la valeur du paramtre de position 1, beta la

$ => valeur du deuxime paramtre de position et gamma

$ => la valeur du paramtre de position 3

Pour obtenir la valeur dun paramtre de position, il suffit de placer le caractre $ devant sonnumro ; ainsi, $1 permet dobtenir la valeur du premier paramtre de position, $2 la valeur dudeuxime et ainsi de suite.

Ex : $ set ab be ga => numrotation des mots ab, be et ga$

$ echo $3 $2ga be$$ echo $4

$

Tous les paramtres de position sont rinitialiss ds que la commande interne set est utilise avecau moins un argument.

Ex : $ set coucou$ echo $1

coucou$ echo $2

=> les valeurs be et ga prcdentes ont disparues$

La commande set -- rend indfinie la valeur des paramtres de position pralablement initialiss.Ex : $ set alpha beta

$ echo $1alpha$$ set --$ echo $1

=> les valeurs alpha et beta sont perdues$

19


20/107

Remarques :

- Utilise sans argument, set a un comportement diffrent : elle affiche la (longue) listedes noms et valeurs des variables dfinies.

Ex : $ set

BASH=/bin/bash. . .

$

- Si la valeur du premier argument de set commence par un caractre - ou +, une erreurse produit. En effet, les options de cette commande interne commencent par un de ces deuxcaractres. Pour viter que ce type derreur ne se produise, on utilise la syntaxe : set -- arg...

Ex : $ a=+qui$ set $a-bash: set: +q: invalid optionset: usage: set [--abefhkmnptuvxBCHP] [-o option] [arg ...]

$ set -- $a$$ echo $1+qui$

2.2.2. Paramtres spciaux

Un paramtre spcial est rfrenc par un caractre spcial. Laffectation dune valeur unparamtre spcial est effectue par le shell. Pour obtenir la valeur dun paramtre spcial, il suffitde placer le caractre $ devant le caractre spcial qui le reprsente.

Un paramtre spcial trs utilis est le paramtre # ( ne pas confondre avec le dbut duncommentaire). Celui-ci contient le nombre de paramtres de position ayant une valeur.

Ex : $ set a b c$

$ echo $# => affichage de la valeur du paramtre spcial #

3 => il y a 3 paramtres de position ayant une valeur$

Exercice3 : Ecrire un programme shell nbmots qui demande l'utilisateur de saisir une suitequelconque de mots puis affiche le nombre de mots saisis.

Ex : $ nbmotsEntrez une suite de mots : un deux trois quatre cinq

5 => 5 mots ont t saisis$

20


21/107

2.2.3. Commande interne shift

La commande interne shift dcale la numrotation des paramtres de position ayant une valeur.

Syntaxe : shift [n ]

Elle renomme le n+1 ime paramtre de position en paramtre de position 1, le n+2 imeparamtre de position en paramtre de position 2, etc. : (n+1) => 1 , (n+2) => 2 , etc.Une fois le dcalage effectu, le paramtre spcial # est mis jour.

Ex : $ set a b c d e

=> 1 2 3 4 5$ echo $1 $2 $#a b 5$$ shift 2

=> a b c d e les mots a et b sont devenus inaccessibles=> 1 2 3$ echo $1 $3c e$ echo $#3$

La commande interne shift sans argument est quivalente shift 1.

Remarque : shift ne modifie pas la valeur du paramtre de position 0 qui possde unesignification particulire.

2.2.4. Paramtres de position et fichiers shell

Dans un fichier shell, les paramtres de position sont utiliss pour accder aux valeurs desarguments qui ont t passs lors de son appel : cela signifie quau sein du fichier shell, lesoccurrences de $1 sont remplaces par la valeur du premier argument, celles de $2 par la valeur dudeuxime argument, etc. Le paramtre spcial $# contient le nombre darguments passs lors delappel.

Le paramtre de position 0 contient le nom complet du programme shell qui sexcute.

Soit le programme shell copie :

#!/bin/bash# @(#) copie

echo "Nom du programme : $0"echo "Nb d'arguments : $#"echo "Source : $1"echo "Destination : $2"cp $1 $2

21


22/107

Pour excuter ce fichier shell :

Ex : $ chmod u+x copie$$ copie /etc/passwd XNom du programme : ./copieNb d'arguments : 2Source : /etc/passwdDestination : X$

Dans le fichier copie, chaque occurrence de $1 a t remplace par la chane de caractres/etc/passwd, celles de $2 parX.

Exercice 4 : Ecrire un programme shell cp2foisprenant trois arguments : le premier dsigne lenom du fichier dont on veut copier le contenu dans deux fichiers dont les noms sont

passs comme deuxime et troisime arguments. Aucun cas d'erreur ne doit tre

considr.

Lorsque la commande interne set est utilise lintrieur dun programme shell, la syntaxe $1possde deux significations diffrentes : $1 comme premier argumentdu programme shell, et $1commepremier paramtre de position initialis parset au sein du fichier shell.

Exemple : programme shell ecrase_arg- - - - - - - - - - - - - - -# !/bin/bash

echo '$1' est $1 => la chane $1 est remplace par le premier argumentset hello => setcrase la valeur prcdente de $1echo '$1' est $1

- - - - - - - - - - - - - -

Ex : $ ecrase_arg bonjour coucou salut$1 est bonjour$1 est hello$

2.2.5. Paramtres spciaux * et @

Les paramtres spciaux @ et * contiennent tous deux la liste des valeurs des paramtres deposition initialiss.

Ex : $ set un deux trois quatre$$ echo $*un deux trois quatre$$ echo $@un deux trois quatre$

22


23/107

Ces deux paramtres spciaux ont des valeurs distinctes lorsque leur rfrence est place entre desguillemets ("$*" et "$@") :

"$*" est remplace par "$1 $2...""$@" est remplace par "$1" "$2"...

Ex : $ set un deux trois => trois paramtres de position sont initialiss$

$ set "$*" => est quivalent : set un deux trois$$ echo $#1$$ echo $1un deux trois$

Lintrt de la syntaxe "$*" est de pouvoir considrer lensemble des paramtres de position

initialiss comme une unique chane de caractres.

La syntaxe "$@" produit autant de chanes que de paramtres de positions initialiss.

$ set un deux trois => trois paramtres de position initialiss$

$ set "$@" => est quivalent : set un deux trois$$ echo $#3$ echo $1un

$

Variable prdfinie IFS et paramtre spcial "$*" :

La variable prdfinie du shell IFS contient les caractres sparateurs de mots dans unecommande. Par dfaut, ce sont les caractres espace, tabulation et interligne. Linitialisation deIFS est effectue parbash.

Le shell utilise le premier caractre mmoris dans IFS (par dfaut, le caractre espace) poursparer les diffrents paramtres de position lorsque la syntaxe "$*" est utilise. En modifiant la

valeur deIFS, lutilisateur peut changer ce caractre sparateur.

Ex : $ IFS=: => le caractre deux-points est maintenant le premier caractre de IFS$$ set un deux trois quatre$$ echo $*un deux trois quatre$$ echo "$@"un deux trois quatre$

$ echo "$*"un:deux:trois:quatre => seule la forme "$*" provoque un changement$

23


24/107

2.3. Suppression des ambiguts

Pour viter les ambiguts dans linterprtation des rfrences de paramtres, on utilise la syntaxe${paramtre}.

Ex : $ x=bon$ x1=jour

$ echo $x1 => valeur de la variablex1jour

$ echo ${x}1 => pour concatner la valeur de la variable x la chane 1bon1$

Ex : $ set un deux trois quatre cinq six sept huit neuf dix onze douze$ echo $11un1

$

$ echo ${11} => pour obtenir la valeur du onzime paramtre de positiononze$

2.4. Paramtres non dfinis

Trois cas peuvent se prsenter lorsque le shell doit valuer un paramtre :- le paramtre nest pas dfini,- le paramtre est dfini mais ne possde aucune valeur (valeurvide),

- le paramtre possde une valeur non vide.

Lorsque loption nounset de la commande interne set est positionne ltat on (commandeset -o nounset), bash affiche un message derreur quand il doit valuer un paramtre non dfini.

Ex : $ set -o nounset => option nounset ltat on$

$ echo $c => variable utilisateurc non dfinie,

-bash: c: unbound variable => message derreur !$$ echo $1

-bash: $1: unbound variable$

$ d= => d: variable dfinie mais vide$$ echo $d

=> valeurnull, pas derreur$

La prsence de paramtres non dfinis ou dfinis mais vides dans une commande peut mener sonexcution lchec. Afin de traiter ce type de problme, bash fournit plusieurs mcanismessupplmentaires de substitution de paramtres. Lun deux consiste associer au paramtre une

valeur ponctuelle lorsquil est non dfini ou bien dfini vide.

24


25/107

La syntaxe utiliser est la suivante : ${paramtre:-chane}

Ex : $ set -o nounset$

$ ut1=root => ut1 dfinie et non vide

$ ut2= => ut2 dfinie et vide

$$ echo $ut1root$$ echo $ut2

$ echo $1

-bash: $1: unbound variable => paramtre de position 1 non dfini$

Avec la syntaxe mentionne ci-dessus, il est possible dassocier temporairement une valeur pardfaut aux trois paramtres.

Ex : $ echo ${ut1:-sanchis}

root => ut1 tant dfinie non vide, elle conserve sa valeur$

$ echo ${ut2:-sanchis} => ut2 est dfinie et vide, la valeur de remplacement est

sanchis => utilise$$ echo ${1:-sanchis}

sanchis => le premier paramtre de position est non dfini$

Cette association ne dure que le temps dexcution de la commande.

Ex : $ echo $1

-bash: $1: unbound variable => le paramtre est redevenu indfini$

La commande set+o nounset positionne loption nounset ltat off: le shell traite les paramtresnon dfinis comme des paramtres vides.

Ex : $ set +o nounset => option nounset ltat off$

$ echo $e => variable e non dfinie,

=> aucune erreur signale$$ echo $2

=> aucune erreur signale$

$ f= =>f: variable dfinie vide$ echo $f

$

25


26/107

2.5. Suppression de variables

Pour rendre indfinies une ou plusieurs variables, on utilise la commande interne unset.

Syntaxe : unset var[var1. . . ]

Ex : $ a=coucou => la variable a est dfinie$ echo $acoucou

$ unset a => la variable a est supprime$

$ set -o nounset => pour afficher le message derreur$ echo $a-bash: a: unbound variable$

Une variable en lecture seule ne peut tre supprime parunset.

Ex : $ declare -r a=coucou => dfinition de la constante a$ echo $acoucou$ unset a-bash: unset: a: cannot unset: readonly variable$

26


27/107

3. Substitution de commandes

3.1.

PrsentationSyntaxe : $( cmd)

Une commande cmd entoure par une paire de parenthses () prcdes d'un caractre $ estexcute par le shell puis la chane $( cmd) est remplace par les rsultats de la commande cmdcrits sur la sortie standard, cest dire lcran. Ces rsultats peuvent alors tre affects unevariable ou bien servir initialiser des paramtres de position.

Ex : $pwd

/home/sanchis => rsultat crit parpwdsur sa sortie standard

$ repert=$(pwd) => la chane /home/sanchis remplace la chane $(pwd)$$ echo mon repertoire est $repertmon repertoire est /home/sanchis$

Exercice 1 : En utilisant la substitution de commande, crire un fichier shell mach affichant :"Ma machine courante est nomdelamachine"

Ex : $machMa machine courante est jade

$

Lorsque la substitution de commande est utilise avec la commande interne set, lerreur suivantepeut se produire :

$ set $( ls -l .bashrc)bash: set: -w: invalid optionset: usage: set [--abefhkmnptuvxBCHP] [-o option] [arg ...]$ ls -l .bashrc-rw-r--r-- 1 sanchis users 1342 nov 29 2004 .bashrc$

Le premier mot issu de la substitution commence par un caractre tiret : la commande interne setl'interprte comme une option, ce qui provoque une erreur. Pour rsoudre ce type de problme, ondouble le caractre tiret.

Ex : $ set -- $(ls -l .bashrc)$$ echo $1-rw-r--r$

Exercice2 : Ecrire un programme shell taille qui prend un nom de fichier en argument etaffiche sa taille. On ne considre aucun cas d'erreur.

27


28/107

Plusieurs commandes peuvent tre prsentes entre les parenthses.

Ex : $pwd ; whoami/home/sanchissanchis$$ set $(pwd ; whoami)$$ echo $2: $1sanchis: /home/sanchis$

Exercice 3 : A l'aide de la commande unix date, crire un programme shell jour qui affiche lejour courant du mois

Ex : $ datedimanche 22 octobre 2006, 18:33:38 (UTC+0200)

$$ jour22$

Exercice4 : a) Ecrire un programme shell heure1 qui affiche l'heure sous la formeheures:minutes:secondes

Ex : $ heure118:33:38$

b) Ecrire un programme shell heure qui n'affiche que les heures et minutes

Ex : $ heure18:33$

Exercice 5 : Ecrire un programme shell nbconnect qui affiche le nombre d'utilisateursconnects sur la machine locale

Rq : plusieurs solutions sont possiblessolution 1, avec who | wc -lsolution 2, avec uptime

solution 3, avec userssolution 4, avec who -q

Les substitutions de commandes peuvent tre imbriques.

Ex : $ ls .gnomeapplication-info gnome-vfs mime-info$$ set $( ls $(pwd)/.gnome )$

$ echo $# => nombre d'entres du rpertoire .gnome3$

28


29/107

Plusieurs sortes de substitutions (de commandes, de variables) peuvent tre prsentes dans lamme commande.

Ex : $ read repgnome$

$ set $( ls $( pwd)/$rep )=> substitutions de deux commandes et d'une$ => variable

La substitution de commande permet galement de capter les rsultats crits par un fichier shell.

Ex : $ jour22$$ resultat=$( jour )$

La variable resultatcontient la chane 22.

Exercice 6 : Ecrire un programme shell uid qui affiche l'uid de l'utilisateur. On utilisera lacommande unix id, la commande interne set et la variable prdfinie IFS.

Rq : Il existe pour la substitution de commande une syntaxe plus ancienne `cmd` (deux caractres accent graveentourent la commande cmd), utiliser lorsque se posent des problmes de portabilit.

3.2. Substitutions de commandes et paramtres rgionaux

Cr par des informaticiens amricains, le systme Unix tait originellement destin desutilisateurs anglophones. La diffusion des systmes de la famille Unix (dont GNU/Linux) vers des

publics de langues et de cultures diffrentes a conduit leurs dveloppeurs introduire desparamtres rgionaux (locale). Ces derniers permettent par exemple de fixer la langue d'affichagedes messages, le format des dates ou des nombres. Les paramtres rgionaux se prsentent l'utilisateur sous la forme de variables prdfinies dont le nom commence parLC_.

La commande unix locale utilise sans argument affiche la valeur courante de ces variablesd'environnement.

Ex : $ localeLANG=fr_FR@euroLC_CTYPE="fr_FR@euro"LC_NUMERIC="fr_FR@euro"LC_TIME="fr_FR@euro"LC_COLLATE="fr_FR@euro"LC_MONETARY="fr_FR@euro"LC_MESSAGES="fr_FR@euro"LC_PAPER="fr_FR@euro"LC_NAME="fr_FR@euro"LC_ADDRESS="fr_FR@euro"LC_TELEPHONE="fr_FR@euro"LC_MEASUREMENT="fr_FR@euro"LC_IDENTIFICATION="fr_FR@euro"LC_ALL=$

29


30/107

Des commandes telles que date utilisent la valeur de ces variables prdfinies pour afficher leursrsultats.

Ex : $ datevendredi 3 novembre 2006, 18:47:02 (UTC+0100)

$

On remarque que le format du rsultat correspond bien une date la franaise (jour de lasemaine, jour du mois, mois, anne). Si cette internationalisation procure un confort indniablelors d'une utilisation interactive du systme, elle pose problme lorsque l'on doit crire un

programme shell se basant sur la sortie d'une telle commande, sortie qui dpend troitement de lavaleur des paramtres rgionaux. La portabilit du programme shell en est fortement fragilise.

Cependant, le fonctionnement standard dun systme unix traditionnel peut tre obtenu enchoisissant la locale standard appele C. Pour que cette locale naffecte temporairement que lesrsultats dune seule commande, par exemple date, il suffit dexcuter la commande

LC_ALL=C date

Ex : $ LC_ALL=C dateFri Nov 3 18:47:41 CET 2006$

On saperoit quavec la locale standard, le jour du mois est en troisime position alors quavec lalocale prcdente, il tait en deuxime position. Pour obtenir de manire portable le jour courantdu mois, on pourra excuter les commandes suivantes :

Ex : $ set $(LC_ALL=C date) ; echo $3

3$

30


31/107

4. Caractres et expressions gnriques

Les caractres et expressions gnriques sont issus d'un mcanisme plus gnral appelexpressions rationnelles

(regular expressions

) ouexpressions rgulires

. Ces caractres etexpressions sont utiliss pour spcifier un modle de noms d'entres. Ce modle est ensuiteinterprt par le shell pour crer une liste trie de noms d'entres. Par dfaut, le shell traiteuniquement les entres non caches du rpertoire courant ; cela signifie que les entres dont lenom commence par le caractre .sont ignores.

Pour illustrer lutilisation des caractres et expressions gnriques, on utilisera un rpertoire appelgenerique contenant les 16 entres suivantes :

$pwd/home/sanchis/generique$

$ ls -ltotal 0-rw-r--r-- 1 sanchis users 0 nov 10 2004 1-rw-r--r-- 1 sanchis users 0 nov 10 2004 a-rw-r--r-- 1 sanchis users 0 nov 10 2004 _a-rw-r--r-- 1 sanchis users 0 nov 10 2004 A-rw-r--r-- 1 sanchis users 0 nov 10 2004 -rw-r--r-- 1 sanchis users 0 nov 10 2004 ami-rw-r--r-- 1 sanchis users 0 nov 10 2004 an-rw-r--r-- 1 sanchis users 0 nov 10 2004 Arbre-rw-r--r-- 1 sanchis users 0 nov 10 2004 e-rw-r--r-- 1 sanchis users 0 nov 10 2004 -rw-r--r-- 1 sanchis users 0 nov 10 2004 mirat

-rw-r--r-- 1 sanchis users 0 nov 10 2004 En-rw-r--r-- 1 sanchis users 0 nov 10 2004 tat-rw-r--r-- 1 sanchis users 0 nov 10 2004 minuit-rw-r--r-- 1 sanchis users 0 nov 10 2004 zaza-rw-r--r-- 1 sanchis users 0 nov 10 2004 Zoulou$

Rq : La valeur des paramtres rgionaux influe grandement sur la prsentation et la mthode de tri des noms dentres. Sion utilise la locale standard, on obtient laffichage suivant :

$ LC_ALL=C ls -ltotal 0-rw-r--r-- 1 sanchis users 0 Nov 10 2004 1-rw-r--r-- 1 sanchis users 0 Nov 10 2004 A-rw-r--r-- 1 sanchis users 0 Nov 10 2004 Arbre-rw-r--r-- 1 sanchis users 0 Nov 10 2004 En-rw-r--r-- 1 sanchis users 0 Nov 10 2004 Zoulou-rw-r--r-- 1 sanchis users 0 Nov 10 2004 _a-rw-r--r-- 1 sanchis users 0 Nov 10 2004 a-rw-r--r-- 1 sanchis users 0 Nov 10 2004 ami-rw-r--r-- 1 sanchis users 0 Nov 10 2004 an-rw-r--r-- 1 sanchis users 0 Nov 10 2004 e-rw-r--r-- 1 sanchis users 0 Nov 10 2004 minuit-rw-r--r-- 1 sanchis users 0 Nov 10 2004 zaza-rw-r--r-- 1 sanchis users 0 Nov 10 2004 ?-rw-r--r-- 1 sanchis users 0 Nov 10 2004 ?-rw-r--r-- 1 sanchis users 0 Nov 10 2004 ?mirat-rw-r--r-- 1 sanchis users 0 Nov 10 2004 ?tat

$

31


32/107

On saperoit que laffichage des noms dentres contenant des caractres accentus est altr. La raison de cela est queseuls les 7 premiers bits codant les caractres sont interprts en locale standard. La locale prcdente utilise un codagedes caractres sur 8 bits.

4.1. Caractres gnriques

Les caractres gnriques du shell sont : * ? []

Rq : il ne faut pas confondre la syntaxe [] du mta-langage et les caractres gnriques [] du shell.

Pour que bash interprte les caractres gnriques, il est ncessaire que l'option noglob de lacommande interne set soit l'tat off. Pour connatre l'tat des diffrentes options de la commandeinterne set, on utilise la commande set o .

Ex: $ set oallexport offbraceexpand on

emacs onerrexit offhashall onhistexpand onhistory onignoreeof offinteractive-comments onkeyword offmonitor onnoclobber offnoexec offnoglob offnolog off

notify offnounset offonecmd offphysical offposix offprivileged offverbose offvi offxtrace off$

Le caractre gnrique * dsigne n'importe quelle suite de caractres, mme la chane

vide

Ex : $ echo *1 a _a A ami an Arbre e mirat En tat minuit zaza Zoulou$

Tous les noms d'entres sont affichs, tris.

Ex : $ ls -l a*-rw-r--r-- 1 sanchis users 0 nov 10 11:41 a-rw-r--r-- 1 sanchis users 0 nov 10 11:41 ami-rw-r--r-- 1 sanchis users 0 nov 10 11:41 an$

32


33/107

La notation a* dsigne toutes les entres du rpertoire courant dont le nom commence par la lettrea. Par consquent, dans la commande ls l a* le shell remplace la chane a* par la chane : aami anEn dautres termes, la commande ls "ne voit pas" le caractre * puisquil est prtrait par le shell.

$ echo *a* => noms des entres contenant un caractre a

a _a ami an mirat tat zaza$

Attention : quand aucune entre ne correspond au modle fourni, les caractres et expressionsgnriques ne sont pas interprts.

Ex : $ echo Z*tZ*t$

Le caractre gnrique ? dsigne un et un seul caractre

Ex : $ echo ? => noms dentres composs dun seul caractre1 a A e $$ echo ?nan En$

Plusieurs caractres gnriques diffrents peuvent tre prsents dans un modle.

Ex : $ echo ?mi*ami mirat

$

Exercice : Ecrire un modle permettant d'afficher le nom des entres dont le 2me caractre estun a.

Exercice : Ecrire un modle permettant d'afficher le nom des entres dont le 1er caractre estun a suivi par 2 caractres quelconques.

Les caractres gnriques [] dsignent un seul caractre parmi un groupe de caractres

Ce groupe est prcis entre les caractres[]. Il peut prendre deux formes : la forme ensemble et laforme intervalle.

Forme ensemble : tous les caractres souhaits sont explicitement mentionns entre[]

Ex : $ ls -l [ame]-rw-r--r-- 1 sanchis users 0 nov 10 11:41 a-rw-r--r-- 1 sanchis users 0 nov 10 11:41 e$$ echo ?[ame]*_a ami mirat zaza$

Le modle [ame] dsigne tous les noms d'entres constitus d'un seul caractre a, m ou e.

33


34/107

Forme intervalle : seules les bornes de l'intervalle sont prcises et spares par un - .

Ex : $ echo *1 a _a A ami an Arbre e mirat En tat minuit zaza Zoulou$

$ echo [a-z]* => le caractre Zest ignor

a A ami an Arbre e mirat En tat minuit zaza$

$ echo [A-Z]* => le caractre a est ignorA Arbre e mirat En tat minuit zaza Zoulou$

Linterprtation du modle [a-z] est conditionne par la valeur des paramtres rgionaux : cettesyntaxe est donc non portable et il est dconseill de lemployer car elle peut avoir des effetsnfastes lorsquelle est utilise avec la commande unix rm.

Si l'on souhaite dsigner une classe de caractres tels que les minuscules ou les majuscules, il estprfrable d'utiliser la syntaxe POSIX 1003.2 correspondante. Ce standard dfinit des classes de

caractres sous la forme [:nom_classe:]

Des exemples de classes de caractres dfinies dans ce standard sont :[:upper:] (majuscules)[:lower:] (minuscules)[:digit:] (chiffres, 0 9)[:alnum:](caractres alphanumriques).

Attention : pour dsigner n'importe quel caractre d'une classe, par exemple les minuscules, onplace la classe entre les caractres gnriques[].

Ex : $ echo [[:lower:]] => noms d'entres constitus d'une seule minusculea e $$ echo [[:upper:]]*A Arbre En Zoulou$

Pour afficher les noms d'entres commenant par une majuscule ou le caractre a :echo [[:upper:]a]*

Il est possible de mentionner un caractre ne devant pas figurer dans un groupe de caractres. Il

suffit de placer le caractre !juste aprs le caractre[.

Ex : $ echo ?[!n]* => noms d'entres ne comportant pas le caractre n en 2me position_a ami Arbre mirat tat minuit zaza Zoulou$$ echo [![:lower:]]1 A$$ echo [![:upper:]]*1 a _a ami an e mirat tat minuit zaza$$ echo [![:upper:]]*[!at]ami an

$

34


35/107

4.2. Expressions gnriques

Pour que bash, interprte les expressions gnriques, il est ncessaire que loption extglob de lacommande interne shopt soit active.

Ex : $ shopt

cdable_vars offcdspell offcheckhash offcheckwinsize oncmdhist ondotglob offexecfail offexpand_aliases onextdebug offextglob offextquote onfailglob offforce_fignore on

gnu_errfmt offhistappend offhistreedit offhistverify offhostcomplete onhuponexit offinteractive_comments onlithist offlogin_shell onmailwarn offno_empty_cmd_completion offnocaseglob offnocasematch off

nullglob offprogcomp onpromptvars onrestricted_shell offshift_verbose offsourcepath onxpg_echo off$

Pour activer une option de la commande interne shopt on utilise la commande : shopt soptPour activer le traitement des expressions gnriques par le shell : shopt s extglob

Les expressions gnriques de bash sont :

? (liste_modles): correspond 0 ou 1 occurrence de chaque modle

* (liste_modles) : correspond 0,1 ou plusieurs occurrences de chaque modle

+ (liste_modles) : correspond au moins 1 occurrence de chaque modle

@ (liste_modles) : correspond exactement 1 occurrence de chaque modle

! (liste_modles) : correspond tout sauf aux modles mentionns

35


36/107

Ex : $ echo +([[:lower:]])bash: syntax error near unexpected token `('$$ shopt -s extglob$

$ echo +([[:lower:]]) => noms constitus que de minusculesa ami an e mirat tat minuit zaza

$$ echo !(+([[:lower:]]))1 _a A Arbre En Zoulou$

Exercice : Ecrire un modle correspondant aux noms d'entres ne comportant pas decaractre a

Si lon souhaite utiliser les expressions gnriques dans un fichier shell, on y inclurapralablement la commande shopt s extglob

Remarques :

- Outre extglob, dautres options de la commande interne shopt permettent de modifier lacration de la liste des noms dentres. Ces options sont : dotglob, nocaseglob, nullglob,failglob. Par dfaut elles sont inactives (off).

- Pour grer ses propres options, bash intgre deux commandes, set et shopt.Dun point de vue pratique,pour connatre l'tat des options de la commande interne set : set o

pour activer une option de la commande interne set : set o optionpour dsactiver une option de la commande interne set : set +o optionpour connatre l'tat des options de la commande interne shopt : shoptpour activer une option de la commande interne shopt : shopt -s optionpour dsactiver une option de la commande interne shopt : shopt -u option

36


37/107

5. Redirections lmentaires

5.1.

Descripteurs de fichiersUn processus Unix possde par dfaut trois voies dinteraction avec lextrieur appeles entres /sorties standardidentifies par un entier positif ou nul appel descripteur de fichier.Ces entres / sorties standard sont :

- une entre standard, de descripteur0- une sortie standard, de descripteur1- une sortie standard pour les messages derreurs, de descripteur2.

Toute commande tant excute par un processus, nous dirons galement quune commandepossde trois entres / sorties standard.

0

2

1commande

De manire gnrale, une commande de type filtre (ex : cat) prend ses donnes sur son entrestandard qui correspond par dfaut au clavier, affiche ses rsultats sur sa sortie standard, par dfautlcran, et affiche les erreurs ventuelles sur sa sortie standard pour les messages derreurs, pardfaut lcran galement.

5.2. Redirections lmentaires

On peut rediriger sparment chacune des trois entres/sorties standard dune commande. Celasignifie quune commande pourra

- lire les donnes traiter partir dun fichier et non du clavier de lutilisateur- crire les rsultats ou erreurs dans un fichier et non lcran.

Redirection de la sortie standard : >fichier ou 1>fichier

Ex : $pwd

/home/sanchis$pwd>fich

$ => aucun rsultat affich lcran !

$ cat fich => le rsultat a t enregistr dans le fichierfich/home/sanchis$

Cette premire forme de redirection de la sortie standard crase l'ancien contenu du fichier desortie (fichierfich) si celui-ci existait dj, sinon le fichier est cr.

Le shell prtraite une commande avant de lexcuter : dans lexemple ci-dessous, le shell cre un

fichier videfdevant recevoir les rsultats de la commande (ici inexistante) ; lunique effet de >fsera donc la cration du fichierfou sa remise zro.

37


38/107

Ex : $ >f => cre ou remet zro le fichierf$$ ls -l f-rw-r--r-- 1 sanchis users 0 oct 22 11:34 f$

Une commande ne possde quune seule sortie standard; par consquent, si on dsire effacer lecontenu de plusieurs fichiers, il est ncessaire dutiliser autant de commandes que de fichiers effacer. Le caractre ; permet dexcuter squentiellement plusieurs commandes crites sur lamme ligne.

Ex : $ >f1 ; >f2$

La redirection de la sortie standard de cat est souvent utilise pour affecter un contenu succinct un fichier.

Ex : cat >tata => lentre standard est directement recopie dans tata$a demainsi vous le voulez bien^D$$ cat tataa demainsi vous le voulez bien$

0cat

1

tata

a demainsi vous le voulez bien

Pour concatner (cest dire ajouter la fin) la sortie standard d'une commande au contenu d'unfichier, une nouvelle forme de redirection doit tre utilise : >> fichier

Ex : $pwd > t$$ date >>t$

$ cat t/home/sanchislundi 20 novembre 2006, 15:27:41 (UTC+0100)$

Comme pour la redirection prcdente, lexcution de >> fich cre le fichierfich sil nexistaitpas.

Redirection de la sortie standard pour les messages d'erreur : 2>fichier

On ne doit laisser aucun caractre espace entre le chiffre 2et le symbole >.

38


39/107

Ex : $pwd/home/sanchis

$ ls vi => lditeur de texte vi se trouve dans le rpertoire /usr/binls: vi: Aucun fichier ou rpertoire de ce type$ ls vi 2>/dev/null$

Le fichier spcial /dev/null est appel poubelle ou puits car toute sortie qui y est redirige,est perdue. En gnral, il est utilis lorsquon est davantage intress par le code de retour de lacommande plutt que par les rsultats ou messages derreur quelle engendre.

Comme pour la sortie standard, il est possible de concatner la sortie standard pour les messagesderreur d'une commande au contenu d'un fichier : 2>>fichier

Ex : $ ls vils: vi: Aucun fichier ou rpertoire de ce type$$ ls vi 2>err

$$ ls date 2>>err$$ cat errls: vi: Aucun fichier ou rpertoire de ce typels: date: Aucun fichier ou rpertoire de ce type$

Pour rediriger la sortie standard pour les messages derreur vers la sortie standard (c.a.d vers lefichier de descripteur1), on utilisera la syntaxe : 2>&1Cela est souvent utilis lorsquon dsire conserver dans un mme fichier toutes les sorties.

Ex : $ lsMail err public_html tmp_.forward fic_noms t$$ ls vierr >trace 2>&1$$ cat tracels: vi: Aucun fichier ou rpertoire de ce typeerr$

La sortie standard est redirige vers le fichier trace [a] puis la sortie standard pour les messages

derreur est redirige vers la sortie standard, c.--d. galement vers le fichier trace [b].

ls vi err Ecran

trace

1

2

[a]

39


40/107

ls vi err Ecran

trace

1

2

[b]

La syntaxe &>fichier est quivalente la syntaxe >fichier 2>&1

Ex : $ ls vi err &>trace$$ cat tracels: vi: Aucun fichier ou rpertoire de ce typeerr$

Attention : Les redirections tant traites de gauche droite, lordre des redirections estimportant.

Exercice : Que fait la commande : ls vi fic_noms 2>&1 >trace

Redirection de l'entre standard : fichierfic_noms

Redirections spares des entres / sorties standard :

Les entres / sorties peuvent tre rediriges indpendamment les unes des autres.

40


41/107

Ex : $wc -l fic_nblignes 2>err$$ cat fic_nblignes3$$ cat err$

La commande unix wc -l affiche le nombre de lignes dun ou plusieurs fichiers texte. Ici, il sagitdu nombre de lignes du fichierfic_noms. Le fichiererrest cr mais est vide car aucune erreur nesest produite. Dans cet exemple, la disposition des redirections dans la ligne de commande na pasdimportance, car les deux sorties ne sont pas rediriges vers le mme fichier.

Il est possible de placer les redirections o l'on souhaite car le shell traite les redirections avantd'excuter la commande :

Ex : $ < fic_noms >fic_nblignes wc 2>err -l$

$ cat fic_nblignes3$$ cat err$

La plupart des commandes affichent leurs rsultats sous la mme forme, suivant que lon passe enargument le nom dun fichier ou que lon redirige son entre standard avec ce fichier.

Ex : $ cat fic => cat ouvre le fichierfic afin de lire son contenubonjouret au revoir

$$ cat cat lit son entre standard (redirige par le shell)bonjouret au revoir$

Il nen est pas ainsi avec la commande wc : celle-ci ncrit pas les rsultats de la mme manire.

Ex : $wc -l fic_noms3 fic_noms$$wc -l< fic_noms

3$

Par consquent, lorsque lon dsirera traiter la sortie dune commande wc, il faudra prendre garde la forme utilise. La deuxime forme est prfrable lorsque on ne souhaite que le nombre delignes.

Ex : $ nblignes=$( wc -l< fic_noms )$$ echo $nblignes

3 => nombre de lignes

$

41


42/107

Texte joint :

Il existe plusieurs syntaxes lgrement diffrentes pour passer un texte joint comme entre unecommande. Nanmoins, la syntaxe prsente ci-dessous est la plus simple.

Syntaxe : cmd


43/107

more qui les affiche cran par cran. La sortie standard de la dernire commande ntant pasredirige, laffichage final seffectue lcran.

ls -l /bin more|1 10

2 2

Un rsultat quivalent aurait pu tre obtenu dune manire moins lgante en excutant la suite decommandes :

ls -l /bin >temporaire ; more < temporaire ; rm temporaire

La commande ls -l /bin crit le rsultat dans le fichier temporaire ; ensuite, on affiche cran parcran le contenu de ce fichier ; enfin, on efface ce fichier devenu inutile. Le mcanisme de tubevite lutilisateur de grer ce fichier intermdiaire.

Pipelines :

On appellepipeline, une suite non vide de commandes connectes par des tubes :cmd1|...| cmdn

Chaque commande est excute par un processus distinct, la sortie standard de la commandecmdi-1 tant connecte lentre standard de la commande cmdi .

Ex : $ date | tee trace1 trace2 | wc -l

1 => date ncrit ses rsultats que sur une seule ligne$$ cat trace1lundi 20 novembre 2006, 15:37:49 (UTC+0100)$$ cat trace2lundi 20 novembre 2006, 15:37:49 (UTC+0100)$

La commande unix tee crit le contenu de son entre standard sur sa sortie standard tout en gardantune copie dans le ou les fichiers dont on a pass le nom en argument.Dans lexemple ci-dessus, tee crit le rsultat de date dans les fichiers trace1 et trace2 ainsi que

sur sa sortie standard, rsultat pass la commande wc -l.

43


44/107

6. Groupement de commandes

Le shell fournit deux mcanismes pour grouper lexcution dun ensemble de commandes sans

pour cela affecter un nom ce groupement :- linsertion de la suite de commandes entre une paire daccolades- linsertion de cette suite de commandes entre une paire de parenthses.

{ suite_cmds ; }

Insre entre une paire daccolades, la suite de commandes est excute dans le shell courant. Celaa pour effet de prserver les modifications apportes par la suite de commandes surlenvironnement du processus courant.

Ex : $pwd

/home/sanchis => rpertoire initial$$ { cd /bin ; pwd; } => changement du rpertoire courant/bin$$pwd

/bin => rpertoire final (le changement a t prserv !)$

Sexcutant dans le shell courant, les modifications apportes aux variables sont galementconserves :

Ex : $ a=bonjour$$ { a=coucou ; echo $a ;}coucou$$ echo $acoucou$

Les accolades { et } sont deux mots-cl de bash ; chacune delles doit donc tre le premier motdune commande. Pour cela, chaque accolade doit tre le premier mot de la ligne de commande ou

bien tre prcde dun caractre ;. De plus, suite_cmds ne doit pas coller laccolade

ouvrante{.Par contre, la prsence ou absence dun caractre espace entre le caractre ; et le mot-cl } naaucune importance.

Ex : $ { cd /bin } => laccolade } nest pas le premier mot dune commande

> => le shell ne dtecte pas la fin du groupement

>^C => control-C$

$ {cd/bin ;} => il manque un espace ou une tabulation entre {et cd-bash: syntax error near unexpected token `}'$

44


45/107

Toutefois, lance en arrire-plan, la suite de commandes nest plus excute par le shell courantmais par un sous-shell.

Ex : $pwd

/home/sanchis => rpertoire initial$

$ { echo processus : ; cd / ; ps ;}&processus :[1] 27963$ PID TTY TIME CMD27942 pts/14 00:00:00 bash27947 pts/14 00:00:00 bash27963 pts/14 00:00:00 ps

[1] + Done { echo processus :; cd /; ps; }$$pwd

/home/sanchis => rpertoire final$

Bien quune commande cd / ait t excute, le rpertoire courant na pas t modifi(/home/sanchis).

Une utilisation frquente du regroupement de commandes est la redirection globale de leur entreou sortie standard.

Ex : $ cat fichpremiere lignedeuxieme ligne

troisieme lignequatrieme ligne$$ { read ligne1 ; read ligne2

>}< fich => le caractre> est affich par le shell, indiquant

$ => que laccolade } est manquante$ echo $ligne1premiere ligne$ echo $ligne2deuxieme ligne$

Lentre standard des deux commandes read ligne1 et read ligne2 est globalement redirige : ellesliront squentiellement le contenu du fichierfich.

Si les commandes de lecture navaient pas t groupes, seule la premire ligne defich aurait tlue.

Ex : $ read ligne1< fich ; read ligne2< fich$$ echo $ligne1premiere ligne$$ echo $ligne2

premiere ligne$

45


46/107

Comme pour toutes commandes composes, lorsque plusieurs redirections de mme type sontappliques la mme suite de commandes, seule la redirection la plus proche est effective.

Ex : $ { read lig1 ; read -p "Entrez votre ligne : " lig2read lig3>}< fich

Entrez votre ligne :bonjour tout le monde$$ echo $lig1premiere ligne$ echo $lig2bonjour tout le monde$ echo $lig3deuxieme ligne$

Les commandes read lig1 et read lig3 lisent le contenu du fichierfich mais la commanderead -p "Entrez votre ligne : " lig2 lit son entre standard (/dev/tty).

(suite_cmds)

Insre entre une paire de parenthses, la suite de commandes est excute dans un sous-shell.Lenvironnement du processus nest pas modifi aprs excution de la suite de commandes.Les parenthses sont des oprateurs (et non des mots cl) : suite_cmds peut par consquent collerune ou deux parenthses sans provoquer une erreur de syntaxe.

Ex : $pwd

/home/sanchis => rpertoire initial$

$ (cd /bin ; pwd)/bin$$pwd

/home/sanchis => le rpertoire initial na pas t modifi$$b=bonjour$$ ( b=coucou ; echo $b )coucou$$ echo $b

bonjour => la valeur de la variable b na pas t modifie$

Ce type de groupement de commandes peut tre aussi utilis pour effectuer une redirectionglobale.

Ex : $ ( pwd ; date ; echo FIN ) >fin$$ cat fin/home/sanchislundi 20 novembre 2006, 15:47:45 (UTC+0100)FIN

$

46


47/107

7. Code de retour4

Un code de retour(exit status) est fourni par le shell aprs excution d'une commande.

Le code de retour est un entier positif ou nul, compris entre 0 et 255, indiquant si l'excution de lacommande s'est bien droule ou s'il y a eu un problme quelconque.Par convention, un code de retour gal 0 signifie que la commande s'est excute correctement.Un code diffrent de 0 signifie une erreur syntaxique ou d'excution.

Lvaluation du code de retour est essentielle lexcution de structures de contrle du shell tellesque ifet while.

7.1. Paramtre spcial ?

Le paramtre spcial ? ( ne pas confondre avec le caractre gnrique ?) contient le code deretour de la dernire commande excute de manire squentielle (excution synchrone).

Ex : $pwd/home/sanchis$ echo $?

0 => la commandepwds'est excute correctement$ ls -l vils: vi: Aucun fichier ou rpertoire de ce type$ echo $?

2 => une erreur sest produite !$

Exercice : En utilisant la commande unix ls et le mcanisme de redirection, crire unprogramme shell dansbin prenant un nom de commande en argument et qui affiche0 si cette commande est prsente dans/bin, une valeur diffrente de 0 sinon.

Ex : $ dansbin ls0$ dansbin who2$

Chaque commande positionne sa manire les codes de retour diffrents de 0. Ainsi, un codede retour gal 1 positionn par la commande unix ls n'a pas la mme signification qu'un code deretour 1 positionn par la commande unix grep. Les valeurs et significations du code de retourdune commande unix ou du shell sont documentes dans les pages correspondantes du manuel(ex : man grep).

Lorsque une commande est excute en arrire-plan (excution asynchrone), son code de retourn'est pas mmoris dans le paramtre spcial ?.

4 Ce texte est paru sous une forme lgrement diffrente dans la revue Linux Magazine France , n39, mai 2002

47


48/107

Ex : $ pwd => mise zro du paramtre spcial ?/home/sanchis$$ echo $?0

$ ls -l vi & => commande excute en arrire-plan[1] 19331

$ ls: vi: Aucun fichier ou rpertoire de ce type

[1]+ Exit 2 ls --color=tty -l vi$$ echo $?0$

On remarque que la commande s'est termine avec la valeur 2 (Exit 2) mais que ce code de retourn'a pas t enregistr dans le paramtre ?.

La commande interne deux-points (:) sans argument retourne toujours un code de retour gal 0.

Ex : $ : => commande deux-points$ echo $?0$

Il en est de mme avec la commande interne echo : elle retourne toujours un code de retour gal 0, sauf cas particuliers.

Ex : $ 1>&- echo coucou-bash: echo: write error: Mauvais descripteur de fichier$$ echo $?

1$

Enfin, certaines commandes utilisent plusieurs valeurs pour indiquer des significations diffrentes,comme la commande unix grep.

Commande unix grep :

Cette commande affiche sur sa sortie standard l'ensemble des lignes contenant une chane decaractres spcifie en argument, lignes appartenant un ou plusieurs fichiers texte (ou par dfaut,son entre standard).

La syntaxe de cette commande est : grep [ option(s)] chane_cherche [fich_texte1... ]

Soit le fichierpass contenant les cinq lignes suivantes :

root:x:0:0:root:/root:/bin/bashdaemon:x:1:1:daemon:/usr/sbin:/bin/shbertrand:x:101:100::/home/bertrand:/bin/bashalbert:x:102:100::/home/albert:/bin/bashsanchis:x:103:100::/home/sanchis:/bin/bash

48


49/107

La commande ci-dessous affiche toutes les lignes du fichierpass contenant la chane sanchis.

Ex : $ grep sanchis passsanchis:x:103:100::/home/sanchis:/bin/bash$

Attention : grep recherche une chane de caractres et non un mot.

Ex : $ grep bert passbertrand:x:101:100::/home/bertrand:/bin/bashalbert:x:102:100::/home/albert:/bin/bash$

La commande affiche toutes les lignes contenant la chane bert(et non le mot bert).Si lon souhaite la chane cherche en dbut de ligne, on utilisera la syntaxe^chane_cherche. Si on la veut en fin de ligne : chane_cherche$

Ex : $ grep bert passbertrand:x:101:100::/home/bertrand:/bin/bash$

La commande unix grep positionne un code de retour- gal 0 pour indiquer qu'une ou plusieurs lignes ont t trouves- gal 1 pour indiquer qu'aucune ligne n'a t trouve- gal 2 pour indiquer la prsence d'une erreur de syntaxe ou qu'un fichier mentionn en

argument est inaccessible.

Ex : $ grep sanchis passsanchis:x:103:100::/home/sanchis:/bin/bash

$0echo $?

$$ grep toto pass$$ echo $?

1 => la chane toto n'est pas prsente danspass$$ grep sanchis turlututugrep: turlututu: Aucun fichier ou rpertoire de ce type$$ echo $?

2=> le fichierturlututu n'existe pas !

$

Exercice : Ecrire un programme shell connu prenant en argument un nom dutilisateur quiaffiche 0 sil est enregistr dans le fichierpass, 1 sinon.

Ex : $ connu bert1$ connu albert0$

49


50/107

7.2. Code de retour d'un programme shell

Le code de retour d'un programme shell est le code de retour de la dernire commande qu'il aexcute.

Soit le programme shell lvicontenant l'unique commande ls vi.

#!/bin/bash# @(#) lvi

ls vi

Cette commande produira une erreur car vi ne se trouve pas dans le rpertoire courant ; aprsexcution, le code de retour de lvi sera de celui de la commande ls vi (dernire commandeexcute).

Ex : $ lvils: vi: Aucun fichier ou rpertoire de ce type

$$ echo $?

2 => code de retour de la dernire commande excute parlvi

$ => c.--d. ls vi

Autre exemple avec le programme shell lvi1 de contenu :

#!/bin/bash# @(#) lvi1

ls viecho Fin

La dernire commande excute parlvi1 sera la commande interne echo qui retourne un code deretour gal 0.

Ex : $ lvi1ls: vi: Aucun fichier ou rpertoire de ce typeFin$$ echo $?

0 => code de retour de la dernire commande excute parlvi (echo Fin)$

Il est parfois ncessaire de positionner explicitement le code de retour d'un programme shell avantqu'il ne se termine : on utilise alors la commande interne exit.

7.3. Commande interne exit

Syntaxe : exit [ n]

Elle provoque l'arrt du programme shell avec un code de retour gal n.Si n n'est pas prcis, le code de retour fourni est celui de la dernire commande excute.

50


51/107

Soit le programme shell lvi2 :

#!/bin/bash# @(#) lvi2

ls viexit 23

Ex : $ lvi2ls: vi: Aucun fichier ou rpertoire de ce type$$ echo $?

23 => code de retour de exit 23$

Le code de retour renvoy par ls vi est 2 ; en utilisant la commande interne exit, le programmeshell lvi2 positionne un code de retour diffrent (23).

7.4. Code de retour d'une suite de commandes

Le code de retour d'une suite de commandes est le code de retour de la dernire commandeexcute.

Le code de retour de la suite de commandes cmd1; cmd2; cmd3 est le code de retour de lacommande cmd3.

Ex : $pwd ; ls vi ; echo bonjour

/home/sanchisls: vi: Aucun fichier ou rpertoire de ce typebonjour$ echo $?

0 => code de retour de echo bonjour$

Il en est de mme pour le pipeline cmd1|cmd2|cmd3. Le code de retour sera celui de cmd3.

Ex : $ cat pass | grep sanchissanchis:x:103:100::/home/sanchis:/bin/bash$

$ echo $?0 => code de retour de grep sanchis$

Il est possible d'obtenir la ngation d'un code de retour d'un pipeline en plaant le mot-cl ! devantcelui-ci. Cela signifie que si le code de retour depipeline est gal 0, alors le code de retour de !

pipeline est gal 1.

Ex : $ ! ls pass=> le code de retour de ls passest gal 0pass$$ echo $?1$$ ! cat pass | grep daemon

51


52/107

daemon:x:1:1:daemon:/usr/sbin:/bin/sh$$ echo $?1$

Inversement, si le code de retour depipeline est diffrent de 0, alors celui de !pipeline est gal 0.

Ex : $ ! grep sanchis turlututugrep: turlututu: Aucun fichier ou rpertoire de ce type$$ echo $?0$

7.5. Rsultats et code de retour

On ne doit pas confondre le rsultat d'une commande et son code de retour : le rsultat correspond ce qui est crit sur sa sortie standard ; le code de retour indique uniquement si l'excution de lacommande s'est bien effectue ou non.

Parfois, on est intress uniquement par le code de retour d'une commande et non par les rsultatsqu'elle produit sur la sortie standard ou la sortie standard pour les messages d'erreurs.

Ex : $ grep toto pass > /dev/null 2>&1 => ou bien : grep toto pass &>/dev/null$$ echo $?

1 => on en dduit que la chane toto n'est pas prsente danspass$

7.6. Oprateurs && et || sur les codes de retour

Les oprateurs && et || autorisent lexcution conditionnelle dune commande cmd suivant lavaleur du code de retour de la dernire commande prcdemment excute.

Oprateur : &&

Syntaxe : cmd1 && cmd2

Le fonctionnement est le suivant : cmd1 est excute et si son code de retour est gal 0, alorscmd2 est galement excute.

Ex : $ grep daemon pass && echo daemon existedaemon:x:1:1:daemon:/usr/sbin:/bin/shdaemon existe$

La chane de caractres daemon est prsente dans le fichierpass, le code de retour renvoy par

lexcution de grep est 0 ; par consquent, la commande echo daemon existe est excute.

52


53/107

Oprateur : ||

Syntaxe : cmd1 || cmd2

cmd1 est excute et si son code de retour est diffrent de 0, alors cmd2est galement excute.

Pour illustrer cela, supposons que le fichiertoto nexiste pas.

Ex : $ ls pass totols: toto: Aucun fichier ou rpertoire de ce typepass$$ rm toto || echo toto non effacerm: ne peut enlever `toto': Aucun fichier ou rpertoire de ce typetoto non efface$

Le fichiertoto nexistant pas, la commande rm toto affiche un message derreur et produit un code

de retour diffrent de 0 : la commande interne echo qui suit est donc excute.

Combinaisons doprateurs && et ||

Les deux rgles mentionnes ci-dessus sont appliques par le shell lorsqu'une suite de commandescontient plusieurs oprateurs && et ||.Ces deux oprateurs ont mme priorit et leur valuationseffectue de gauche droite.

Ex : $ ls pass || ls toto || echo fini aussipass

$

Le code de retour de ls pass est gal 0 carpass existe, la commande ls toto ne sera donc pasexcute. Dautre part, le code de retour de lensemble ls pass || ls toto est le code de retour de ladernire commande excute, cest dire est gal 0 (car cest le code de retour de ls pass), doncecho fini aussi nest pas excute.

Documents

programation Bash