Bap: Compléments, surtout pour les débutants en programmation

(définition des variables, entrée/sortie, etc.)
2005-05-28 11:05:39 +00:00 · 2005-05-28 11:05:39 +00:00 · d429d8de60
commit d429d8de60
parent 329afe7141
1 changed files with 581 additions and 144 deletions
--- a/unix/shell.tml
+++ b/unix/shell.tml
@ -13,68 +13,165 @@
 <h2><a name="presentation">Présentation</a></h2>
 <p>
-Le machin qui interprète les commandes. 
+Le mot <em>shell</em> signifie «&nbsp;coquille&nbsp;» en anglais. Il
 s'agit du programme que vous utilisez régulièrement à l'ENS, et qui
 interprète les commandes. Par exemple, vous y tapez <code>pine</code> ou
 <code>mutt</code>, <code>forum</code>, <code>cc</code>,
 <code>mozilla</code>, etc. 
 </p>
 <p>
 Mais quel rapport avec une coquille&nbsp;? Eh bien, dans une coquille
 vous pouvez mettre de l'eau, pour la porter ensuite à votre
 bouche&nbsp;; vous pouvez y mettre du sable avant de le verser dans des
 bocaux&nbsp;; en somme, une coquille est un récipient qui permet
 de manipuler toutes sortes de contenus. Il en va de même du shell. C'est
 un outil en mode texte qui permet l'exploitation d'un grand nombre de
 ressources de l'ordinateur.
 </p>
 <p>
 Cette page vous donnera les rudiments pour exploiter les deux
 principales fonctionnalités du shell&nbsp;:
 </p>
 <ul>
 <li> l'usage interactif, reposant sur les <strong>lignes de
 commandes</strong>&nbsp;;</li>
 <li> la conception de <strong>scripts</strong> (programmes écrits en
 shell). </li> 
 </ul>
 <h3><a name="etats">Les deux états du shell</a>
 </h3>
 <p>
 Le shell, comme le normalien, ne connaît que deux états&nbsp;:
 </p>
 <ul>
 <li> le travail&nbsp;;</li>
 <li> l'inactivité.</li>
 </ul>
 <p>
 Le shell, une fois lancé, est inactif&nbsp;: il attend qu'on lui donne
 des ordres. Quand on lui en donne un, il l'exécute&nbsp;; et quand il a
 terminé, il retourne à son état d'inactivité, en attente d'un nouveau
 commandement. 
 </p>
 <p>
 Quand le shell est inactif, il affiche une <em>invite</em>
 (<em>prompt</em> en anglais), qui ressemble à cela&nbsp;:
 </p>
 <pre><span class="prompt">chaland ~ $</span></pre>
 <p>
 Un curseur, parfois clignotant, indique que le shell attend que vous lui
 tapiez des instructions.
 </p>
 <h3><a name="path">Comment le shell trouve-t-il les commandes ?</a>
 </h3>
 <p> La <a href="#variables">variable</a> <code>PATH</code> contient le
 chemin d'accès aux commandes. Le shell l'utilise pour trouver les
 commandes.  Il s'agit d'une liste de répertoires séparés par des
 <code>:</code>.  La plupart des commandes sont en fait des programmes,
 c'est-à-dire des fichiers qu'on trouve dans le système de fichiers.  </p>
 <p>
-Par exemple, quand vous tapez <code>ls</code>,  le shell exécute le fichier
+J'ai l'habitude de taper des commandes dans le shell, et je vois qu'il
-<code>/bin/ls</code>.  Pour trouver ce fichier, il cherche dans le premier
+réagit. Mais comment comprend-il ce que je veux faire&nbsp;?
 répertoire du <code>PATH</code> un fichier qui s'appelle <code>ls</code>.
 S'il ne trouve pas, il cherche ensuite dans le deuxième répertoire et ainsi
 de suite.
 </p>
 <p>
-S'il ne trouve la commande dans aucun répertoire du <code>PATH</code>, le shell
+Prenons un cas simple. Je tape la commande <code>bonjour</code> à
-affiche un message d'erreur.  Exemple:
+l'invite (<em>prompt</em>) du shell. Il va chercher à plusieurs endroits
 ce que j'entends par là&nbsp;:
 </p>
 <ol>
 <li> d'abord, il va se demander si <code>bonjour</code> n'est pas une de
 ses commandes intégrées&nbsp;; si c'est le cas, il l'exécute
 directement, sinon il passe à l'étape suivante&nbsp;;</li>
 <li> ensuite, il va lire le contenu d'une variable, qui s'appelle
 <code>PATH</code>, et qui indique le «&nbsp;chemin&nbsp;» où trouver les
 commandes que l'on appelle. Par exemple, si la variable PATH contient
 les répertoires&nbsp;:
 <ul>
 <li> <code>/usr/bin</code> </li>
 <li> <code>/bin</code> et </li>
 <li> <code>/home/toto/bin</code>,</li>
 </ul>
 alors le shell va chercher successivement les commandes&nbsp;:
 <ul>
 <li> <code>/usr/bin/bonjour</code>,</li>
 <li> <code>/bin/bonjour</code> et </li>
 <li> <code>/home/toto/bin/bonjour</code>&nbsp;;</li> 
 </ul></li>
 <li> enfin, s'il ne trouve la commande dans aucun des répertoires
 référencés par le <code>PATH</code>, il va renvoyer un message d'erreur
 en disant que désolé, il ne voit pas ce que l'on entend par
 <code>bonjour</code>.  Exemple&nbsp;:
 <pre>
 <span class="prompt">chaland ~ $</span> bonjour
 bonjour: Command not found</pre> </li>
 </ol>
 <p> La <a href="#variables">variable</a> <code>PATH</code> consiste en
 une liste de répertoires séparés par des
 «&nbsp;<code>:</code>&nbsp;». Si vous voulez voir à quoi ressemble votre
 PATH, tapez&nbsp;:
 </p>
 <pre>
-<span class="prompt">chaland ~ $</span> sl
+<span class="prompt">chaland ~ $</span> echo $PATH</pre>
-sl: Command not found</pre>
+
 <h3><a name="builtins">Commandes internes</a></h3>
 <p>
-Certaines commandes du shell ne sont pas des programmes mais des commandes
+Certaines commandes du shell ne sont pas des programmes mais des
-<em>internes</em> (<em>builtins functions</em>).  Elles sont directement
+commandes <em>internes</em> (<em>builtins functions</em>).  Comme nous
-reconnues et exécutées par le shell.  Un exemple de commande interne est
+l'avons vu, elles sont directement reconnues et exécutées par le shell.
-<code>cd</code>.  C'est le répertoire courant du shell qui est modifié par
+Un exemple de commande interne est <code>cd</code>&nbsp;; elle modifie
-<code>cd</code>, ce qui signifie que le script suivant :
+le répertoire courant du shell.
 </p>
 <div class="attention">
 <p> 
 Attention&nbsp;: si vous créez un script (c'est-à-dire un programme
 écrit en langage shell) qui utilise <code>cd</code>, il ne modifie pas
 le répertoire courant du shell qui lance ce script, mais celui d'un
 shell qui est créé à l'occasion de l'exécution de ce script, et qui
 meurt à la fin de cette exécution.</p>
 <p> Exemple&nbsp;: je crée un script <code>aller</code> qui contient les
 lignes suivantes&nbsp;: </p>
 <pre>
 #! /bin/sh
 cd $*</pre>
-<p class="continue">
+<p>
-ne marche pas, car le shell lance un autre shell pour exécuter le script.
+Nous aurons alors&nbsp;:
 C'est ce sous-shell qui change son répertoire courant, et ce changement est
 perdu quand le sous-shell meurt.
 </p>
 <pre>
 <span class="prompt">chaland ~ $</span> aller toto
 <span class="prompt">chaland ~ $</span> cd toto
 <span class="prompt">chaland ~/toto $</span></pre>
 </div>
 <h3><a name="prog">Quels programmes utilisent le langage du shell ?</a></h3>
 <p>
-Scripts pour automatiser ou systématiser  des tâches,
+La répétition de commandes complexes en ligne de commande du shell est
-opérations un peu compliquées.
+rapidement fastidieuse&nbsp;; aussi est-il très pratique de connaître
-</p>
+les bases de la programmation de scripts shell. Les scripts servent à
-
+automatiser ou systématiser des tâches.
 <p>
 sh : .profile (shell de login) ; sh lance un autre shell qui prend la relève
 pour la session.
 .xinitrc (pour lancer X)
 </p>
 <p>
@ -90,9 +187,22 @@ config conscrits. Il est n
 options.
 </p>
 <p> Il existe encore le script <code>.xinitrc</code>, qui lance X&nbsp;;
 X&nbsp;est le gestionnaire de fenêtres classique sous Unix.
 </p>
 <p>
 Le nombre de scripts possibles est illimité&nbsp;; vous pouvez en créer
 autant que vous voulez, selon vos besoins&nbsp;: c'est ainsi que l'on
 personnalise son système et qu'on l'adapte à ses exigences, plutôt que
 l'inverse. 
 </p>
 <h2><a name="ligne">La ligne de commande</a></h2>
-<h3><a name="raccourcis">Raccourcis pour les noms de fichiers</a></h3>
+<h3><a name="raccourcis">Raccourcis pour les noms de fichiers&nbsp;: les
 jokers</a></h3>
 <p>
 Il est parfois ennuyeux d'avoir à taper un nom complet de fichier comme
@ -107,13 +217,13 @@ Pour
 (<em>wildcards</em> en anglais).
 </p>
-<h4>L'étoile</h4>
+<h4>L'étoile : *</h4>
 <p>
 Une <strong>étoile</strong> <code>*</code> dans un nom de fichier est
 interprétée par le shell comme « n'importe quelle séquence de
 caractères » (mais ça ignore les fichiers dont le nom commence par un
-point).  Exemple:
+point).  Exemple&nbsp;:
 </p>
 <pre>cc -o foo *.c</pre>
@ -128,7 +238,7 @@ ex
 <pre>cc -o foo bar.c buz.c foo.c gee.c gog.c</pre>
-<h4>Le point d'interrogation</h4>
+<h4>Le point d'interrogation : ?</h4>
 <p>
 On a aussi le <strong>point d'interrogation</strong> <code>?</code>, qui
@ -137,7 +247,7 @@ de nom).  Par exemple, <code>ls *.?</code> liste tous les dont l'extension
 ne comporte qu'un caractère (<code>.c</code>, <code>.h</code>...).
 </p>
-<h4>Les crochets</h4>
+<h4>Les crochets : []</h4>
 <p>
 La forme <code>[abcd]</code> remplace un caractère quelconque parmi
@ -208,7 +318,7 @@ backslash est lui-m
 </p>
 <p>
-Exemples:
+Exemples&nbsp;:
 </p>
 <pre>
@ -221,20 +331,21 @@ Exemples:
 <p>
 Un autre moyen est d'inclure une chaîne de caractères entre apostrophes
-(simples quotes) <code>'</code>.  Tout ce qui se trouve entre deux apostrophes
+(simples quotes) <code>'</code>.  Tout ce qui se trouve entre deux
-sera passé tel quel par le shell à la commande.
+apostrophes sera passé tel quel par le shell à la
-Exemple:
+commande. Exemple&nbsp;:
 </p>
 <pre>
 <span class="prompt">chaland ~ $</span> echo '$?*'
 $?*</pre>
-<h4>Les guillemets doubles ou doubles quotes (<code>"</code>)</h4>
+<h4>Les guillemets doubles ou doubles quotes (<code>&quot;</code>)</h4>
 <p> 
 Les guillemets se comportent comme les apostrophes, à une exception près: les
-dollars et les backslashes sont interprétés entre les guillemets.  Exemple:
+dollars et les backslashes sont interprétés entre les guillemets.
 Exemple&nbsp;: 
 </p>
 <pre>
@ -242,8 +353,9 @@ dollars et les backslashes sont interpr
 /users/87/maths/doligez/*</pre>
 <p>
-Une technique utile: Quand on juxtapose deux chaînes de caractères quotées, le
+Une technique utile: Quand on juxtapose deux chaînes de caractères
-shell les concatène, et elles ne forment qu'un argument.  Exemple:
+quotées, le shell les concatène, et elles ne forment qu'un argument.
 Exemple&nbsp;:
 </p>
 <pre>
@ -263,7 +375,7 @@ de savoir si
 Dernière forme de quotation: <code>`<em>commande</em>`</code>. Le shell
 exécute la <em>commande</em> indiquée entre backquotes, lit la sortie de la
 commande mot par mot, et remplace  <code>`</code> <em>commande</em>
-<code>`</code> par la liste de ces mots.  Exemple :
+<code>`</code> par la liste de ces mots.  Exemple&nbsp;:
 </p>
 <pre>
@ -284,20 +396,92 @@ commande it <em>cmd</em>
 /usr/local/bin/emacs</pre>
-<h3><a name="redirections">Redirections</a></h3>
+<h3><a name="redirections">Entrée, sortie et redirection</a></h3>
 <h4>Entrée et sortie</h4>
 <p>
-Chaque commande a une <em>entrée standard</em>, une <em>sortie standard</em>,
+Un programme consiste à traiter des données, et à renvoyer des données
-et une <em>sortie d'erreur</em>. Par défaut, l'entrée standard est le clavier,
+transformées&nbsp;: il transforme des informations, et c'est pourquoi
-la sortie standard est l'écran, et la sortie d'erreur est aussi l'écran.
+l'on parle d'<em>informatique</em>.</p>
 <p> Prenons le programme <code>hachoir</code>, par exemple&nbsp;: on y
 fait entrer des choses, elles sortent sous une autre forme, et dans
 l'intervalle, elles subissent des transformations régulières. Par
 exemple, on fait entrer une vache, il en ressort du steak haché&nbsp;;
 on y fait entrer des carottes, il en ressort des carottes rapées.
 </p>
 <p>
 Deux concepts permettent de modéliser cette transformation
 d'informations&nbsp;: les concepts d'entrée et de
 sortie. L'<strong>entrée</strong>, c'est la vache ou les carottes&nbsp;;
 la <strong>sortie</strong>, c'est le steak haché ou les carottes
 rapées. 
 </p>
 <h4>Sortie standard et sortie d'erreur</h4>
 <p>
 Mais cette première distinction entre entrée et sortie ne suffit pas,
 car la sortie d'un programme, c'est-à-dire les messages qu'il renvoie,
 sont de deux ordres&nbsp;: il y a les <em>messages normaux</em> relevant
 de la transformation d'informations (par exemple le steak haché ou les
 carottes rapées), mais il y a aussi des <em>messages d'erreur</em>.</p>
 <p> Par exemple, si vous mettez, sur le tapis roulant qui mène au
 hachoir, un objet trop gros pour y rentrer, le hachoir, s'il est bien
 conçu, devra vous prévenir qu'il n'arrive pas à hacher un objet si
 gros. Et ce message, quoiqu'il sorte aussi bien du hachoir que le steak
 haché, ne doit pas être traité de la même façon à sa sortie, et n'est
 pas suivi des mêmes conséquences. C'est pourquoi l'on distingue la
 <strong>sortie standard</strong> et la <strong>sortie d'erreur</strong>.
 </p>
 <p>
 Pour résumer, chaque commande a donc&nbsp;:</p>
 <ul>
 <li> une <em>entrée standard</em>, </li>
 <li> une <em>sortie standard</em> et </li>
 <li> une <em>sortie d'erreur</em>.</li>
 </ul>
 <h4>Comportement par défaut</h4>
 <p> Par défaut, l'entrée standard est le clavier, la sortie standard est
 l'écran, et la sortie d'erreur est aussi l'écran.</p>
 <p> C'est sur le clavier que vous tapez&nbsp;; ce que vous tapez et ce
 que renvoient les programmes s'inscrit à l'écran&nbsp;; les messages
 d'erreur renvoyés par les programmes s'affichent à l'écran.
 </p>
 <h4>Les redirections</h4>
 <p>
 Mais il ne s'agit là que du comportement par défaut, et pas d'un
 comportement obligatoire. Vous pouvez tout à fait orienter différemment
 vos programmes.</p>
 <p> Par exemple, si vous donnez une vache comme entrée au hachoir, vous
 pouvez orienter la sortie vers une imprimante (au lieu de l'écran,
 proposé par défaut), et vous imprimerez ainsi du steak haché. </p>
 <p>
 Ou encore, vous pouvez donner un plant de carottes comme entrée au
 programme <code>cueillette</code>, et envoyer la sortie (c'est-à-dire
 les carottes cueillies) au programme <code>hachoir</code>.
 </p>
 <h4>Rediriger la sortie dans un fichier : <code>&gt;</code></h4>
 <p>
-On peut <em> rediriger</em> la sortie standard d'une commande vers un fichier
+On peut <em> rediriger</em> la sortie standard d'une commande vers un
-(caractère <code>&gt;</code>). Le résultat de la commande sera placé dans le
+fichier (caractère «&nbsp;<code>&gt;</code>&nbsp;»). Le résultat de la
-fichier au lieu de s'afficher sur l'écran.  Exemple:
+commande sera placé dans le fichier au lieu de s'afficher sur l'écran.
 Exemple&nbsp;:
 </p>
 <pre><span class="prompt">chaland ~ $</span> ls -l &gt; foo</pre>
@ -314,12 +498,41 @@ dans le fichier <code>foo</code>.  On peut alors taper
 pour lire le fichier page par page.
 </p>
 <h4>Ajouter la sortie à un fichier : <code>&gt;&gt;</code></h4>
 <p> On veut parfois ajouter la sortie d'un programme à un fichier, sans
 effacer ce qui précède. Or, par défaut, si l'on tape plusieurs fois
 </p>
 <pre><span class="prompt">chaland ~ $</span> ls -l &gt; foo</pre>
 <p class="continue">
 à chaque fois, le contenu antérieur du fichier <code>foo</code> est
 écrasé par le contenu ultérieur.
 </p>
 <p>
 Pour éviter cela, il existe l'outil de redirection &gt;&gt;. Ainsi, si
 vous tapez plusieurs fois
 </p>
 <pre><span class="prompt">chaland ~ $</span> ls -l &gt;&gt; foo</pre>
 <p class="continue">
 le fichier <code>foo</code> contiendra <em>à la suite</em> tout ce que
 vous a renvoyé la commande.
 </p>
 <h4>Rediriger l'entrée : <code>&lt;</code></h4>
 <p>
 On peut aussi rediriger l'entrée standard d'une commande (caractère
-<code>&lt;</code>). La commande lira alors le fichier au lieu du clavier.
+«&nbsp;<code>&lt;</code>&nbsp;»). La commande lira alors le fichier au
-Exemple:
+lieu du clavier.  Exemple&nbsp;:
 </p>
 <pre><span class="prompt">chaland ~ $</span> elm leroy &lt; foo</pre>
@ -339,19 +552,64 @@ standard et l'affiche page par page sur le terminal.
 <code>|</code></h4>
 <p>
-On peut  se passer du fichier intermédiaire grâce à un <em>pipe</em>
+Il devient rapidement ennuyeux de taper&nbsp;:
-(caractère <code>|</code>).  Un pipe connecte directement la sortie standard d'une
+</p>
-commande sur l'entrée standard d'une autre commande.  Exemple: pour afficher
+
-page par page la liste des fichiers du répertoire courant, faire
+<pre><span class="prompt">chaland ~ $</span> ls -l &gt; foo
 <span class="prompt">chaland ~ $</span> less &lt; foo
 <span class="prompt">chaland ~ $</span> rm foo</pre>
 <p>
 On peut se passer du fichier intermédiaire (<code>foo</code> dans notre
 exemple) grâce à un <em>pipe</em> (caractère
 «&nbsp;<code>|</code>&nbsp;»).  Un pipe connecte directement la sortie
 standard d'une commande sur l'entrée standard d'une autre commande.
 Exemple&nbsp;: pour afficher page par page la liste des fichiers du
 répertoire courant, faire
 </p>
 <pre><span class="prompt">chaland ~ $</span> ls -l | less</pre>
 <p>
-Le pipe est d'un usage très courant et rend beaucoup de services.
+Le pipe, ou tube, est d'un usage très courant, et rend beaucoup de
 services.
 </p>
-<h4>Récapitulatif</h4>
+
 <h3>Succès et erreur</h3>
 <p>
 On a parfois besoin de savoir si une commande a réussi ou non avant d'en
 lancer une autre. Les indicateurs <code>&amp;&amp;</code> et
 <code>||</code> permettent, respectivement, de lancer une commande si
 (et seulement si) la précédente a réussi ou échoué.
 </p>
 <p>
 Par exemple, si j'ai un fichier <code>foo</code>, j'obtiens&nbsp;:
 </p>
 <pre>
 <span class="prompt">chaland ~ $</span> ls foo &amp;&amp; echo "J'ai un fichier foo."
 foo
 J'ai un fichier foo.
 </pre>
 <p>
 Si je n'ai pas de fichier <code>foo</code>, le message ne s'affiche
 pas. En revanche, si je tape alors&nbsp;:
 </p>
 <pre>
 <span class="prompt">chaland ~ $</span> ls foo || echo "Je n'ai pas de fichier foo."
 ls: foo: No such file or directory
 Je n'ai pas de fichier foo.
 </pre>
 <h3>Récapitulatif</h3>
 <p>
 La panoplie complète des redirections est la suivante (le tableau indique les
@ -379,11 +637,19 @@ premi
 </li>
 </ul>
 <h3>Redirection des sorties standard et d'erreur</h3>
 <p>
 Il est parfois utile de rediriger la sortie standard et la sortie
 d'erreur vers un même endroit. Pour cela, on utilise le motif
 <code>2&gt;&amp;1</code> avant la redirection.
 </p>
 <table class="tableau">
 <tr>
 <th> Fonction     </th>
-<th> Bourne shell </th>
+<th> Bourne shell (sh, bash) </th>
-<th> Z-shell      </th>
+<th> Z-shell (zsh)      </th>
 </tr>
 <tr>
 <td>Redirige la sortie d'erreur (2) et la sortie standard (1) sur l'entrée
@ -472,12 +738,79 @@ Affiche les 10 derniers mots du dictionnaire qui contiennent la cha
 <h3><a name="variables">Variables</a></h3>
 <h4>Qu'est-ce qu'une variable&nbsp;?</h4>
 <p>
-Le shell a des variables.  Pour désigner le contenu d'une variable, on écrit
+Une variable est l'assignation d'une étiquette à un contenu&nbsp;; ce
-le nom de la variable précédé d'un dollar.  Exemple: <code>echo $HOME</code>
+contenu, comme l'indique le mot «&nbsp;variable&nbsp;», peut changer
-affiche le nom du répertoire personnel de l'utilisateur.
+autant que l'on veut&nbsp;; l'assignation de l'étiquette à ce contenu,
 elle, est fixe, aussi longtemps que l'on ne dissout pas la
 variable. </p>
 <p>
 La notion de variable est commune à presque tous les langages
 informatiques, et en particulier aux langages de programmation. Ceux qui
 ont déjà manipulé des langages sont donc familiers avec cette
 notion. Pour les autres, un petit exemple les aidera peut-être à la
 saisir. 
 </p>
 <p>
 Mettons que vous programmiez le hachoir dont nous parlions plus haut. Un
 hachoir est un instrument dangereux, à ne pas mettre à la portée des
 enfants. Robert le jardinier, qui a conçu ce hachoir, veut être le seul
 à pouvoir l'utiliser, sans quoi le petit Émile pourrait se blesser en y
 mettant le doigt.</p>
 <p> Ainsi, il va dire au programme <code>hachoir</code> de vérifier la
 variable <code>USER</code>, qui contient le nom de l'utilisateur. Si le
 nom «&nbsp;Robert&nbsp;» est associé à l'étiquette <code>USER</code>,
 alors le programme se met en route&nbsp;; sinon, il dit à l'utilisateur
 de ne pas utiliser cet instrument sans la présence d'un adulte, et de
 bien regarder des deux côtés avant de traverser la rue.
 </p>
 <p>
 Certaines variables sont prédéfinies, par exemple
 <code>USER</code>&nbsp;; mais on peut en créer autant que l'on veut. Par
 exemple, si Robert veut autoriser d'autres adultes que lui à utiliser
 son hachoir, il peut faire que le programme demande à l'utilisateur quel
 âge il a&nbsp;; la réponse est enregistrée dans la variable
 <code>age</code>&nbsp;; ensuite, le programme va examiner le contenu de
 cette variable. Si <code>age &gt;= 18</code>, alors le hachoir peut se
 mettre en route&nbsp;; mais si <code>age &lt; 18</code>, le hachoir
 refuse de se mettre en marche.
 </p>
 <h4>Les variables en shell</h4>
 <p>
 En shell, pour désigner le contenu d'une variable, on écrit le nom de la
 variable précédé du signe dollar.  Exemple&nbsp;: <code>echo
 $HOME</code> affiche le nom du répertoire personnel de l'utilisateur,
 mémorisé par la variable <code>HOME</code>.
 </p>
 <h5>Les noms de variables</h5>
 <p>
 Par convention, les variables relevant du système, comme
 <code>HOME</code>, <code>USER</code> et beaucoup d'autres, sont en
 majuscules, tandis que l'on recommande d'écrire en minuscules les
 variables que l'on se crée soi-même. On évite ainsi la désagréable
 surprise de remplacer une variable importante et de casser tout ou
 partie de son système. 
 </p>
 <p>
 Les noms de variables sont en effet sensibles à la casse&nbsp;:
 <code>USER</code>, <code>user</code>, <code>User</code>,
 <code>uSeR</code> etc. sont des variables différentes.
 </p>
 <h5>Définir une variable</h5>
 <p>
 La façon de donner une valeur à une variable varie selon le type de shell
 utilisé :
@ -504,11 +837,14 @@ Famille des <strong>Bourne Shell</strong> (<code>sh</code>, <code>bash</code>,
 <span class="prompt">chaland ~ $</span> echo $foo
 bar</pre>
 <h5>Les variables d'environnement</h5>
 <p>
-Les valeurs des variables sont accessibles aux commandes lancées par le shell.
+Les valeurs des variables sont accessibles aux commandes lancées par le
-L'ensemble de ces valeurs constitue l'<em>environnement</em>.  On peut aussi
+shell.  L'ensemble de ces valeurs constitue l'<em>environnement</em>.
-supprimer une variable de l'environnement avec <code>unsetenv</code>
+On peut aussi supprimer une variable de l'environnement avec
-(C-Shell) ou <code>unset</code> (Bourne Shell).
+<code>unsetenv</code> (C-Shell) ou <code>unset</code> (Bourne Shell).
 </p>
 <p>
@ -516,29 +852,23 @@ Quelques variables d'environnement:
 </p>
 <ul>
-<li><code>DISPLAY</code> : L'écran sur lequel les programmes X travaillent.
+<li><code>DISPLAY</code> : L'écran sur lequel les programmes&nbsp;X
-C'est souvent de la forme : <code>machine.somehost.somewhere:0.0</code>
+travaillent.  Cette variable est souvent de la forme&nbsp;:
-Si c'est vide, c'est qu'il n'y a pas d'affichage graphique possible.
+<code>machine.somehost.somewhere:0.0</code> Si cette variable est vide,
-</li>
+c'est qu'il n'y a pas d'affichage graphique possible.  </li>
-<li><code>PRINTER</code> : pour les commandes d'impression.  Contient le nom de
+<li><code>PRINTER</code> : pour les commandes d'impression.  Contient le
-l'imprimante sur laquelle il faut envoyer vos fichiers.
+nom de l'imprimante sur laquelle il faut envoyer vos fichiers.  </li>
-</li>
+<li><code>EDITOR</code> : utilisée par <code>mutt</code>,
-<li><code>EDITOR</code> : utilisée par <code>mutt</code>, <code>forum</code>,
+<code>forum</code>, et beaucoup d'autres commandes.  Contient le nom de
-et beaucoup d'autres commandes.  Contient le nom de votre éditeur de textes
+votre éditeur de textes préféré.  </li> 
-préféré.
+<li><code>VISUAL</code> : la même chose qu'<code>EDITOR</code>.  </li>
-</li>
+<li><code>SHELL</code> : contient le nom de votre shell.  </li>
 <li><code>VISUAL</code> : la même chose qu'<code>EDITOR</code>.
 </li>
 <li><code>SHELL</code> : contient le nom de votre shell.
 </li>
 <li><code>HOME</code> : contient le nom de votre répertoire personnel.
 </li> 
-<li><code>USER</code> : contient votre nom de login.
+<li><code>USER</code> : contient votre nom de login.  </li>
-</li>
+<li><code>LOGNAME</code> : la même chose que <code>USER</code>.  </li>
-<li><code>LOGNAME</code> : la même chose que <code>USER</code>.
+<li><code>PATH</code> : contient une liste de répertoires dans lesquels
-</li>
+le shell va chercher les commandes. 
 <li><code>PATH</code> : contient une liste de répertoires dans lesquels le
 shell va chercher les commandes.
 </li> 
 </ul>
@ -559,75 +889,173 @@ nous avons d
 </p>
 <p>
-Pour  la programmation du shell, nous allons utiliser le shell  <code>sh</code>,
+Pour la programmation du shell, nous allons utiliser le shell
-qui est le plus répandu et standard.   Ce que nous avons vu jusqu'ici
+<code>sh</code>, qui est le plus répandu et standard.  Ce que nous avons
-s'applique aussi bien à <code>sh</code> qu'à  <code>zsh</code> et aussi à
+vu jusqu'ici s'applique aussi bien à <code>sh</code> qu'à
-<code>csh</code>, à l'exception de <code>setenv</code> et de certaines
+<code>zsh</code> et aussi à <code>csh</code>, à l'exception de
-redirections signalées.  Pour  être un script, un fichier doit commencer par
+<code>setenv</code> et de certaines redirections signalées. </p>
-la ligne:
+
-</p>
+
 <h3>Rendre un script exécutable</h3>
 <p> Pour être un script, un fichier doit commencer par la ligne: </p>
 <pre>#!/bin/sh</pre>
 <p>
 Il doit aussi avoir être exécutable (bit <code>x</code>).  Le
 <code>#!/bin/sh</code> sur la première ligne indique que ce script doit être
-exécuté par le shell <code>sh</code> dont on indique le chemin d'accès.
+exécuté par le shell <code>sh</code> dont on indique le chemin
 d'accès. Pour rendre un fichier exécutable, tapez&nbsp;:
 </p>
 <pre><span class="prompt">chaland ~</span> chmod u+x fichier
 </pre>
 <p class="continue">
 (pour en savoir plus sur les droits attachés à un fichier, consultez la
 page sur <a href="droits.html">les droits d'accès</a>).
 </p>
 <h3><a name="structures">Structures de contrôle</a></h3>
-
+<p>
-<h4>for</h4>
+C'est avec les structures de contrôle qu'un programme peut commencer à
-
+devenir sérieux. Le principe général de ces structures est le
-<pre>for <em>var</em> in <em>liste de chaînes</em> ;
+suivant&nbsp;: adapter le comportement du programme selon les réponses
-do <em>commandes</em> ; done</pre>
+apportées à certaines questions.
 </p>
 <p>
-Affecte successivement à la variable de nom <em>var</em> chaque chaîne de
+Nous avons déjà vu une application possible des structures de contrôle
-caractères trouvée  dans la <em>liste de chaînes</em>, et exécute les
+en parlant des variables. Le programme <code>hachoir</code> conçu par
-<em>commandes</em> une fois pour chaque chaîne. 
+Robert le jardinier pose la question suivante&nbsp;: est-ce que
 <code>$USER</code> vaut «&nbsp;Robert&nbsp;»&nbsp;? 
 </p>
 <ul>
 <li> si oui, alors le hachoir doit se mettre en marche&nbsp;;</li>
 <li> si non, alors le hachoir doit refuser de se mettre en
 marche.</li> 
 </ul>
 <h4>La boucle <code>if</code></h4>
 <p>
 La structure de contrôle <code>if</code> est la plus courante de toutes,
 et la plus élémentaire. Elle est constituée de quatre termes&nbsp;:</p>
 <ol>
 <li> <code>if</code> (si), qui marque la condition à remplir&nbsp;;
 </li> 
 <li> <code>then</code> (alors), qui marque les conséquences si la
 condition est remplie&nbsp;; </li>
 <li> <code>else</code> (sinon), qui est facultatif et marque le
 comportement à adopter si la condition n'est pas remplie&nbsp;; </li>
 <li> <code>fi</code> (<code>if</code> à l'envers), qui marque la fin de
 la boucle.</li>
 </ol>
 <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)&nbsp;:</p>
 <pre>if <em>commande</em>  
 then <em>commandes</em> 
 else <em>commandes</em>  
 fi</pre>
 <p>
 Par exemple, pour Robert le jardinier, on aura&nbsp;:
 </p>
 <pre>if  [[ $USER == "Robert"]]
    then hacher_menu
    else echo "Quand tu seras grand, $USER." 
         echo "Et fais bien attention en traversant la rue."
 fi</pre>
 <h4>La boucle <code>for</code></h4>
 <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>
 <pre>for <em>var</em> in <em>liste de chaînes</em> ; do <em>commandes</em> ; done</pre>
 <p class="continue"> ou bien&nbsp;:</p>
 <pre>for <em>var</em> in <em>liste de chaînes</em> 
 do <em>commandes</em> 
 done</pre>
 <p>
 Rappel : <code>$<em>var</em></code> accède à la valeur courante de
 <em>var</em>. La partie <em>commandes</em> est une suite de commandes,
-séparées par des <code>;</code> ou des retours à la ligne.  (Tous les
+séparées par des points et virgules (<code>;</code>) ou des retours à la
-<code>;</code> dans cette syntaxe peuvent aussi être remplacés par des
+ligne.
 retours à la ligne.)
 </p>
 <p>
-Exemple : 
+Exemple&nbsp;: 
 </p>
-<pre>for i in *; do echo $i; done</pre>
+<pre>for i in *; do echo &quot;$i&quot;; done</pre>
 <p class="continue">
 affiche les noms de tous les fichiers du répertoire courant, un par ligne.
 </p>
 <h4>if</h4>
 <pre>if <em>commande</em> ; then <em>commandes</em> ;
 else <em>commandes</em> ; fi</pre>
 <p>
-Exécute l'une ou l'autre des listes de <em>commandes</em>, suivant que la
+Remarque&nbsp;: plus un programme grossit, plus il importe que son
-première <em>commande</em> a réussi ou non (voir ci-dessous).
+contenu soit lisible. <strong>Les noms de variable doivent donc être le
 plus lisibles possible</strong>, pour permettre à d'autres gens, ou bien
 à vous-même dans quelques mois, de comprendre rapidement votre script.
 Ainsi, il peut être plus explicite d'écrire, au lieu de «&nbsp;<code>for
 i in *; do echo &quot;$i&quot;; done</code>&nbsp;»&nbsp;:
 </p>
-<h4>while</h4>
+<pre>for fichier in *; do echo &quot;$fichier&quot;; done</pre>
 <pre>while <em>commande</em> ; do <em>commande</em> ; done</pre>
 <p>
-Exécute les <em>commandes</em> de manière répétée tant que la première
+En outre, pour des raisons de lisibilité, <strong>n'hésitez pas à
-<em>commande</em> réussit.
+gaspiller des lignes de code</strong> en sautant des lignes&nbsp;; les
 lignes de code ne sont pas une ressource rare&nbsp;:
 </p>
-<h4>case</h4>
+<pre>for fichier in * 
 do echo &quot;$fichier&quot; 
 done</pre>
 <h4>La boucle <code>while</code></h4>
 <pre>while <em>commande</em>  
 do <em>commande</em>  
 done</pre>
 <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.</p>
 <p> Par exemple&nbsp;: <em>tant que</em> le mot de passe correct n'a pas
 été donné, refuser l'accès et redemander le mot de passe.
 </p>
 <h4>La boucle <code>case</code></h4>
 <pre>case <em>chaîne</em> in
  <em>pattern</em>) <em>commande</em> ;;
@ -635,11 +1063,12 @@ Ex
 esac</pre>
 <p>
-Exécute la première <em>commande</em> telle que la <em>chaîne</em> est de la
+La boucle <code>case</code> exécute la première <em>commande</em> telle
-forme <em>pattern</em>. Un <em>pattern</em> est un mot contenant
+que la <em>chaîne</em> est de la forme <em>pattern</em>. Un
-éventuellement les constructions <code>*</code>, <code>?</code>,
+<em>pattern</em> (motif) est un mot contenant éventuellement les
-<code>[a-d]</code>, avec la même signification que pour les raccourcis dans
+constructions <code>*</code>, <code>?</code>, <code>[a-d]</code>, avec
-les noms de fichiers. Exemple :
+la même signification que pour les raccourcis dans les noms de
 fichiers. Exemple&nbsp;:
 </p>
 <pre>
@ -649,6 +1078,11 @@ case $var in
  *) echo 'Autre chose';;
 esac</pre>
 <p>
 Vous observerez que l'on clôt la boucle <code>case</code> avec
 <code>esac</code>, qui est le mot <code>case</code> à l'envers, de même
 que l'on clôt <code>if</code> avec <code>fi</code>.
 </p>
 <h3><a name="retour">Code de retour</a></h3>
@ -656,20 +1090,23 @@ esac</pre>
 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
+commande a réussi&nbsp;; sinon, la commande a échoué. Par exemple, le
-<code>cc</code> renvoie un code d'erreur non nul si le fichier compilé
+compilateur <code>cc</code> renvoie un code d'erreur non nul si le
-contient des erreurs, ou s'il n'existe pas.
+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
+Les commandes <code>if</code> et <code>while</code> considèrent donc le
-de retour 0 comme « vrai », et tout autre code comme « faux ».
+code de retour 0 comme «&nbsp;vrai&nbsp;», et tout autre code comme
 «&nbsp;faux&nbsp;».
 </p>
 <p>
-Il existe une commande <code>test</code>, qui évalue des expressions booléennes
+Il existe une commande <code>test</code>, qui évalue des expressions
-passées en argument, et renvoie un code de retour en fonction du résultat.
+booléennes (c'est-à-dire dont la valeur ne peut être que vraie ou
-Elle est bien utile pour les scripts.  Exemple :
+fausse, 1 ou 0) passées en argument, et renvoie un code de retour en
 fonction du résultat.  Elle est bien utile pour les scripts.
 Exemple&nbsp;:
 </p>
 <pre>
@ -733,8 +1170,8 @@ entra
 <div class="metainformation">
 Basé sur un polycopié de Roberto Di Cosmo, Xavier Leroy et Damien Doligez.
-Ajustements : Nicolas George.
+Ajustements&nbsp;: Nicolas George. Compléments&nbsp;: Baptiste Mélès. 
-Dernière modification le 2002-12-16.
+Dernière modification le <date value="$Date: 2005-05-28 11:05:39 $" />.
 </div>
 </body>