2009-09-20 12:34:28 +02:00
|
|
|
|
<?xml version="1.0" encoding="UTF-8"?>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<!DOCTYPE html
|
|
|
|
|
|
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
|
|
|
|
|
"tuteurs://DTD/tml.dtd">
|
|
|
|
|
|
<html>
|
|
|
|
|
|
<head>
|
|
|
|
|
|
<title>Boucles</title>
|
|
|
|
|
|
</head>
|
|
|
|
|
|
<body>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h1>Structures de contrôle</h1>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<p>
|
|
|
|
|
|
Une fois que vous avez compris qu'un script n'est rien d'autre qu'une
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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>).
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h2>Examiner une condition : <code>if</code> et <code>case</code></h2>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<h3>La boucle <code>if</code></h3>
|
|
|
|
|
|
|
|
|
|
|
|
<h4>Description</h4>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
|
|
|
|
|
Robert le jardinier programme un hachoir en shell, et veut en interdire
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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 » ?
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<ul>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li> Si oui, alors le hachoir doit se mettre en marche ;</li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<li> si non, alors le hachoir doit refuser de se mettre en
|
|
|
|
|
|
marche.</li>
|
|
|
|
|
|
</ul>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<ol>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li> <code>if</code> (si), qui marque la condition à remplir ;
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</li>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li> <code>then</code> (alors), qui marque les conséquences si la
|
|
|
|
|
|
condition est remplie ; </li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<li> <code>elif</code> (contraction de <em>else if</em>, qui signifie
|
2009-09-20 12:27:14 +02:00
|
|
|
|
« sinon, si... »), qui est <em>facultatif</em> et marque une
|
|
|
|
|
|
condition alternative ;</li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<li> <code>else</code> (sinon), qui est <em>facultatif</em> et marque le
|
2009-09-20 12:27:14 +02:00
|
|
|
|
comportement à adopter si la condition n'est pas remplie ; </li>
|
|
|
|
|
|
<li> <code>fi</code> (<code>if</code> à l'envers), qui marque la fin de
|
2005-06-03 15:56:21 +02:00
|
|
|
|
la boucle.</li>
|
|
|
|
|
|
</ol>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>On peut donc taper :</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>if <em>commande</em> ; then <em>commandes</em> ; else <em>commandes</em> ; fi</pre>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p class="continue"> ou bien (car le point et virgule équivaut à un saut
|
|
|
|
|
|
de ligne) :</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<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>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Par exemple, pour le hachoir de Robert le jardinier, on aura :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</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>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p> Comme vous pouvez le constater, <strong>à la suite des commandes
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<code>then</code> et <code>else</code>, vous pouvez mettre autant de
|
2009-09-20 12:27:14 +02:00
|
|
|
|
commandes que vous le voulez</strong>. Le shell exécute tout ce qu'il
|
|
|
|
|
|
trouve jusqu'à la prochaine instruction.</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<ul>
|
|
|
|
|
|
<li> <code>elif</code>,</li>
|
|
|
|
|
|
<li> <code>else</code> ou</li>
|
|
|
|
|
|
<li> <code>fi</code>.</li>
|
|
|
|
|
|
</ul>
|
|
|
|
|
|
|
|
|
|
|
|
<h5>Exemple 2</h5>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>Autre exemple :</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "mon-pwd"
|
|
|
|
|
|
|
|
|
|
|
|
if test $PWD = $HOME
|
2009-09-20 12:27:14 +02:00
|
|
|
|
then echo "Vous êtes dans votre répertoire d'accueil."
|
2005-06-03 15:56:21 +02:00
|
|
|
|
elif test $PWD = $HOME/bin
|
2009-09-20 12:27:14 +02:00
|
|
|
|
then echo "Vous êtes dans votre répertoire d'exécutables."
|
2005-06-03 15:56:21 +02:00
|
|
|
|
elif test $PWD = $HOME/bin/solaris
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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."
|
2005-06-03 15:56:21 +02:00
|
|
|
|
fi
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
<h5>Observations</h5>
|
|
|
|
|
|
|
|
|
|
|
|
<ol>
|
|
|
|
|
|
<li> <strong>Le nombre de <code>elif</code> successifs est
|
2009-09-20 12:27:14 +02:00
|
|
|
|
illimité</strong>, alors qu'il ne peut (et c'est logique) y avoir qu'une
|
2005-06-03 15:56:21 +02:00
|
|
|
|
seule condition <code>if</code>, une seule instruction <code>else</code>
|
|
|
|
|
|
et une seule instruction <code>fi</code> dans une boucle. </li>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<code>/home/toto</code>).</li>
|
|
|
|
|
|
</ol>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<h3>La boucle <code>case</code></h3>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h4>Quand préférer <code>case</code> à <code>if</code> ?</h4>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>La boucle <code>if</code> est très pratique, mais devient rapidement
|
2005-06-03 15:56:21 +02:00
|
|
|
|
illisible lorsqu'un aiguillage offre plusieurs sorties, et que l'on doit
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
if test $PWD = $HOME
|
2009-09-20 12:27:14 +02:00
|
|
|
|
then echo "Vous êtes dans votre répertoire d'accueil."
|
2005-06-03 15:56:21 +02:00
|
|
|
|
elif test $PWD = $HOME/bin
|
2009-09-20 12:27:14 +02:00
|
|
|
|
then echo "Vous êtes dans votre répertoire d'exécutables."
|
2005-06-03 15:56:21 +02:00
|
|
|
|
elif test $PWD = $HOME/bin/solaris
|
2009-09-20 12:27:14 +02:00
|
|
|
|
then echo "Vous êtes dans votre répertoire d'exécutables pour Solaris."
|
2005-06-03 15:56:21 +02:00
|
|
|
|
elif test $PWD = $HOME/prive
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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."
|
2005-06-03 15:56:21 +02:00
|
|
|
|
fi
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>Pourquoi ce programme est-il pénible à écrire, à lire et à
|
|
|
|
|
|
débuguer ?</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<ol>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li> parce qu'on a du mal, en le survolant simplement, à saisir
|
|
|
|
|
|
immédiatement son enjeu ; </li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<code>elif</code>, alors que logiquement les deux instructions le
|
2009-09-20 12:27:14 +02:00
|
|
|
|
sont), ce qui nuit à la lisibilité.</li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
</ol>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
case "$PWD" in
|
2009-09-20 12:27:14 +02:00
|
|
|
|
"$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.";;
|
2005-06-03 15:56:21 +02:00
|
|
|
|
esac
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>Le gain de lisibilité est flagrant (si si, c'est flagrant, je vous
|
|
|
|
|
|
assure) :</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<ol>
|
|
|
|
|
|
<li> la structure de la boucle et son enjeu sont
|
2009-09-20 12:27:14 +02:00
|
|
|
|
transparents ;</li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li>les valeurs possibles sont citées à la suite, et toutes sur le même
|
2005-06-03 15:56:21 +02:00
|
|
|
|
plan.</li>
|
|
|
|
|
|
</ol>
|
|
|
|
|
|
|
|
|
|
|
|
<h4>Syntaxe de <code>case</code></h4>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>La boucle <code>case</code> adopte la syntaxe suivante :</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
case <em>chaîne</em> in
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<em>motif</em>) <em>commandes</em> ;;
|
|
|
|
|
|
<em>motif</em>) <em>commandes</em> ;;
|
|
|
|
|
|
esac
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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 »
|
2005-06-03 15:56:21 +02:00
|
|
|
|
possibles.</p>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Vous observerez que :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<ul>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li> le <em>motif</em> est séparé des commandes par une parenthèse
|
|
|
|
|
|
fermante (qui n'est ouverte nulle part !) ;</li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li> la série des <em>commandes</em> est close par deux points et
|
|
|
|
|
|
virgules successifs (« ;; ») ; </li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<li> la boucle <code>case</code> est close par l'instruction
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</ul>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Un <em>motif</em> (<em>pattern</em>) est un mot contenant éventuellement
|
2005-06-03 15:56:21 +02:00
|
|
|
|
les constructions <code>*</code>, <code>?</code>, <code>[a-d]</code>,
|
2009-09-20 12:27:14 +02:00
|
|
|
|
avec la même signification que pour les raccourcis dans les noms de
|
|
|
|
|
|
fichiers (les <em>jokers</em>). Exemple :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</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>
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h4>L'aiguillage commun à plusieurs motifs</h4>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "canards"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Quel est ton nom ?"
|
2005-06-03 15:56:21 +02:00
|
|
|
|
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>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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 :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "canards"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Quel est ton nom ?"
|
2005-06-03 15:56:21 +02:00
|
|
|
|
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>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p class="continue">On gagne ainsi en concision, et on évite bien des
|
|
|
|
|
|
fautes d'inattention, qui sont particulièrement coriaces à débuguer.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<div class="attention">
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>La boucle <code>case</code> exécute les commandes correspondant au
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<strong>premier</strong> motif correct, et ne parcourt pas les motifs
|
2009-09-20 12:27:14 +02:00
|
|
|
|
suivants si elle en a trouvé un. Par conséquent, <strong>si le dernier
|
|
|
|
|
|
motif est « * », cela revient à l'instruction
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<code>else</code> dans la boucle <code>if</code></strong>.</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h2>Répéter une procédure : <code>while</code>, <code>until</code>
|
|
|
|
|
|
et <code>for</code></h2>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<p>Les structures <code>if</code> et <code>case</code> sont des
|
2009-09-20 12:27:14 +02:00
|
|
|
|
structures d'aiguillage ; les structures <code>while</code>,
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<code>until</code> et <code>for</code> sont proprement des
|
2009-09-20 12:27:14 +02:00
|
|
|
|
boucles. C'est-à-dire qu'elles soumettent à une condition déterminée la
|
|
|
|
|
|
répétition (ou non) d'une suite de commandes.</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<h3>La boucle <code>while</code></h3>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<h4>Syntaxe de <code>while</code></h4>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>La boucle <code>while</code> adopte la syntaxe suivante :</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>while <em>condition</em>
|
|
|
|
|
|
do <em>commandes</em>
|
|
|
|
|
|
done</pre>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<code>done</code>. </p>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<h4>Exemple</h4>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Tapez le mot de passe :"
|
2005-06-03 15:56:21 +02:00
|
|
|
|
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>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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 !...).
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<h4>Un usage concret de <code>while</code></h4>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>Supposons que vous vouliez créer cinquante fichiers sous la forme
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<code>fichier1</code>, <code>fichier2</code>, <code>fichier3</code>,
|
2009-09-20 12:27:14 +02:00
|
|
|
|
etc. Un petit script vous fera ça plus vite que cinquante lignes de
|
2005-06-03 15:56:21 +02:00
|
|
|
|
commande. </p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "50fichiers"
|
|
|
|
|
|
|
|
|
|
|
|
numero=1
|
|
|
|
|
|
|
|
|
|
|
|
while test $numero != 51
|
|
|
|
|
|
do
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# la commande "touch" permet de créer un fichier vide :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
touch fichier"$numero"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# cette commande ajoute 1 à la variable "numero" :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
numero=$(($numero + 1))
|
|
|
|
|
|
done
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
<p class="continue">Avec ce script, la variable <code>numero</code> est
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<p>Petit conseil pour faire les choses le plus proprement
|
2009-09-20 12:27:14 +02:00
|
|
|
|
possible : dans le script qui précède,
|
|
|
|
|
|
remplacez « 51 » par une variable : le script sera
|
|
|
|
|
|
beaucoup plus lisible. Exemple :</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "50fichiers"
|
|
|
|
|
|
|
|
|
|
|
|
numero=1
|
|
|
|
|
|
<strong>limite=51</strong>
|
|
|
|
|
|
|
|
|
|
|
|
while test $numero != <strong>$limite</strong>
|
|
|
|
|
|
do
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# la commande "touch" permet de créer un fichier vide :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
touch fichier"$numero"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# cette commande ajoute 1 à la variable "numero" :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
numero=$(($numero + 1))
|
|
|
|
|
|
done
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<h3>La boucle <code>until</code></h3>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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
|
2005-06-03 15:56:21 +02:00
|
|
|
|
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>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p> On aura ainsi : </p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Tapez le mot de passe :"
|
2005-06-03 15:56:21 +02:00
|
|
|
|
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>
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h4><code>while</code> ou <code>until</code> ?</h4>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<h3>La boucle <code>for</code></h3>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
|
|
|
|
|
La boucle <code>for</code> affecte successivement une variable chaque
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<h4>Syntaxe de <code>for</code></h4>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<pre>for <em>var</em> in <em>liste de chaînes</em>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
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">
|
2009-09-20 12:27:14 +02:00
|
|
|
|
affiche les noms de tous les fichiers du répertoire courant, un par ligne.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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
|
2005-06-03 15:56:21 +02:00
|
|
|
|
fichiers <code>a</code>, <code>b</code> et <code>c</code>, le shell va
|
2009-09-20 12:27:14 +02:00
|
|
|
|
exécuter successivement <code>echo "a"</code>, <code>echo
|
2005-06-03 15:56:21 +02:00
|
|
|
|
"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
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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>.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
|
|
|
|
|
Prenons par exemple le script qui permettait, avec <code>while</code>,
|
2009-09-20 12:27:14 +02:00
|
|
|
|
de créer 50 fichiers rapidement. La numération des passages par la
|
|
|
|
|
|
boucle était assez pénible, et éclatée en trois endroits :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<ol>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<li> eu début de la boucle, la condition
|
|
|
|
|
|
<code>test $numero != 51</code> ou
|
|
|
|
|
|
<code>test $numero != $limite</code> ;</li>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</ol>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
|
|
|
|
|
Pourquoi dire en trois fois ce qui, dans les langages naturels
|
2009-09-20 12:27:14 +02:00
|
|
|
|
(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 :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "50fichiers-for"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# la commande "seq <em>a</em> <em>b</em>" compte de <em>a</em> à <em>b</em>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
for numero in `seq 1 50`
|
|
|
|
|
|
do touch fichier"$numero"
|
|
|
|
|
|
done
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
<p class="continue">Avouez que le script est beaucoup plus simple de
|
2009-09-20 12:27:14 +02:00
|
|
|
|
cette manière !</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h2>Définir une variable : <code>select</code></h2>
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Il est parfois utile de donner à l'utilisateur du script des formulaires
|
|
|
|
|
|
sous forme de <strong>questions à choix multiples</strong>.</p>
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
|
|
|
|
|
<p> Par exemple, je suis sociologue et je veux dresser des statistiques
|
2009-09-20 12:27:14 +02:00
|
|
|
|
sur les opinions d'un échantillon représentatif de normaliens :
|
|
|
|
|
|
sont-ils favorables ou défavorables à la destruction du NIR (Nouveau
|
|
|
|
|
|
Pavillon Rataud) et à la reconstruction du VIR (Vieux Pavillon
|
|
|
|
|
|
Rataud) ?
|
2005-06-03 16:59:10 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Spontanément, je fais le script suivant :
|
2005-06-03 16:59:10 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "vote-nir"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Êtes-vous favorable au remplacement du NIR par le VIR ?"
|
|
|
|
|
|
echo "(Répondez « pour » ou « contre »)"
|
2005-06-03 16:59:10 +02:00
|
|
|
|
read opinion
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# M'envoyer le résultat par mail
|
2005-06-03 16:59:10 +02:00
|
|
|
|
echo "$opinion" | mail bourdieu
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<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>
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>Heureusement, il existe une parade : la boucle
|
2005-06-03 16:59:10 +02:00
|
|
|
|
<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>
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<h4>Questions à choix multiples</h4>
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Voici le script de notre sociologue :
|
2005-06-03 16:59:10 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "vote-nir"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Êtes-vous favorable au remplacement du NIR par le VIR ?"
|
2005-06-03 16:59:10 +02:00
|
|
|
|
select opinion in Pour Contre
|
|
|
|
|
|
do break
|
|
|
|
|
|
done
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# M'envoyer le résultat par mail
|
2005-06-03 16:59:10 +02:00
|
|
|
|
echo "$opinion" | mail bourdieu
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
<p class="continue">
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Les utilisateurs verront alors :
|
2005-06-03 16:59:10 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Êtes-vous favorable au remplacement du NIR par le VIR ?
|
2005-06-03 16:59:10 +02:00
|
|
|
|
1) Pour
|
|
|
|
|
|
2) Contre
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
|
|
|
|
|
<p class="continue">
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Ils devront alors taper 1 ou 2, selon leur opinion.
|
2005-06-03 16:59:10 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p>Vous avez remarqué que l'instruction <code>do</code> est suivie de la
|
2005-06-03 16:59:10 +02:00
|
|
|
|
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>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Par défaut, <code>select</code> se comporte comme une boucle. Observons
|
|
|
|
|
|
le comportement du script suivant :
|
2005-06-03 16:59:10 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "piege"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Si tu arrives à sortir de ce script, je te donne 30 euros."
|
2005-06-03 16:59:10 +02:00
|
|
|
|
select issue in "Sortir" "Quitter"
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# la commande "continue" est une commande vide : elle ne fait rien de spécial
|
2005-06-03 16:59:10 +02:00
|
|
|
|
do continue
|
|
|
|
|
|
done
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p class="continue">Essayez maintenant d'exécuter ce script :</p>
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Si tu arrives à sortir de ce script, je te donne 30 euros.
|
2005-06-03 16:59:10 +02:00
|
|
|
|
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
|
2009-09-20 12:27:14 +02:00
|
|
|
|
petit jeu, ou autre. Ou encore, pour prévenir les réponses non
|
|
|
|
|
|
valides. Exemple :</p>
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
#!/bin/sh
|
|
|
|
|
|
# Fichier "vote-nir"
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
echo "Êtes-vous favorable au remplacement du NIR par le VIR ?"
|
2005-06-03 16:59:10 +02:00
|
|
|
|
select opinion in Pour Contre
|
|
|
|
|
|
do
|
|
|
|
|
|
case $opinion in
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# Laisser passer ceux qui répondent correctement à la question
|
2005-06-03 16:59:10 +02:00
|
|
|
|
"Pour"|"Contre") break;;
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# Au cas où des zozos tapent sur autre chose que 1 ou 2
|
2005-06-03 16:59:10 +02:00
|
|
|
|
"*") continue;;
|
|
|
|
|
|
esac
|
|
|
|
|
|
done
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
# M'envoyer le résultat par mail
|
2005-06-03 16:59:10 +02:00
|
|
|
|
echo "$opinion" | mail bourdieu
|
|
|
|
|
|
</pre>
|
|
|
|
|
|
|
2009-09-20 12:27:14 +02:00
|
|
|
|
<p class="continue">Grâce à cela, si un normalien tape une réponse
|
2005-06-03 16:59:10 +02:00
|
|
|
|
invalide, <code>select</code> attend qu'il tape quelque chose de
|
2009-09-20 12:27:14 +02:00
|
|
|
|
correct ; s'il tape quelque chose de correct, la réponse est
|
|
|
|
|
|
envoyée au sociologue.</p>
|
2005-06-03 16:59:10 +02:00
|
|
|
|
|
|
|
|
|
|
<div class="attention">
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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>.
|
2005-06-03 16:59:10 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
|
2005-06-03 15:56:21 +02:00
|
|
|
|
<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
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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
|
2005-06-03 15:56:21 +02:00
|
|
|
|
compilateur <code>cc</code> renvoie un code d'erreur non nul si le
|
2009-09-20 12:27:14 +02:00
|
|
|
|
fichier compilé contient des erreurs, ou s'il n'existe pas.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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 ».
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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 :
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</p>
|
|
|
|
|
|
|
|
|
|
|
|
<pre>
|
|
|
|
|
|
if test $var = foo
|
|
|
|
|
|
then echo 'La variable vaut foo'
|
|
|
|
|
|
else echo 'La variable ne vaut pas foo'
|
|
|
|
|
|
fi</pre>
|
|
|
|
|
|
|
2005-09-08 01:00:03 +02:00
|
|
|
|
<p>
|
2009-09-20 12:27:14 +02:00
|
|
|
|
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ù
|
2005-09-08 01:00:03 +02:00
|
|
|
|
vous pourrez vous orienter vers d'autres parties du cours.
|
|
|
|
|
|
</p>
|
2005-06-03 15:56:21 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
<div class="metainformation">
|
2009-09-20 12:27:14 +02:00
|
|
|
|
Auteur : Baptiste Mélès.
|
|
|
|
|
|
Dernière modification le <date value="$Date: 2007-07-17 10:03:40 $" />.
|
2005-06-03 15:56:21 +02:00
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
|
|
</body>
|
|
|
|
|
|
</html>
|
