Script shell

2005-10-13T20:54:55Z

Sleg : /* Copyright */

[[Category:Développer sous Linux]]
= Programmation de Script: Une introduction =

<div class="leatitre">Programmation de Script: Une introduction</div><div class="leapar">par Fred, correction et ajouts de Marc</div><div class="leadesc">Comment écrire de petits scripts permettant d'automatiser la réalisation de taches répétitives.</div>
----

== Introduction ==

Vous aurez envie d'écrire un script (petit programme écrit avec un langage simple : shell, perl ou autre) dès que vous aurez tapé dans un terminal quatre fois la même série de commandes et que vous vous apercevrez que vous êtes ammené à le refaire de nombreuses fois. Un script est une suite d'instructions élémentaires qui sont éxécutées de façon séquencielle (les unes après les autres) par le langage de script. Dans cet article nous nous limiterons à l'utilisation du shell comme langage, et en particulier à du shell <tt>bash</tt>. En guise de première introduction, vous pouvez lire ce qui concerne les commandes du shell dans l'article [http://lea-linux.org/admin/shell.php3 Le Shell et les Commandes]. Attention, n'espérez pas que le présent document constitue un manuel complet de programmation ! C'est une courte introduction qui nous l'espérons, vous permettra d'écrire de petits scripts qui vous rendront de précieux services.

== Notions de base ==

=== Mon premier script. ===

Pour commencer, il faut savoir qu'un script est un fichier texte standard pouvant être créé par n'importe quel éditeur : [http://lea-linux.org/software/vi.php3 vi], [http://lea-linux.org/software/emacs.php3 emacs], kedit, gnotepad, ou autre. D'autre part, conventionnellement, un script commence par une ligne de commentaire contenant le nom du langage à utiliser pour interpréter ce script, soit dans notre cas : <tt>/bin/sh</tt> (on parle alors de "script shell"). Donc un script shell élémentaire pourrait être :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt></blockquote>

Note : <tt>"#!"</tt> se prononce "''she bang''", soit "chi-bang". Évidemment un tel script ne fait rien ! Changeons cela. La commande qui affiche quelque chose à l'écran est <tt>echo</tt>. Donc pour créer le script <tt>bonjour_monde</tt> nous pouvons écrire :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt>echo "Bonjour, Monde !"</tt> <tt>echo "un premier script est né."</tt></blockquote>

Comment on l'éxécute ? C'est simple il suffit de faire :

<blockquote><tt>[user@becane user]$ '''sh bonjour_monde'''</tt> <tt>Bonjour, Monde !</tt> <tt>un premier script est né.</tt> <tt>[user@becane user]$ _</tt></blockquote>

C'est pas cool, vous préféreriez taper quelque chose comme :

<blockquote><tt>[user@becane user]$ '''./bonjour_monde'''</tt> <tt>Bonjour, Monde !</tt> <tt>un premier script est né.</tt> <tt>[user@becane user]$ _</tt></blockquote>

C'est possible si vous avez au préalable rendu votre script exécutable par la commande :

<blockquote><tt>[user@becane user]$ '''chmod +x bonjour_monde'''</tt> <tt>[user@becane user]$ '''./bonjour_monde'''</tt> <tt>Bonjour, Monde !</tt> <tt>un premier script est né.</tt> <tt>[user@becane user]$ _</tt></blockquote>

Résumons : un script shell commence par : <tt><nowiki>#!/bin/sh</nowiki></tt>, il contient des commandes du shell et est rendu exécutable par <tt>chmod +x</tt>.

=== Quelques conseils concernant les commentaires ===

Dans un shell-script, est considéré comme un commentaire tout ce qui suit le caractère # et ce, jusqu'à la fin de la ligne. Usez et abusez des commentaires : lorsque vous relirez un script 6 mois après l'avoir écrit, vous serez bien content de l'avoir documenté. Un programme n'est jamais trop documenté. Par contre, il peut être mal documenté ! Un commentaire est bon lorsqu'il décrit pourquoi on fait quelque chose, pas quand il décrit ce que l'on fait. Exemple :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt><nowiki># pour i parcourant tous les fichiers,</nowiki></tt> <tt>for i in * ; do</tt> <tt><nowiki># copier le fichier vers .bak</nowiki></tt> <tt> cp $i $i.bak</tt> <tt><nowiki># fin pour</nowiki></tt> <tt>done</tt></blockquote>

Que fait le script ? Les commentaires ne l'expliquent pas ! Ce sont de mauvais commentaire. Par contre :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt><nowiki># on veut faire un copie de tous les fichiers</nowiki></tt> <tt>for i in * ; do</tt> <tt><nowiki># sous le nom *.bak</nowiki></tt> <tt> cp $i $i.bak</tt> <tt>done</tt></blockquote>

Là, au moins, on sait ce qu'il se passe. (Il n'est pas encore important de connaître les commandes de ces deux fichiers.)

=== Le passage de paramètres ===

Un script ne sera, en général, que d'une utilisation marginale si vous ne pouvez pas modifier son comportement d'une manière ou d'une autre. On obtient cet effet en "passant" un (ou plusieurs) paramètre(s) au script via la ligne de commande. Voyons comment faire cela. Soit le script <tt>essai01</tt><nowiki>: </nowiki>

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt>echo le paramètre \$1 est \"$1\"</tt> <tt>echo le paramètre \$2 est \"$2\"</tt> <tt>echo le paramètre \$3 est \"$3\"</tt></blockquote>

Que fait-il ? Il affiche, les uns après les autres les trois premiers paramètres du script, donc si l'on tappe :

<blockquote><tt>$ '''./essai01 paramètre un'''</tt> <tt>le paramètre $1 est "paramètre"</tt> <tt>le paramètre $2 est "un"</tt> <tt>le paramètre $3 est ""</tt> <tt>$ _</tt></blockquote>

Donc, les variables <tt>$1</tt>, <tt>$2</tt> ... <tt>$9</tt> contiennent les "mots" numéro 1, 2 ... 9 de la ligne de commande. Attention : par "mot" on entend ensemble de caractères ne contenant pas de caractères de séparations. Les caractères de séparation sont l'espace, la tabulation, le point virgule.

Vous avez sans doute remarqué que j'ai utilisé les caractères : <tt>\$</tt> à la place de <tt>$</tt> ainsi que <tt>\"</tt> à la place de <tt>"</tt> dans le script. Pour quelle raison ? La raison est simple, si l'on tape : <tt>echo "essai"</tt> on obtient : <tt>essai</tt>, si l'on veut obtenir <tt>"essai"</tt> il faut dire à <tt>echo</tt> que le caractère <tt>"</tt> n'indique pas le début d'une chaîne de caractère (comme c'est le comportement par défaut) mais que ce caractère fait partie de la chaîne : on dit que l'on "échappe" ou "protège" le caractère <tt>"</tt> en tapant <tt>\"</tt>. En "échappant" le caractère <tt>\</tt> (par <tt>\\</tt>) on obtient le caractère <tt>\</tt> sans signification particulière. On peut dire que le caractère <tt>\</tt> devant un autre lui fait perdre sa signification particulière s'il en a une, ne fait rien si le caractère qui suit <tt>\</tt> n'en a pas.

Maintenant, essayons de taper :

<blockquote><tt>$ '''./essai01 *'''</tt> <tt>le paramètre $1 est "Mail"</tt> <tt>le paramètre $2 est "essai01"</tt> <tt>le paramètre $3 est "nsmail"</tt> <tt>$ _</tt></blockquote>

(Le résultat doit être sensiblement différent sur votre machine). Que s'est-il passé ? Le shell a remplacé le caractère * par la liste de tous les fichiers non cachés présents dans le répertoire actif. En fait, toutes les substitutions du shell sont possibles ! C'est le shell qui "substitue" aux paramètres des valeurs étendues par les caractères spéciaux : * (toute suite de caractères) ? (un caractère grave quelconque), [dze] (l'un des caractères d, z ou e), [d-z] (les caractères de 'd' à 'z')... Autre exemple :

<blockquote><tt>$ '''./essai01 \*'''</tt> <tt>le paramètre $1 est "*"</tt> <tt>le paramètre $2 est ""</tt> <tt>le paramètre $3 est ""</tt> <tt>$ _</tt></blockquote>

Hé oui, on a "échappé" le caractère <tt><nowiki>*</nowiki></tt> donc il a perdu sa signification particulière : il est redevenu un simple <tt><nowiki>*</nowiki></tt>.

C'est bien, me direz vous, mais si je veux utiliser plus de dix paramètres ? Il faut utiliser la commande shift ; à titre d'exemple voici le script <tt>essai02</tt> :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt>echo le paramètre 1 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 2 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 2 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 4 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 5 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 6 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 7 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 8 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 9 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 10 est \"$1\"</tt> <tt>shift</tt> <tt>echo le paramètre 11 est \"$1\"</tt></blockquote>

Si vous tapez :

<blockquote><tt>$ '''./essai02 1 2 3 4 5 6 7 8 9 10 11 12 13'''</tt> <tt>le paramètre 1 est "1"</tt> <tt>le paramètre 2 est "2"</tt> <tt>le paramètre 2 est "3"</tt> <tt>le paramètre 4 est "4"</tt> <tt>le paramètre 5 est "5"</tt> <tt>le paramètre 6 est "6"</tt> <tt>le paramètre 7 est "7"</tt> <tt>le paramètre 8 est "8"</tt> <tt>le paramètre 9 est "9"</tt> <tt>le paramètre 10 est "10"</tt> <tt>le paramètre 11 est "11"</tt> <tt>$ _</tt></blockquote>

A chaque appel de <tt>shift</tt> les paramètres sont décalés d'un numéro : le paramètre 2 devient le paramètre 1, 3 devient 2, etc... Évidemment le paramètre 1 est perdu par l'appel de shift : vous devez donc vous en servir avant d'appeler <tt>shift</tt> (ou le sauvegarder dans une variable).

=== Les variables ===

Le passage des paramètres nous a montré l'utilisation de "noms" particuliers : <tt>$1</tt>, <tt>$2</tt> etc. Ce sont les substitutions des variables <tt>1</tt>, <tt>2</tt>, etc. par leur valeurs. Mais vous pouvez définir et utiliser n'importe quel nom. Attention toutefois à ne pas confondre le nom d'une variable (notée par exemple <tt>machin</tt>) et son contenu (noté dans cas <tt>$machin</tt>). Vous connaissez peut-être la variable <tt>PATH</tt> (attention, le shell différencie les majuscules des minuscules) qui contient la liste des répertoires (séparés par des <tt>":"</tt>) dans lesquels il doit rechercher les programmes. Si dans un script vous tapez :

<blockquote><tt>1:#!/bin/sh</tt> <tt>2:PATH=/bin # PATH contient /bin</tt> <tt>3:PATH=PATH:/usr/bin # PATH contient PATH:/usr/bin</tt> <tt>4:PATH=/bin # PATH contient /bin</tt> <tt>5:PATH=$PATH:/usr/bin # PATH contient /bin:/usr/bin</tt></blockquote>

(Les numéros ne sont là que pour repérer les lignes, il ne faut pas les taper) La ligne 3 est très certainement une erreur, à gauche du signe <tt>"="</tt> il faut une variable (donc un nom sans <tt>$</tt>) mais à droite de ce même signe il faut une valeur, et la valeur que l'on a mis est <tt>"PATH:/usr/bin"</tt> : il n'y a aucune substitution à faire. Par contre la ligne 5 est certainement correcte : à droite du <tt>"="</tt> on a mis <tt>"$PATH:/usr/bin"</tt>, la valeur de <tt>$PATH</tt> étant <tt>"/bin"</tt>, la valeur après substitution par le shell de <tt>"$PATH:/usr/bin"</tt> est <tt>"/bin:/usr/bin"</tt>. Donc, à la fin de la ligne 5, la valeur de la variable <tt>PATH</tt> est <tt>"/bin:/usr/bin"</tt>.

Attention : il ne doit y avoir aucun espace de part et d'autre du signe <tt>"="</tt>.

Résumons : <tt>MACHIN</tt> est un nom de variable que l'on utilise lorsque l'on a besoin d'un nom de variable (mais pas de son contenu), et <tt>$MACHIN</tt> est le contenu de la variable <tt>MACHIN</tt> que l'on utilise lorsque l'on a besoin du contenu de cette variable.

=== Variables particulières ===

Il y a un certain nombre de variables particulières, en voici quelques unes :

* la variable <tt><nowiki>*</nowiki></tt> (dont le contenu est <tt>$*</tt>) contient l'ensemble de tous les "mots" qui on été passé au script (c'est à dire toute la ligne de commande, sans le nom du script).
* la variable <tt><nowiki>#</nowiki></tt> contient le nombre de paramètres (<tt>$#</tt>) qui ont été passés au programme.
* la variable <tt></tt> (zéro) contient le nom du script (ou du lien si le script a été appelé depuis un lien).

Il y en a d'autres, moins utilisées : allez voir la man page de <tt>bash</tt>.

=== Saisir la valeur d'une variable ===

Les paramètres permettent à l'utilisateur d'agir sur le déroulement du script avant son exécution. Mais il est aussi souvent intéressant de pouvoir agir sur le déroulement du script lors de son exécution, c'est ce que permet la commande : <tt>read nom_variable</tt>. Dans cette commande vous pouvez bien sûr remplacer nom_variable par le nom de variable qui vous convient le mieux. Voici un exemple simple.

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt>echo -n "Entrez votre prénom : "</tt> <tt>read prenom</tt> <tt>echo -n "Entrez votre nom de login : "</tt> <tt>read nomlogin</tt> <tt>echo "Le nom de login de $prenom est $nomlogin."</tt></blockquote>

Ce script se déroule ainsi :

<blockquote><tt>'''./essai02bis '''Entrez votre prénom : '''Marc '''Entrez votre nom de login : '''spoutnik '''Le nom de login de Marc est spoutnik.</tt></blockquote>

Lors du déroulement du script vous devez valider vos entrées en appuyant sur la touche "Entrée".

=== Arithmétique ===

Vous vous doutez bien qu'il est possible de faire des calculs avec le shell. En fait, le shell ne "sait" faire que des calculs sur les nombres entiers (ceux qui n'ont pas de virgules ;-). Pour faire un calcul il faut encadrer celui-ci de : <tt>$(( un calcul ))</tt> ou <tt>$[ un calcul ]</tt>. Exemple, le script essai03 :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt>echo 2+3*5 = $((2+3*5))</tt> <tt>MACHIN=12</tt> <tt>echo MACHIN*4 = $[$MACHIN*4]</tt></blockquote>

Affichera :

<blockquote><tt>$ '''sh essai03'''</tt> <tt>2+3*5 = 17</tt> <tt>MACHIN*4 = 48</tt></blockquote>

Vous remarquerez que le shell respecte les priorités mathématiques habituelles (il fait les multiplications avant les additions !). L'opérateur puissance est <tt>"**"</tt> (ie : 2 puissance 5 s'écrit : <tt>2**5</tt>). On peut utiliser des parenthèses pour modifier l'ordre des calculs. 

== Les instructions de contrôle de scripts ==

Les instructions de contrôle du shell permettent de modifier l'exécution purement séquencielle d'un script. Jusqu'à maintenant, les scripts que nous avons créés n'étaient pas très complexes. Ils ne pouvaient de toute façon pas l'être car nous ne pouvions pas modifier l'ordre des instructions, ni en répéter.

=== L'exécution conditionnelle ===

Lorsque vous programmerez des scripts, vous voudrez que vos scripts fassent une chose si une certaine condition est remplie et autre chose si elle ne l'est pas. La construction de bash qui permet cela est le fameux test : <tt>if then else fi</tt>. Sa syntaxe est la suivante (la partie <tt>else...</tt> en italique est optionnelle) :

<blockquote><tt>'''if''' <test> ; '''then'''</tt> <tt> <instruction 1></tt> <tt> <instruction 2></tt> <tt> ...</tt> <tt> <instruction n></tt> ''<tt>else</tt>'' ''<tt> <instruction n+1></tt>'' ''<tt> ...</tt>'' ''<tt> <instruction n+p></tt>'' '''<tt>fi</tt>'''</blockquote>

Il faut savoir que tous les programmes renvoient une valeur. Cette valeur est stockée dans la variable <tt>?</tt> dont la valeur est, rappelons le : "<tt>$?</tt>". Pour le shell une valeur nulle est synonyme de VRAI et une valeur non nulle est synonyme de FAUX (ceci parce que, en général les programmes renvoie zéro quand tout c'est bien passé et un code d'erreur (numéro non nul) quand il s'en est produit une).

Il existe deux programmes particuliers : <tt>false</tt> et <tt>true</tt>. <tt>true</tt> renvoie toujours 0 et <tt>false</tt> renvoie toujours 1. Sachant cela, voyons ce que fait le programme suivant :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt>if true ; then</tt> <tt> echo Le premier test est VRAI($?)</tt> <tt>else</tt> <tt> echo Le premier test est FAUX($?)</tt> <tt>fi</tt>

<tt>if false ; then</tt> <tt> echo Le second test est VRAI($?)</tt> <tt>else</tt> <tt> echo Le second test est FAUX($?)</tt> <tt>fi</tt>

</blockquote>

Affichera :

<blockquote><tt>$ ./test</tt> <tt>Le premier test est VRAI(0)</tt> <tt>Le second test est FAUX(1)</tt> <tt>$ _</tt></blockquote>

On peut donc conclure que l'instruction <tt>if ... then ... else ... fi</tt>, fonctionne de la manière suivante : si ('''if''' en anglais) le test est VRAI(0) alors ('''then''' en anglais) le bloc d'instructions compris entre le <tt>then</tt> et le <tt>else</tt> (ou le <tt>fi</tt> en l'absence de <tt>else</tt>) est exécuté, sinon ('''else''' en anglais) le test est FAUX(différent de 0)) et on exécute le bloc d'instructions compris entre le <tt>else</tt> et le <tt>fi</tt> si ce bloc existe.

Bon, évidemment, des tests de cet ordre ne paraissent pas très utiles. Voyons maintenant de vrais tests.

=== Les tests ===

Un test, nous l'avons vu, n'est rien de plus qu'une commande standard. Une des commandes standard est '<tt>test</tt>', sa syntaxe est un peu complexe, je vais la décrire avec des exemples.

* si l'on veut tester l'existence d'un répertoire <tt><machin></tt>, on tapera : <tt>test -d <machin></tt> ('d' comme '''''d'''irectory'')
* si l'on veut tester l'existence d'un fichier <tt><machin></tt>, on tapera : <tt>test -f <machin></tt> ('f' comme '''''f'''ile'')
* si l'on veut tester l'existence d'un fichier ou répertoire <tt><machin></tt>, on tapera : <tt>test -e <machin></tt> ('e' comme '''''e'''xist'')

Pour plus d'information faites : <tt>man test</tt>.

On peut aussi combiner deux tests par des opérations logiques : 'ou' correspond à <tt>-o</tt> ('o' comme '''''o'''r''), 'et' correspond à <tt>-a</tt> ('a' comme '''''a'''nd'') (à nouveau allez voir la man page), exemple :

<blockquote><tt>test -x /bin/sh -a -d /etc</tt></blockquote>

Cette instruction teste l'existence de l'éxécutable <tt>/bin/sh</tt> (<tt>-x /bin/sh</tt>) et (<tt>-a</tt>) la présence d'un répertoire <tt>/etc</tt> (<tt>-d /etc</tt>).

On peut remplacer la commande <tt>test <un test></tt> par <tt>[ <un test> ]</tt> qui est plus lisible, exemple :

<blockquote><tt>if [ -x /bin/sh ] ; then</tt> # ('x' comme ''e'''x'''ecutable'') <tt> echo /bin/sh est exécutable. C\'est bien.</tt> <tt>else</tt> <tt> echo /bin/sh n\'est pas exécutable.</tt> <tt> echo Votre système n\'est pas normal.</tt> <tt>fi</tt></blockquote>

Toujours avec les crochets de <tt>test</tt>, si vous n'avez qu'une seule chose à faire en fonction du résultat d'un test, alors vous pouvez utiliser la syntaxe suivante : 

<blockquote><tt>[ -x /bin/sh ] && echo /bin/sh est exécutable.</tt> ou encore : <tt>[ -x /bin/sh ] || echo /bin/sh n\'est pas exécutable.</tt> </blockquote>

L'affichage du message est effectué, dans le premier cas que si le test est vrai et dans le second cas, que si le test est faux. Dans l'exemple on teste si /bin/sh est un fichier exécutable. Cela allége le script sans pour autant le rendre illisible, si cette syntaxe est utilisée à bon essient.

 Mais il n'y a pas que la commande <tt>test</tt> qui peut être employée. Par exemple, la commande <tt>grep</tt> renvoie 0 quand la recherche a réussi et 1 quand la recherche a échoué. Par exemple :

<blockquote><tt>if grep -E "^frederic:" /etc/passwd > /dev/null ; then</tt> <tt> echo L\'utilisateur frederic existe.</tt> <tt>else</tt> <tt> echo L'utilisateur frederic n\'existe pas.</tt> <tt>fi</tt></blockquote>

Cette série d'instruction teste la présence de l'utilisateur <tt>frederic</tt> dans le fichier <tt>/etc/passwd</tt>. Vous remarquerez que l'on a fait suivre la commande <tt>grep</tt> d'une redirection vers <tt>/dev/null</tt> pour que le résultat de cette commande ne soit pas affiché : c'est une utilisation classique. Ceci explique aussi l'expression : "Ils sont tellement intéressants, tes mails, que je les envoie vers /dev/null" ;-).

=== Faire quelque chose de différent suivant la valeur d'une variable ===

L'instruction <tt>case ... esac</tt> permet de modifier le déroulement du script selon la valeur d'un paramètre ou d'une variable. On l'utilise le plus souvent quand les valeurs possibles sont en nombre restreint et peuvent être prévues. Les imprévus peuvent alors être représentés par le signe *. Demandons par exemple à l'utilisateur s'il souhaite afficher ou non les fichiers cachés du répertoire en cours.

<blockquote><tt><nowiki>#!/bin/sh</nowiki> # pose la question et récupère la réponse echo "Le contenu du répertoire courant va être affiché." echo -n "Souhaitez-vous afficher aussi les fichiers cachés (oui/non) : " read reponse # agit selon la réponse case $reponse in oui) clear ls -a;; non) ls;; *) echo "Erreur, vous deviez répondre par oui ou par non.";; esac</tt></blockquote>

Seules les réponses "oui" et "non" sont réellement attendues dans ce script, toute autre réponse engendrera le message d'erreur. On notera qu'ici l'écran est effacé avant l'affichage dans le cas d'une réponse positive, mais pas dans celui d'une réponse négative. Lorsque vous utilisez l'instruction <tt>case ... esac</tt>, faites bien attention de ne pas oublier les doubles points-virgules terminant les instructions de chacun des cas envisagés.

=== Faire la même chose pour tous les éléments d'une liste ===

Lorsqu'on programme, on est souvent amené à faire la même chose '''pour tous''' les élément d'une liste. Dans un shell script, il est bien évidemment possible de ne pas réécrire dix fois la même chose. On dira que l'on fait une boucle. L'instruction qui réalise une boucle est

<blockquote><tt>for <variable> in <liste de valeurs pour la variable> ; do</tt> <tt> <instruction 1></tt> <tt> ...</tt> <tt> <instruction n></tt> <tt>done</tt></blockquote>

Voyons comment ça fonctionne. Supposons que nous souhaitions renommer tous nos fichiers *.tar.gz en *.tar.gz.old, nous taperons le script suivant :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt><nowiki># I prend chacune des valeurs possibles correspondant</nowiki></tt> <tt><nowiki># au motif : *.tar.gz</nowiki></tt> <tt>for I in *.tar.gz ; do</tt> <tt> # tous les fichiers $I sont renommés $I.old</tt> <tt> echo "$I -> $I.old"</tt> <tt> mv $I $I.old</tt> <tt><nowiki># on finit notre boucle</nowiki></tt> <tt>done</tt></blockquote>

Simple, non ? Un exemple plus complexe ? Supposons que nous voulions parcourir tous les sous-répertoires du répertoire courant pour faire cette même manipulation. Nous pourrons taper :

<blockquote><tt> 1:#!/bin/sh</tt> <tt> 2:for REP in `find -type d` ; do</tt> <tt> 3: for FICH in $REP/*.tar.gz ; do</tt> <tt> 4: if [ -f $FICH ] ; then</tt> <tt> 5: mv $FICH $FICH.old</tt> <tt> 6: else</tt> <tt> 7: echo On ne renomme pas $FICH car ce n\'est pas un répertoire</tt> <tt> 8: fi</tt> <tt> 9: done</tt> <tt>10:done</tt></blockquote>

Explications : dans le premier 'for', on a précisé comme liste : <tt>`find -type d`</tt> (attention au sens des apostrophes, sur un clavier azerty français, on obtient ce symbole en appuyant sur <tt>ALTGR+é</tt>, ce ne sont pas des simples quotes '). Lorsque l'on tape une commande entre apostrophes inverses, le shell exécute d'abord cette commande, et remplace l'expression entre apostrophes inverses par la sortie standard de cette commande (ce qu'elle affiche à l'écran). Donc, dans le cas qui nous intéresse, la liste est le résultat de la commande <tt>find -type d</tt>, c'est à dire la liste de tous les sous-répertoires du répertoire courant. Ainsi, en ligne 2, on fait prendre à la variable REP le nom de chacun des sous-répertoires du répertoire courant, puis (en ligne 3) on fait prendre à la variable FICH le nom de chacun des fichiers .tar.gz de $REP (un des sous-répertoires), puis si $FICH est un fichier, on le renomme, sinon on affiche un avertissement.

Remarque : ce n'est pas le même fonctionnement que la boucle <tt>for</tt> d'autres langage (le pascal, le C ou le basic par exemple).

=== Faire une même chose tant qu'un certaine condition est remplie ===

Pour faire une certaine chose '''tant qu''''une condition est remplie, on utilise un autre type de boucle :

<blockquote><tt>while <un test> ; do</tt> <tt> <instruction 1></tt> <tt> ...</tt> <tt> <instruction n></tt> <tt>done</tt></blockquote>

Supposons, par exemple que vous souhaitiez afficher les 100 premiers nombres (pour une obscure raison), alors vous taperez :

<blockquote><tt>i=0</tt> <tt>while [ $i -lt 100 ] ; do</tt> <tt> echo $i</tt> <tt> i=$[$i+1]</tt> <tt>done</tt></blockquote>

Remarque : <tt>-lt</tt> signifie "'''<tt>l</tt>'''esser '''<tt>t</tt>'''han" ou "plus petit que" (et <tt>-gt</tt> signifie "plus grand", ou "'''<tt>g</tt>'''reater '''<tt>t</tt>'''han").

Ici, on va afficher le contenu de <tt>i</tt> et lui ajouter 1 tant que <tt>i</tt> sera (<tt>-lt</tt>) plus petit que 100. Remarquez que 100 ne s'affiche pas, car <tt>-lt</tt> est "plus petit", mais pas "plus petit ou égal" (dans ce cas, utilisez <tt>-le</tt> et <tt>-ge</tt> pour "plus grand ou égal").

=== Refaire à un autre endroit la même chose ===

Souvent, vous voudrez refaire ce que vous venez de taper autre part dans votre script. Dans ce cas il est inutile de retaper la même chose, préférez utiliser l'instruction <tt>function</tt> qui permet de réutiliser une portion de script (on dit : une "'''fonction'''"). Voyons un exemple :

<blockquote><tt><nowiki>#!/bin/sh</nowiki></tt> <tt>function addpath ()</tt> <tt>{</tt> <tt> if echo $PATH | grep -v $1 >/dev/null; then</tt> <tt> PATH=$PATH:$1;</tt> <tt> fi;</tt> <tt> PATH=`echo $PATH|sed s/::/:/g`</tt> <tt>}</tt>

<tt>addpath /opt/apps/bin</tt> <tt>addpath /opt/office52/program</tt> <tt>addpath /opt/gnome/bin</tt>

</blockquote>

Au début, nous avons défini une fonction nommée <tt>addpath</tt> dont le but est d'ajouter le premier argument (<tt>$1</tt>) de la fonction <tt>addpath</tt> à la varaible <tt>PATH</tt> si ce premier argument n'est pas déjà présent (<tt>grep -v $1</tt>) dans la variable <tt>PATH</tt>, ainsi que supprimer les chemins vides (<tt>sed s/::/:/g</tt>) de PATH. Ensuite, nous exécutons cette fonction pour trois arguments : /opt/apps/bin, /opt/office52/bin et /opt/gnome/bin.

En fait, une fonction est seulement un script écrit à l'intérieur d'un script. Les fonctions permettent surtout de ne pas multiplier les petits scripts, ainsi que de partager des variables sans se préoccuper de la clause <tt>export</tt> mais cela constitue une utilisation avancée du shell, nous n'irons pas plus loin dans cet article.

Remarque : le mot <tt>function</tt> peut être omis, mais son utilisation facilite la lecture du script.

=== Autres types de répétitions. ===

Il existe d'autres types de répétitions, mais nous ne nous en occuperons pas dans cet article, je vous conseille la lecture, forcément profitable, de la "man page" de bash (<tt>man bash</tt>).

À vous de jouer !

<div class="merci">Cette page est issue de la documentation 'pré-wiki' de Léa a été convertie avec HTML::WikiConverter. Elle fut créée par Frédéric Bonnaud le 29/08/2000.</div>

= Copyright =
Copyright © 29/08/2000, Frédéric Bonnaud
{{CC-BY-NC-SA}}

Lea Linux - Contributions [fr]

Bac à sable

Script shell

Bac à sable