2ccac94cd1
J'ai essayé de refaire les petites modifications qui n'avaient pas pu être commitées avec cvstuteurs.
797 lines
24 KiB
XML
797 lines
24 KiB
XML
<?xml version="1.0" encoding="UTF-8"?>
|
||
<!DOCTYPE html
|
||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||
"tuteurs://DTD/tml.dtd">
|
||
<html>
|
||
<head>
|
||
<title>Boucles</title>
|
||
</head>
|
||
<body>
|
||
|
||
<h1>Structures de contrôle</h1>
|
||
|
||
<p>
|
||
Une fois que vous avez compris qu'un script n'est rien d'autre qu'une
|
||
suite de commandes, vous avez fait un grand pas ; chaque script
|
||
consiste à poser des rails : l'utilisateur n'a plus qu'à les suivre
|
||
(si tout cela ne vous paraît pas évident, consultez la page d'<a
|
||
href="script.html">initiation à la programmation en shell</a>).
|
||
</p>
|
||
|
||
<p>Toutefois, avoir posé les rails ne suffit pas toujours : il peut
|
||
importer de disposer de mécanismes d'aiguillage. Les boucles vous
|
||
permettront de réaliser ces mécanismes d'aiguillage, qui donneront à vos
|
||
scripts souplesse et efficacité. </p>
|
||
|
||
|
||
|
||
<h2>Examiner une condition : <code>if</code> et <code>case</code></h2>
|
||
|
||
<h3>La boucle <code>if</code></h3>
|
||
|
||
<h4>Description</h4>
|
||
|
||
<p>
|
||
Robert le jardinier programme un hachoir en shell, et veut en interdire
|
||
l'accès à tout autre utilisateur que lui-même, afin de protéger le petit
|
||
Émile de ce dangereux instrument. Le programme <code>hachoir</code> se
|
||
pose la question suivante : est-ce que <code>$USER</code> vaut
|
||
« Robert » ?
|
||
</p>
|
||
|
||
<ul>
|
||
<li> Si oui, alors le hachoir doit se mettre en marche ;</li>
|
||
<li> si non, alors le hachoir doit refuser de se mettre en
|
||
marche.</li>
|
||
</ul>
|
||
|
||
<p>
|
||
C'est pour les structures de type « si... alors... ou sinon »,
|
||
la commande <code>if</code> a été faite. Elle est constituée de cinq
|
||
termes, dont trois sont obligatoires :</p>
|
||
|
||
<ol>
|
||
<li> <code>if</code> (si), qui marque la condition à remplir ;
|
||
</li>
|
||
<li> <code>then</code> (alors), qui marque les conséquences si la
|
||
condition est remplie ; </li>
|
||
<li> <code>elif</code> (contraction de <em>else if</em>, qui signifie
|
||
« sinon, si... »), qui est <em>facultatif</em> et marque une
|
||
condition alternative ;</li>
|
||
<li> <code>else</code> (sinon), qui est <em>facultatif</em> et marque le
|
||
comportement à adopter si la condition n'est pas remplie ; </li>
|
||
<li> <code>fi</code> (<code>if</code> à l'envers), qui marque la fin de
|
||
la boucle.</li>
|
||
</ol>
|
||
|
||
<p>On peut donc taper :</p>
|
||
|
||
<pre>if <em>commande</em> ; then <em>commandes</em> ; else <em>commandes</em> ; fi</pre>
|
||
|
||
<p class="continue"> ou bien (car le point et virgule équivaut à un saut
|
||
de ligne) :</p>
|
||
|
||
<pre>if <em>condition</em>
|
||
then <em>commandes</em>
|
||
elif <em>condition</em>
|
||
then <em>commandes</em>
|
||
else <em>commandes</em>
|
||
fi</pre>
|
||
|
||
|
||
<h4>Exemples</h4>
|
||
|
||
<h5>Exemple 1</h5>
|
||
<p>
|
||
Par exemple, pour le hachoir de Robert le jardinier, on aura :
|
||
</p>
|
||
|
||
<pre>
|
||
if test $USER = Robert
|
||
then echo "Le hachoir va se mettre en marche."
|
||
<em>mettre en marche le hachoir</em>
|
||
else echo "Quand tu seras grand, $USER."
|
||
echo "Et fais bien attention en traversant la rue."
|
||
fi</pre>
|
||
|
||
|
||
<h5>Observations</h5>
|
||
|
||
<p> Comme vous pouvez le constater, <strong>à la suite des commandes
|
||
<code>then</code> et <code>else</code>, vous pouvez mettre autant de
|
||
commandes que vous le voulez</strong>. Le shell exécute tout ce qu'il
|
||
trouve jusqu'à la prochaine instruction.</p>
|
||
|
||
<p> Par exemple, si la condition indiquée par <code>if</code> est
|
||
remplie, le shell va exécuter tout ce qui suit <code>then</code> jusqu'à
|
||
ce qu'il trouve l'une de ces instructions :</p>
|
||
|
||
<ul>
|
||
<li> <code>elif</code>,</li>
|
||
<li> <code>else</code> ou</li>
|
||
<li> <code>fi</code>.</li>
|
||
</ul>
|
||
|
||
<h5>Exemple 2</h5>
|
||
|
||
<p>Autre exemple :</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "mon-pwd"
|
||
|
||
if test $PWD = $HOME
|
||
then echo "Vous êtes dans votre répertoire d'accueil."
|
||
elif test $PWD = $HOME/bin
|
||
then echo "Vous êtes dans votre répertoire d'exécutables."
|
||
elif test $PWD = $HOME/bin/solaris
|
||
then echo "Vous êtes dans votre répertoire d'exécutables pour Solaris."
|
||
else echo 'Vous êtes dans un répertoire quelconque, qui n'est ni $HOME,'
|
||
echo 'ni $HOME/bin, ni $HOME/bin/solaris. '"Vous êtes dans $PWD."
|
||
fi
|
||
</pre>
|
||
|
||
<h5>Observations</h5>
|
||
|
||
<ol>
|
||
<li> <strong>Le nombre de <code>elif</code> successifs est
|
||
illimité</strong>, alors qu'il ne peut (et c'est logique) y avoir qu'une
|
||
seule condition <code>if</code>, une seule instruction <code>else</code>
|
||
et une seule instruction <code>fi</code> dans une boucle. </li>
|
||
|
||
<li> Remarquez les dernières lignes du script : <code>$HOME</code>
|
||
est cité dans des guillemets simples, alors que <code>$PWD</code> est
|
||
cité entre guillemets doubles. Par conséquent, $HOME ne sera pas
|
||
interprété (le mot « $HOME » apparaîtra tel quel), tandis que
|
||
<code>$PWD</code> sera interprété (il sera remplacé, par exemple, par
|
||
<code>/home/toto</code>).</li>
|
||
</ol>
|
||
|
||
|
||
|
||
<h3>La boucle <code>case</code></h3>
|
||
|
||
<h4>Quand préférer <code>case</code> à <code>if</code> ?</h4>
|
||
|
||
<p>La boucle <code>if</code> est très pratique, mais devient rapidement
|
||
illisible lorsqu'un aiguillage offre plusieurs sorties, et que l'on doit
|
||
répéter une condition pusieurs fois sous des formes à peine
|
||
différentes. Typiquement, un programme comme celui-ci est pénible à
|
||
écrire, à lire et à débuguer :</p>
|
||
|
||
<pre>
|
||
if test $PWD = $HOME
|
||
then echo "Vous êtes dans votre répertoire d'accueil."
|
||
elif test $PWD = $HOME/bin
|
||
then echo "Vous êtes dans votre répertoire d'exécutables."
|
||
elif test $PWD = $HOME/bin/solaris
|
||
then echo "Vous êtes dans votre répertoire d'exécutables pour Solaris."
|
||
elif test $PWD = $HOME/prive
|
||
then echo "Vous êtes dans votre répertoire privé."
|
||
else echo 'Vous êtes dans un répertoire quelconque, qui n'est ni $HOME,'
|
||
echo 'ni $HOME/bin, ni $HOME/bin/solaris. '"Vous êtes dans $PWD."
|
||
fi
|
||
</pre>
|
||
|
||
<p>Pourquoi ce programme est-il pénible à écrire, à lire et à
|
||
débuguer ?</p>
|
||
|
||
<ol>
|
||
|
||
<li> parce qu'on a du mal, en le survolant simplement, à saisir
|
||
immédiatement son enjeu ; </li>
|
||
|
||
<li> parce qu'il y a une redondance de la séquence « <code>test
|
||
$PWD =</code> » ; et qui dit redondance dit possibilité de
|
||
faute de frappe – erreur particulièrement difficile à repérer
|
||
à l'œil nu ;</li>
|
||
|
||
<li> parce que les différentes conditions ne sont pas mises sur le même
|
||
plan (<code>if</code> n'est pas, dans la boucle, sur le même plan que
|
||
<code>elif</code>, alors que logiquement les deux instructions le
|
||
sont), ce qui nuit à la lisibilité.</li>
|
||
|
||
</ol>
|
||
|
||
<p>La boucle <code>case</code> entend remédier à ces inconvénients. Il
|
||
s'agit tout simplement de la simplification d'un usage fréquent de la
|
||
structure <code>if</code>. On peut récrire le programme suivant avec
|
||
<code>case</code> :</p>
|
||
|
||
<pre>
|
||
case "$PWD" in
|
||
"$HOME") echo "Vous êtes dans votre répertoire d'accueil.";;
|
||
"$HOME/bin") echo "Vous êtes dans votre répertoire d'exécutables.";;
|
||
"$HOME/bin/solaris") echo "Vous êtes dans votre répertoire d'exécutables pour Solaris.";;
|
||
"$HOME/prive") echo "Vous êtes dans votre répertoire privé.";;
|
||
"*") echo 'Vous êtes dans un répertoire quelconque, qui n'est ni $HOME,'
|
||
echo 'ni $HOME/bin, ni $HOME/bin/solaris. '"Vous êtes dans $PWD.";;
|
||
esac
|
||
</pre>
|
||
|
||
<p>Le gain de lisibilité est flagrant (si si, c'est flagrant, je vous
|
||
assure) :</p>
|
||
|
||
<ol>
|
||
<li> la structure de la boucle et son enjeu sont
|
||
transparents ;</li>
|
||
|
||
<li> la variable que l'on teste n'est citée qu'une seule fois, au lieu
|
||
d'être répétée à chaque instruction <code>elif</code> ;</li>
|
||
|
||
<li>les valeurs possibles sont citées à la suite, et toutes sur le même
|
||
plan.</li>
|
||
</ol>
|
||
|
||
<h4>Syntaxe de <code>case</code></h4>
|
||
|
||
<p>La boucle <code>case</code> adopte la syntaxe suivante :</p>
|
||
|
||
<pre>
|
||
case <em>chaîne</em> in
|
||
<em>motif</em>) <em>commandes</em> ;;
|
||
<em>motif</em>) <em>commandes</em> ;;
|
||
esac
|
||
</pre>
|
||
|
||
<p>
|
||
La boucle <code>case</code> commence par évaluer la
|
||
<em>chaîne</em>. Ensuite, elle va lire chaque <em>motif</em>. Enfin, et
|
||
dès qu'une <em>chaîne</em> correspond au <em>motif</em>, elle exécute
|
||
les <em>commandes</em> appropriées. En anglais, <em>case</em> signifie
|
||
« cas » ; cette structure de contrôle permet en effet de
|
||
réagir adéquatement aux différents « cas de figure »
|
||
possibles.</p>
|
||
|
||
<p>
|
||
Vous observerez que :
|
||
</p>
|
||
|
||
<ul>
|
||
<li> le <em>motif</em> est séparé des commandes par une parenthèse
|
||
fermante (qui n'est ouverte nulle part !) ;</li>
|
||
|
||
<li> la série des <em>commandes</em> est close par deux points et
|
||
virgules successifs (« ;; ») ; </li>
|
||
|
||
<li> la boucle <code>case</code> est close par l'instruction
|
||
<code>esac</code>, qui n'est autre que le mot <code>case</code> à
|
||
l'envers (de même que la boucle <code>if</code> est terminée par
|
||
l'instruction <code>fi</code>).</li>
|
||
</ul>
|
||
|
||
<p>
|
||
Un <em>motif</em> (<em>pattern</em>) est un mot contenant éventuellement
|
||
les constructions <code>*</code>, <code>?</code>, <code>[a-d]</code>,
|
||
avec la même signification que pour les raccourcis dans les noms de
|
||
fichiers (les <em>jokers</em>). Exemple :
|
||
</p>
|
||
|
||
<pre>
|
||
case $var in
|
||
[0-9]*) echo "$var est un nombre.";;
|
||
[a-zA-Z]*) echo "$var est un mot.";;
|
||
*) echo "$var n'est ni un nombre ni un mot.";;
|
||
esac</pre>
|
||
|
||
|
||
<h4>L'aiguillage commun à plusieurs motifs</h4>
|
||
|
||
<p>Que faire si je veux aiguiller plusieurs motifs différents de la même
|
||
façon ? Le premier réflexe est de répéter, presque à l'identique,
|
||
des lignes, de la façon suivante :</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "canards"
|
||
|
||
echo "Quel est ton nom ?"
|
||
read nom
|
||
|
||
case $nom in <strong>
|
||
"Riri") echo "Ton oncle s'appelle Donald, Riri.";;
|
||
"Fifi") echo "Ton oncle s'appelle Donald, Fifi.";;
|
||
"Loulou") echo "Ton oncle s'appelle Donald, Loulou.";;
|
||
</strong>"*") echo "Tu n'es pas un neveu de Donald.";;
|
||
esac
|
||
</pre>
|
||
|
||
<p>
|
||
Mais <strong>il n'est jamais bon de répéter manuellement des lignes de
|
||
programmation</strong>, car c'est générateur de fautes. Il faut toujours
|
||
chercher des raccourcis, et ne se répéter qu'en dernier recours. On
|
||
utilisera donc le caractère « | », qui permet de mettre sur le
|
||
même plan différents motifs. On pourra donc écrire :
|
||
</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "canards"
|
||
|
||
echo "Quel est ton nom ?"
|
||
read nom
|
||
|
||
case $nom in
|
||
<strong>"Riri"|"Fifi"|"Loulou"</strong>) echo "Ton oncle s'appelle Donald, <strong>$nom</strong>.";;
|
||
"*") echo "Tu n'es pas un neveu de Donald.";;
|
||
esac
|
||
</pre>
|
||
|
||
<p class="continue">On gagne ainsi en concision, et on évite bien des
|
||
fautes d'inattention, qui sont particulièrement coriaces à débuguer.
|
||
</p>
|
||
|
||
<div class="attention">
|
||
<p>La boucle <code>case</code> exécute les commandes correspondant au
|
||
<strong>premier</strong> motif correct, et ne parcourt pas les motifs
|
||
suivants si elle en a trouvé un. Par conséquent, <strong>si le dernier
|
||
motif est « * », cela revient à l'instruction
|
||
<code>else</code> dans la boucle <code>if</code></strong>.</p>
|
||
</div>
|
||
|
||
|
||
|
||
<h2>Répéter une procédure : <code>while</code>, <code>until</code>
|
||
et <code>for</code></h2>
|
||
|
||
<p>Les structures <code>if</code> et <code>case</code> sont des
|
||
structures d'aiguillage ; les structures <code>while</code>,
|
||
<code>until</code> et <code>for</code> sont proprement des
|
||
boucles. C'est-à-dire qu'elles soumettent à une condition déterminée la
|
||
répétition (ou non) d'une suite de commandes.</p>
|
||
|
||
|
||
|
||
<h3>La boucle <code>while</code></h3>
|
||
|
||
<p>
|
||
La boucle <code>while</code> exécute les <em>commandes</em> de manière
|
||
répétée tant que la première <em>commande</em> réussit ; en
|
||
anglais, <em>while</em> signifie « tant que ».</p>
|
||
|
||
|
||
<h4>Syntaxe de <code>while</code></h4>
|
||
|
||
<p>La boucle <code>while</code> adopte la syntaxe suivante :</p>
|
||
|
||
<pre>while <em>condition</em>
|
||
do <em>commandes</em>
|
||
done</pre>
|
||
|
||
<p><strong>Après l'instruction <code>do</code>, vous pouvez mettre
|
||
autant de commandes que vous le désirez</strong>, suivies de retours
|
||
chariot ou bien de points et virgules (« ; »). Le shell
|
||
exécutera tout ce qu'il trouve, jusqu'à ce qu'il tombe sur l'instruction
|
||
<code>done</code>. </p>
|
||
|
||
|
||
<h4>Exemple</h4>
|
||
|
||
<pre>
|
||
echo "Tapez le mot de passe :"
|
||
read password
|
||
|
||
while test "$password" != <em>mot de passe correct</em>
|
||
do echo "Mot de passe incorrect."
|
||
echo "Tapez le mot de passe"
|
||
read password
|
||
done
|
||
|
||
echo "Mot de passe correct."
|
||
echo "Bienvenue sur les ordinateurs secrets du Pentagone."
|
||
</pre>
|
||
|
||
<p class="continue"> Les lignes qui suivent la boucle <code>while</code>
|
||
seront exécutées si, et seulement si, la condition est remplie,
|
||
c'est-à-dire si l'utilisateur tape le bon mot de passe. (En pratique, il
|
||
est très fortement déconseillé de taper un mot de passe en clair dans un
|
||
script, car rien n'est plus facile que de l'éditer !...).
|
||
</p>
|
||
|
||
<h4>Un usage concret de <code>while</code></h4>
|
||
|
||
<p>Supposons que vous vouliez créer cinquante fichiers sous la forme
|
||
<code>fichier1</code>, <code>fichier2</code>, <code>fichier3</code>,
|
||
etc. Un petit script vous fera ça plus vite que cinquante lignes de
|
||
commande. </p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "50fichiers"
|
||
|
||
numero=1
|
||
|
||
while test $numero != 51
|
||
do
|
||
# la commande "touch" permet de créer un fichier vide :
|
||
touch fichier"$numero"
|
||
|
||
# cette commande ajoute 1 à la variable "numero" :
|
||
numero=$(($numero + 1))
|
||
done
|
||
</pre>
|
||
|
||
<p class="continue">Avec ce script, la variable <code>numero</code> est
|
||
d'abord créée avec la valeur 1. Ensuite, le shell examine si la
|
||
valeur de <code>numero</code> est différente de 51 ; c'est le
|
||
cas. Par conséquent, le shell exécute les commandes suivantes : il
|
||
crée un fichier <code>fichier1</code>, puis ajoute 1 à la variable
|
||
<code>numero</code>, qui vaut donc 2. Et c'est reparti pour un
|
||
tour ! Le shell examine si la valeur de <code>numero</code>,
|
||
c'est-à-dire 2, est différente de 51, etc.
|
||
</p>
|
||
|
||
<p>Petit conseil pour faire les choses le plus proprement
|
||
possible : dans le script qui précède,
|
||
remplacez « 51 » par une variable : le script sera
|
||
beaucoup plus lisible. Exemple :</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "50fichiers"
|
||
|
||
numero=1
|
||
<strong>limite=51</strong>
|
||
|
||
while test $numero != <strong>$limite</strong>
|
||
do
|
||
# la commande "touch" permet de créer un fichier vide :
|
||
touch fichier"$numero"
|
||
|
||
# cette commande ajoute 1 à la variable "numero" :
|
||
numero=$(($numero + 1))
|
||
done
|
||
</pre>
|
||
|
||
|
||
|
||
<h3>La boucle <code>until</code></h3>
|
||
|
||
<p>
|
||
<em>Until</em> signifie « jusqu'à ce que » en anglais. Cette
|
||
boucle est le pendant de la boucle <code>while</code>, à ceci près que
|
||
<strong>la <em>condition</em> ne détermine pas la cause de la répétition
|
||
de la boucle, mais celle de son interruption</strong>.</p>
|
||
|
||
<h4>Syntaxe de <code>until</code></h4>
|
||
|
||
<pre>
|
||
until <em>condition</em>
|
||
do <em>commandes</em>
|
||
done
|
||
</pre>
|
||
|
||
<h4>Exemple</h4>
|
||
|
||
<p> On aura ainsi : </p>
|
||
|
||
<pre>
|
||
echo "Tapez le mot de passe :"
|
||
read password
|
||
|
||
<strong>until test $password = <em>mot de passe correct</em></strong>
|
||
do echo "Mot de passe incorrect."
|
||
echo "Tapez le mot de passe"
|
||
read password
|
||
done
|
||
|
||
echo "Mot de passe correct."
|
||
echo "Bienvenue sur les ordinateurs secrets de la NASA."
|
||
</pre>
|
||
|
||
|
||
<p> Il revient en effet au même de répéter une suite de commandes
|
||
« <em>tant que</em> le mot de passe est
|
||
<strong>incorrect</strong> » ou bien « <em>jusqu'à ce que</em>
|
||
le mot de passe soit <strong>correct</strong> », car un mot de
|
||
passe déterminé ne peut être que correct ou incorrect.
|
||
</p>
|
||
|
||
|
||
<h4><code>while</code> ou <code>until</code> ?</h4>
|
||
|
||
<p>Vous allez donc me demander que préférer entre <code>while</code> et
|
||
<code>until</code>, si les deux sont si souvent équivalentes ? Eh
|
||
bien, celle dont la condition sera la plus facile à écrire, à lire et à
|
||
débuguer. Si, comme dans notre exemple, elles sont aussi simples
|
||
l'une que l'autre, choisissez votre préférée ou prenez-en une au hasard.
|
||
</p>
|
||
|
||
|
||
<h3>La boucle <code>for</code></h3>
|
||
|
||
<p>
|
||
La boucle <code>for</code> affecte successivement à une variable chaque
|
||
chaîne de caractères trouvée dans une <em>liste de chaînes</em>, et
|
||
exécute les <em>commandes</em> une fois pour chaque chaîne.
|
||
</p>
|
||
|
||
<h4>Syntaxe de <code>for</code></h4>
|
||
|
||
<pre>for <em>var</em> in <em>liste de chaînes</em>
|
||
do <em>commandes</em>
|
||
done</pre>
|
||
|
||
|
||
|
||
<h4>Exemple</h4>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "liste"
|
||
|
||
for element in *
|
||
do echo "$element"
|
||
done
|
||
</pre>
|
||
|
||
<p class="continue">
|
||
affiche les noms de tous les fichiers du répertoire courant, un par ligne.
|
||
</p>
|
||
|
||
<p>Concrètement, le shell va prendre la liste des chaînes, en
|
||
l'occurrence « * », c'est-à-dire tous les fichiers et
|
||
répertoires du répertoire courant. À chacun de ces éléments, il va
|
||
attribuer la variable <code>element</code>, puis exécuter les commandes
|
||
spécifiées, en l'occurrence <code>echo
|
||
"$element"</code>. Ainsi, si dans mon répertoire j'ai les
|
||
fichiers <code>a</code>, <code>b</code> et <code>c</code>, le shell va
|
||
exécuter successivement <code>echo "a"</code>, <code>echo
|
||
"b"</code> et <code>echo "c"</code>. </p>
|
||
|
||
|
||
<h4>Usage de <code>for</code></h4>
|
||
<p>
|
||
Comme <code>while</code> et <code>until</code>, <code>for</code> est une
|
||
boucle au sens propre. Mais il y a une différence notable entre ces deux
|
||
groupes de boucle : <code>while</code> et <code>until</code> sont
|
||
plus appropriés à la répétition <em>à l'identique</em> d'une séquence de
|
||
commandes, tandis que <strong><code>for</code> convient particulièrement
|
||
aux répétitions soumises à de légères variations</strong>.
|
||
</p>
|
||
|
||
<p>
|
||
Prenons par exemple le script qui permettait, avec <code>while</code>,
|
||
de créer 50 fichiers rapidement. La numération des passages par la
|
||
boucle était assez pénible, et éclatée en trois endroits :
|
||
</p>
|
||
|
||
<ol>
|
||
<li> avant la boucle : l'affectation de la valeur 1 à la
|
||
variable <code>numero</code> (et, éventuellement, de la valeur 51 à
|
||
la variable <code>limite</code>) ;</li>
|
||
|
||
<li> au début de la boucle, la condition
|
||
<code>test $numero != 51</code> ou
|
||
<code>test $numero != $limite</code> ;</li>
|
||
|
||
<li> à la fin de la boucle, l'incrémentation (c'est-à-dire
|
||
l'augmentation régulière) de la variable <code>numero</code>, avec la
|
||
ligne <code>numero=$(($numero + 1))</code>.</li>
|
||
</ol>
|
||
|
||
<p>
|
||
Pourquoi dire en trois fois ce qui, dans les langages naturels
|
||
(c'est-à-dire humains), s'énonce en une seule : « répéter
|
||
<em>n</em> fois cette séquence de commandes » ? La boucle
|
||
<code>for</code> se révèle alors indispensable :
|
||
</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "50fichiers-for"
|
||
|
||
# la commande "seq <em>a</em> <em>b</em>" compte de <em>a</em> à <em>b</em>
|
||
for numero in `seq 1 50`
|
||
do touch fichier"$numero"
|
||
done
|
||
</pre>
|
||
|
||
<p class="continue">Avouez que le script est beaucoup plus simple de
|
||
cette manière !</p>
|
||
|
||
|
||
|
||
<h2>Définir une variable : <code>select</code></h2>
|
||
|
||
<p>
|
||
Il est parfois utile de donner à l'utilisateur du script des formulaires
|
||
sous forme de <strong>questions à choix multiples</strong>.</p>
|
||
|
||
<p> Par exemple, je suis sociologue et je veux dresser des statistiques
|
||
sur les opinions d'un échantillon représentatif de normaliens :
|
||
sont-ils favorables ou défavorables à la destruction du NIR (Nouvel
|
||
Immeuble Rataud) et à la reconstruction du VIR (Vieil Immeuble
|
||
Rataud, a.k.a. Pavillon) ?
|
||
</p>
|
||
|
||
<p>
|
||
Spontanément, je fais le script suivant :
|
||
</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "vote-nir"
|
||
|
||
echo "Êtes-vous favorable au remplacement du NIR par le VIR ?"
|
||
echo "(Répondez « pour » ou « contre »)"
|
||
read opinion
|
||
|
||
# M'envoyer le résultat par mail
|
||
echo "$opinion" | mail bourdieu
|
||
</pre>
|
||
|
||
<p>Seulement voilà, de nombreuses personnes vont faire des fautes de
|
||
frappe, et taper « poru » au lieu de « pour »,
|
||
« cnotre » au lieu de « contre »,
|
||
etc. Résultat : au lieu de laisser d'autres scripts traiter
|
||
automatiquement les résultats des statistiques qui me sont envoyés par
|
||
courriel, je devrai tout regarder à la main et cocher moi-même les
|
||
résultats pour ne pas en oublier. Dans ce cas, autant faire un sondage
|
||
classique à la sortie du Pot !</p>
|
||
|
||
<p>Heureusement, il existe une parade : la boucle
|
||
<code>select</code>. </p>
|
||
|
||
<h4>Syntaxe de <code>select</code></h4>
|
||
|
||
<pre>
|
||
select <em>variable</em> in <em>valeurs possibles</em>
|
||
do <em>commandes</em>
|
||
done
|
||
</pre>
|
||
|
||
|
||
<h4>Questions à choix multiples</h4>
|
||
|
||
<p>
|
||
Voici le script de notre sociologue :
|
||
</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "vote-nir"
|
||
|
||
echo "Êtes-vous favorable au remplacement du NIR par le VIR ?"
|
||
select opinion in Pour Contre
|
||
do break
|
||
done
|
||
|
||
# M'envoyer le résultat par mail
|
||
echo "$opinion" | mail bourdieu
|
||
</pre>
|
||
|
||
<p class="continue">
|
||
Les utilisateurs verront alors :
|
||
</p>
|
||
|
||
<pre>
|
||
Êtes-vous favorable au remplacement du NIR par le VIR ?
|
||
1) Pour
|
||
2) Contre
|
||
</pre>
|
||
|
||
<p class="continue">
|
||
Ils devront alors taper 1 ou 2, selon leur opinion.
|
||
</p>
|
||
|
||
<p>Vous avez remarqué que l'instruction <code>do</code> est suivie de la
|
||
commande <code>break</code>. Celle-ci indique de sortir de la boucle
|
||
<code>select</code>. Sans <code>break</code>, <code>select</code> est en
|
||
effet une boucle, comme <code>while</code>, <code>until</code> et
|
||
<code>for</code>. Nous allons voir pourquoi.</p>
|
||
|
||
|
||
<h4>Utiliser <code>select</code> comme boucle</h4>
|
||
<p>
|
||
Par défaut, <code>select</code> se comporte comme une boucle. Observons
|
||
le comportement du script suivant :
|
||
</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "piege"
|
||
|
||
echo "Si tu arrives à sortir de ce script, je te donne 30 euros."
|
||
select issue in "Sortir" "Quitter"
|
||
# la commande "continue" est une commande vide : elle ne fait rien de spécial
|
||
do continue
|
||
done
|
||
</pre>
|
||
|
||
<p class="continue">Essayez maintenant d'exécuter ce script :</p>
|
||
|
||
<pre>
|
||
Si tu arrives à sortir de ce script, je te donne 30 euros.
|
||
1) Sortir
|
||
2) Quitter
|
||
#? <em>1</em>
|
||
#? <em>2</em>
|
||
#? <em>1</em>
|
||
#? <em>2</em>
|
||
#? <em>1</em>
|
||
<em>(etc.)</em>
|
||
</pre>
|
||
|
||
<p>Ce comportement est parfois utile, par exemple si vous programmez un
|
||
petit jeu, ou autre. Ou encore, pour prévenir les réponses non
|
||
valides. Exemple :</p>
|
||
|
||
<pre>
|
||
#!/bin/sh
|
||
# Fichier "vote-nir"
|
||
|
||
echo "Êtes-vous favorable au remplacement du NIR par le VIR ?"
|
||
select opinion in Pour Contre
|
||
do
|
||
case $opinion in
|
||
# Laisser passer ceux qui répondent correctement à la question
|
||
"Pour"|"Contre") break;;
|
||
|
||
# Au cas où des zozos tapent sur autre chose que 1 ou 2
|
||
"*") continue;;
|
||
esac
|
||
done
|
||
|
||
# M'envoyer le résultat par mail
|
||
echo "$opinion" | mail bourdieu
|
||
</pre>
|
||
|
||
<p class="continue">Grâce à cela, si un normalien tape une réponse
|
||
invalide, <code>select</code> attend qu'il tape quelque chose de
|
||
correct ; s'il tape quelque chose de correct, la réponse est
|
||
envoyée au sociologue.</p>
|
||
|
||
<div class="attention">
|
||
<p>
|
||
Vous aurez remarqué au passage que <strong>l'on peut sans problème
|
||
imbriquer des structures de contrôle les unes dans les autres</strong>.
|
||
</p>
|
||
</div>
|
||
|
||
|
||
<h2><a name="retour">Code de retour</a></h2>
|
||
|
||
<p>
|
||
On remarque que la condition des commandes <code>if</code> et
|
||
<code>while</code> est une commande. Chaque commande renvoie un code de
|
||
retour (qui est ignoré en utilisation normale). Si le code est 0, la
|
||
commande a réussi ; sinon, la commande a échoué. Par exemple, le
|
||
compilateur <code>cc</code> renvoie un code d'erreur non nul si le
|
||
fichier compilé contient des erreurs, ou s'il n'existe pas.
|
||
</p>
|
||
|
||
<p>
|
||
Les commandes <code>if</code> et <code>while</code> considèrent donc le
|
||
code de retour 0 comme « vrai », et tout autre code comme
|
||
« faux ».
|
||
</p>
|
||
|
||
<p>
|
||
Il existe une commande <code>test</code>, qui évalue des expressions
|
||
booléennes (c'est-à-dire dont la valeur ne peut être que vraie ou
|
||
fausse) passées en argument, et renvoie un code de retour en fonction du
|
||
résultat. Elle est bien utile pour les scripts. Exemple :
|
||
</p>
|
||
|
||
<pre>
|
||
if test $var = foo
|
||
then echo 'La variable vaut foo'
|
||
else echo 'La variable ne vaut pas foo'
|
||
fi</pre>
|
||
|
||
<p>
|
||
Pour en savoir plus sur les opérateurs de test, consultez la page <a
|
||
href="test.html">tests et calculs arithmétiques</a> Ou bien vous pouvez
|
||
revenir à la <a href="index.html">page centrale sur le shell</a>, d'où
|
||
vous pourrez vous orienter vers d'autres parties du cours.
|
||
</p>
|
||
|
||
|
||
<div class="metainformation">
|
||
Auteur : Baptiste Mélès.
|
||
<date value="from git" />
|
||
</div>
|
||
|
||
</body>
|
||
</html>
|