tuteurs.ens.fr/unix/shell/script.tml

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE html
  PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
  "tuteurs://DTD/tml.dtd">
<html>
<head>
<title>Scripts</title>
</head>
<body>
 
<h1><a name="programmation">Programmation de scripts en shell</a></h1>


<p>
Un shell, quel qu'il soit, peut ex<65>cuter des commandes prises dans un
fichier.  Un fichier contenant des commandes pour le shell  est appel<65> un
<em>script</em>.  C'est en fait un <em>programme</em> <20>crit <em>dans le
langage du shell</em>. Ce langage comprend  non seulement les commandes que
nous avons d<>j<EFBFBD> vues, mais  aussi des structures de contr<74>le
(constructions conditionnelles et boucles).
</p>

<p>
Pour la programmation du shell, nous allons utiliser le shell
<code>sh</code>, qui est le plus r<>pandu et standard.  Ce que nous avons
vu jusqu'ici s'applique aussi bien <20> <code>sh</code> qu'<27>
<code>zsh</code> et aussi <20> <code>csh</code>, <20> quelques exceptions
pr<EFBFBD>s, que nous vous signalerons en temps voulu. </p>


<h2>Cr<43>er un script</h2>

<h3><3E>crire un script</h3>
<p>
Un script shell est un fichier en mode texte. C'est-<2D>-dire que ce n'est
pas un fichier binaire, ex<65>cutable directement par la machine, mais
<strong>il doit <20>tre interpr<70>t<EFBFBD></strong>.
</p>

<h4>L'interpr<70>tation d'un script</h4>

<p>
L'interpr<70>tation signifie que chaque commande contenue dans un script
doit <20>tre lue par un programme, appel<65> <em>interpr<70>teur</em> (et non
interpr<EFBFBD>te, bizarrement)&nbsp;; l'interpr<70>teur analyse chaque commande
du script et la traduit <20>&nbsp;<3B> la vol<6F>e&nbsp;<3B> en langage machine, ce
qui permet l'ex<65>cution du script.
</p> 

<div class="encadre">
On oppose l'interpr<70>tation <20> la compilation, dans laquelle le programme
est traduit <em>une fois pour toutes</em> en langage machine, quel que
soit le nombre de ses ex<65>cutions&nbsp;; tandis que le programme
interpr<EFBFBD>t<EFBFBD> est traduit <20> la vol<6F>e pour chacune de ses ex<65>cutions. Par
exemple, le langage&nbsp;C est un langage compil<69>.
</div>

<p>Dans le cas des scripts shell, l'interpr<70>teur, c'est le shell
lui-m<>me. Dans d'autres langages, comme le Perl, l'interpr<70>teur est un
programme ind<6E>pendant du shell. </p>


<h4>L'<27>dition d'un script</h4>
<p>Un script <20>tant un fichier en mode texte, il doit <20>tre cr<63><72> avec un
<EFBFBD>diteur de texte. Un <20>diteur de texte est un programme dont la fonction
est... d'<27>diter du texte. Pour savoir plus <20> leur sujet, consultez les
pages sur les <a href="&url.tuteurs;unix/editeurs/"><3E>diteurs</a>. </p>

<p>Mais quel <20>diteur choisir&nbsp;?</p>

<p> Tout d'abord, il faut savoir que <strong>n'importe quel <20>diteur est
capable d'ouvrir et d'<27>crire des scripts shell</strong>, et vous pouvez
tout <20> fait modifier avec n'importe quel <20>diteur de texte ce que vous
avez <20>crit avec n'importe quel autre.</p>

<p>Mais il faut savoir aussi que <strong>certains <20>diteurs de texte sont
plus appropri<72>s que d'autres <20> l'<27>criture de scripts shell</strong>. Par
exemple, <code>nano</code> permet d'<27>diter des scripts comme tout autre
<EFBFBD>diteur, mais quand un script fait plus d'une dizaine de lignes, on
commence <20> s'y perdre un peu. <20> l'inverse, <a
href="&url.tuteurs;unix/editeurs/emacs.html"><code>emacs</code></a> et
<a href="&url.tuteurs;unix/editeurs/vim.html"><code>vim</code></a>
offrent quelques fonctionnalit<69>s qui deviennent rapidement
indispensables&nbsp;:</p>

<ol>
<li> l'indentation&nbsp;;</li>
<li> la coloration syntaxique.</li>
</ol>


<h5>L'indentation</h5>

<p>L'indentation consiste <20> <20>&nbsp;a<>rer&nbsp;<3B> votre texte selon sa
construction logique. C'est tr<74>s utile, en particulier, quand on a un
script qui ressemble <20> ceci&nbsp;:</p>

<pre>
#!/bin/sh
# Fichier &quot;vote-nir&quot;

echo &quot;<3B>tes-vous favorable au remplacement du NIR par le VIR&nbsp;?&quot;
select opinion in Pour Contre
do case $opinion in 
# Laisser passer ceux qui r<>pondent correctement <20> la question
&quot;Pour&quot;|&quot;Contre&quot;) break;;
# Au cas o<> des zozos tapent sur autre chose que 1 ou 2
&quot;*&quot;) continue;;
esac        
done

# M'envoyer le r<>sultat par mail
echo &quot;$opinion&quot; | mail bourdieu
</pre>

<p>M<>me (surtout) si vous ne comprenez pas ce que tout cela veut dire,
vous conviendrez que ce n'est pas tr<74>s lisible. Comparez donc avec
ceci&nbsp;: </p>

<pre>
#!/bin/sh
# Fichier &quot;vote-nir&quot;

echo &quot;<3B>tes-vous favorable au remplacement du NIR par le VIR&nbsp;?&quot;

select opinion in Pour Contre
  do 
    case $opinion in 
      # Laisser passer ceux qui r<>pondent correctement <20> la question
      &quot;Pour&quot;|&quot;Contre&quot;) break;;

      # Au cas o<> des zozos tapent sur autre chose que 1 ou 2
      &quot;*&quot;) continue;;
    esac        
done

# M'envoyer le r<>sultat par mail
echo &quot;$opinion&quot; | mail bourdieu
</pre>

<p>Les deux scripts sont interpr<70>t<EFBFBD>s exactement de la m<>me fa<66>on&nbsp;:
l'interpr<70>teur ignore les espaces et les lignes vides. Mais avec
l'indentation, on per<65>oit imm<6D>diatement (en tout cas, beaucoup plus
vite) la <strong>structure logique</strong> du script.</p>


<h5>La coloration syntaxique</h5>
<p>Les <20>diteurs comme <a
href="&url.tuteurs;unix/editeurs/emacs.html"><code>emacs</code></a> et
<a href="&url.tuteurs;unix/editeurs/vim.html"><code>vim</code></a>
analysent automatiquement le statut des diff<66>rents mots et symboles que
vous tapez et les colorent logiquement. Par exemple, avec emacs, vous
pouvez avoir&nbsp;:</p>

<ul>
<li> les commentaires en rouge&nbsp;;</li>
<li> les noms de commande en bleu fonc<6E>&nbsp;;</li>
<li> les noms d'arguments en vert&nbsp;;</li>
<li> les noms de variables en jaune&nbsp;;</li>
<li> les instructions li<6C>es aux boucles en bleu clair&nbsp;;</li>
<li> etc.</li>
</ul>

<p><3E>a n'a l'air de rien, dit comme cela, mais comparez vous-m<>me et vous
verrez que ces outils sont indispensables, et que l'on y gagne au moins
la moiti<74> du temps d'<27>criture et de d<>bugage.</p>

<h5>Apprendre <code>emacs</code> ou <code>vim</code></h5>

<p>Apprenez donc, si ce n'est pas d<>j<EFBFBD> le cas, les commandes de base
d'emacs ou de vim, ce sont des outils quasi incontournables au
programmeur shell, surtout d<>butant.</p>

<p> Heureusement, les tuteurs vous ont concoct<63> des pages
d'initiation&nbsp;: le <a
href="&url.tuteurs;unix/editeurs/emacs.html">tutorial
<code>emacs</code></a> et le <a
href="&url.tuteurs;unix/editeurs/vim.html">tutorial
<code>vim</code></a>.</p>

<p>Vous h<>sitez entre <code>emacs</code> et <code>vim</code>&nbsp;? Tout
le monde est pass<73> par l<>. Jetez un coup d'&oelig;il <20> chacun des deux,
puis concentrez-vous sur celui qui vous para<72>t le plus sympathique et le
plus pratique&nbsp;; et si vous h<>sitez encore, tirez-en un au
sort, ils se valent vraiment.</p>


<h3>Rendre un script ex<65>cutable</h3>

<p> Pour que le shell sache comment l'interpr<70>ter, un script shell doit
commencer par la ligne: </p>

<pre>#!/bin/sh</pre>

<p>
Il doit aussi avoir <20>tre ex<65>cutable (bit <code>x</code>).  Le
<code>#!/bin/sh</code> sur la premi<6D>re ligne indique que ce script doit <20>tre
ex<EFBFBD>cut<EFBFBD> par le shell <code>sh</code> dont on indique le chemin
d'acc<63>s. Pour rendre un fichier ex<65>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<63>s <20> un fichier, consultez la
page sur <a href="&url.tuteurs;unix/droits.html">les droits
d'acc<63>s</a>).
</p>


<h3>Le chemin d'une commande</h3>
<p>
Pour comprendre ce qui suit, vous devez savoir ce qu'est le
<code>PATH</code>. Si ce n'est pas le cas, lisez la <a
href="presentation.html">pr<70>sentation du shell</a>.
</p>

<p>
Quand vous ex<65>cutez un script, vous pouvez vous trouver <20>
n'importe quel endroit de l'arborescence de vos r<>pertoires. Si le
r<EFBFBD>pertoire courant ne se situe pas dans votre <code>PATH</code> et
que vous voulez ex<65>cuter un programme qui s'y trouve, vous ne pouvez
pas taper&nbsp;:
</p>

<pre>
<span class="prompt">clipper ~</span> commande
</pre>

<p class="continue">car si le r<>pertoire courant n'est pas dans le
<code>PATH</code>, le shell n'ira pas y chercher
<code>commande</code>. </p>

<p>
Vous recevrez donc un message comme&nbsp;:
</p>

<pre>
<span class="prompt">clipper ~</span> commande
zsh: command not found: commande</pre>


<h4>Sp<53>cifier le chemin d'une commande</h4>

<p>
Pour que le shell comprenne o<> chercher votre commande, il faut donc
sp<EFBFBD>cifier l'emplacement de la commande en donnant son chemin, qu'il
soit absolu&nbsp;:
</p>

<pre>
<span class="prompt">clipper ~</span> /home/toto/repertoire/courant/commande
</pre>

<p class="continue">ou relatif&nbsp;: </p>

<pre>
<span class="prompt">clipper ~</span> repertoire/courant/commande
</pre>

<p class="continue">ou encore sous la forme&nbsp;: </p>

<pre>
<span class="prompt">clipper ~/repertoire/courant</span> ./commande
</pre>


<h4>Le r<>pertoire <code>~/bin</code></h4>
<p>
Il y a un certain nombre de commandes que l'on peut vouloir utiliser
depuis n'importe quel r<>pertoire. Dans ce cas, il est fastidieux de&nbsp;:
</p>

<ul>
<li> devoir se rappeler dans quel r<>pertoire se trouve chacune
d'entre elles&nbsp;;</li> 
<li> devoir taper <20> chaque fois le chemin de la commande.</li>
</ul>

<p>Il suffit donc de mettre tous vos scripts dans un m<>me
r<EFBFBD>pertoire, et de mettre ce r<>pertoire dans le
<code>PATH</code>. Par convention, ce r<>pertoire s'appelle
<code>bin</code> et se place dans votre r<>pertoire personnel. Si
votre r<>pertoire personnel est <code>/home/toto</code>, ce
r<EFBFBD>pertoire sera donc <code>/home/toto/bin</code>. </p> 

<p>
Commencez donc par cr<63>er ce r<>pertoire&nbsp;:
</p>

<pre>
<span class="prompt">clipper ~</span> mkdir bin
</pre>

<p>
Ensuite, v<>rifiez qu'il soit bien dans votre <code>PATH</code>&nbsp;: 
</p>

<pre>
<span class="prompt">clipper ~</span> echo $PATH
</pre>

<p class="continue">Si vous voyez par exemple <code>$HOME/bin</code>
dans votre <code>PATH</code>, alors c'est bon, tous les fichiers
ex<EFBFBD>cutables situ<74>s dans ce r<>pertoire seront accessibles depuis
n'importe quel r<>pertoire.
</p>

<p>
Si ce n'est pas le cas, il faut ajouter ce r<>pertoire au
<code>PATH</code>. Pour cela, ajoutez dans le fichier de configuration
de votre shell, par exemple le fichier <code>.zshrc</code>, la
ligne&nbsp;: 
</p>

<pre>PATH=$PATH:$HOME/bin</pre>

<p class="continue">Cette ligne indique que la prochaine fois que vous
ouvrirez votre shell, le r<>pertoire <code>bin</code> figurera dans
votre <code>PATH</code>.
</p>

<h2>Principes g<>n<EFBFBD>raux des scripts shell</h2>

<h3>Une succession de commandes</h3>

<p> Si vous manipulez d<>j<EFBFBD> le shell en ligne de commande, vous
pouvez commencer vos premiers scripts. Un script shell est en effet
avant tout une <strong>succession de commandes</strong>.
</p>

<p> Par exemple, si vous avez coutume de taper successivement, quand
vous vous loguez <20> l'ENS&nbsp;:
</p>

<pre>
<span class="prompt">clipper ~</span> mozilla &amp;
<span class="prompt">clipper ~</span> mutt
</pre>

<p class="continue">vous pouvez vous cr<63>er le script suivant dans le
fichier <code>~/bin/amorce</code>&nbsp;:</p>

<pre>
#!/bin/sh

mozilla &amp;
mutt
</pre>

<p>Ainsi, d<>s que vous vous connectez, vous pouvez taper
<code>amorce</code> dans le shell, et vos commandes s'ex<65>cuteront
automatiquement. </p>


<h3>Commentaires</h3>
<p>
Presque tous les langages informatiques autorisent d'ins<6E>rer des
commentaires&nbsp;; le shell n'<27>chappe pas <20> la r<>gle. Pour
cela, il suffit de faire pr<70>c<EFBFBD>der chaque ligne de commentaire du
caract<EFBFBD>re <20>&nbsp;#&nbsp;<3B>. Exemple&nbsp;:
</p>

<pre>
#!/bin/sh

# Tout ce que j'<27>cris ici ne sera pas lu.
echo &quot;Ce que je tape ici sera lu.&quot;
</pre>

<p>
Les lignes de commentaire sont tout bonnement ignor<6F>es par
l'interpr<70>teur. Alors, allez-vous demander, <20> quoi servent-elles si
elles ne servent <20> rien&nbsp;? Elles sont indispensables pour tout
programmeur, car elles lui permettent de <20>&nbsp;commenter&nbsp;<3B> son
programme, c'est-<2D>-dire d'<27>crire ce qu'il veut, comme dans la marge d'un
livre. 
</p>

<p>
Les commentaires jouent pour beaucoup dans la lisibilit<69> d'un programme
par un humain. Car les lignes de commande pures sont relativement
aust<EFBFBD>res&nbsp;; des commentaires permettent de les d<>crire <20> l'intention
d'un <20>tre humain. 
</p>

<p>
Sans doute allez-vous vous demander quel <20>tre humain cela peut bien
int<EFBFBD>resser. Eh bien, quelqu'un d'autre que vous qui lit ce code&nbsp;;
ou bien vous-m<>me, dans un mois, un an, une d<>cennie, ou plus, quand
vous aurez tout oubli<6C> de ce programme et de son fonctionnement.
</p> 

<p>
N'h<>sitez donc pas <20> recourir abondamment aux commentaires, qui
accroissent la lisibilit<69> de votre programme, m<>me s'ils n'ont
absolument aucune influence directe sur son fonctionnement intrins<6E>que. 
</p>


<h3>Lignes blanches</h3>

<p>
Les lignes blanches ne sont pas interpr<70>t<EFBFBD>es non
plus. N'h<>sitez donc surtout pas <20> espacer votre script, les
lignes blanches ne consomment presque rien en termes d'espace disque, ce
n'est donc pas une ressource rare&nbsp;; et elles facilitent
consid<EFBFBD>rablement la lecture pour un <20>tre humain.
</p>

<h3>L'imp<6D>ratif de lisibilit<69></h3>

<p>
Pourquoi espacer son script&nbsp;? Pourquoi ins<6E>rer des
commentaires&nbsp;? Pour une seule et m<>me raison&nbsp;:
<strong>votre script doit <20>tre lisible</strong>. Pourquoi <20>tre
lisible&nbsp;? </p>

<p> D'abord, pour autrui&nbsp;: si d'autres gens lisent votre script, il
doit <20>tre intelligible, et les passages complexes doivent <20>tre
explicit<EFBFBD>s par des commentaires.</p>

<p> Ensuite, pour vous-m<>me&nbsp;; au moment o<> vous <20>crivez un
script, vous comprenez tout, naturellement&nbsp;; mais si vous le
relisez dans quelques mois, voire quelques ann<6E>es, les passages
obscurs risqueront d'<27>tre incompr<70>hensibles, ce qui est
particuli<EFBFBD>rement p<>nible quand on essaye de <em>d<>buguer</em>
un programme, c'est-<2D>-dire d'en corriger les erreurs.
</p>


<h2>Un script qui parle&nbsp;: la commande <code>echo</code></h2>
<p>
Maintenant que vous savez comment on peut ex<65>cuter un script, il s'agit
de le remplir... Commen<65>ons par ce qu'il y a de plus simple&nbsp;:
afficher du texte.
</p>

<h3>Hello World&nbsp;!</h3>

<p>
Traditionnellement, on commence par faire un programme qui affiche
simplement la ligne <20>&nbsp;Hello world&nbsp;<3B> (ce qui signifie en
anglais&nbsp;: bonjour au monde entier). Faites donc un fichier
<code>helloworld</code> contenant les lignes suivantes&nbsp;:
</p>

<pre>
#!/bin/sh

# Fichier &quot;helloworld&quot;
echo &quot;Hello world&quot;
</pre>

<p>
Ex<EFBFBD>cutez ensuite ce programme, par exemple en tapant, dans le r<>pertoire
o<EFBFBD> il se trouve&nbsp;:
</p>

<pre><span class="prompt">clipper ~ $</span> ./helloworld
Hello world</pre>

<p>
<EFBFBD>a y est, vous avez cr<63><72> votre premier programme&nbsp;! Lancez-le autant
de vous que vous voulez, vous avez bien m<>rit<69> d'<27>tre fier de vous.
</p>

<p>
Exercice&nbsp;: francisez ce script.
</p>


<h3>La commande <code>echo</code></h3>

<p>
La commande <code>echo</code> sert <20> afficher du texte. Chaque ligne de
texte est <20>crite sur une ligne <20> part. Exemple&nbsp;:
</p>

<pre>
#!/bin/sh
# Fichier &quot;bonjour&quot;

echo &quot;Bonjour... &quot;
echo &quot;Comment allez-vous ?&quot;
</pre>

<p class="continue">affiche les lignes suivantes&nbsp;:</p>

<pre>
Bonjour... 
Comment allez-vous ?
</pre>

<p class="continue">et non&nbsp;:</p>

<pre>
Bonjour... Comment allez-vous ?
</pre>


<h4>Annuler le retour chariot</h4>

<p>
Si vous voulez annuler le retour chariot qui a lieu par d<>faut <20> la fin
de toute commande <code>echo</code>, il faut utiliser l'option
<code>-n</code>. Le programme sera alors&nbsp;:
</p>

<pre>
#!/bin/sh

echo -n &quot;Bonjour...&quot;
echo &quot;Comment allez-vous ?&quot;
</pre>

<p class="continue">
Alors seulement, vous pourrez avoir&nbsp;:
</p>

<pre>
Bonjour... Comment allez-vous ?
</pre>


<h4>Citer des variables</h4>

<p>Faisons mieux encore&nbsp;: votre script va citer des variables. Pour
savoir ce que sont des variables, allez voir la page sur les <a
href="variable.html">variables</a>.</p> 

<p>La variable <code>USER</code> contient le login de
l'utilisateur&nbsp;; la variable <code>PWD</code> (pour <em>print
working directory</em>) affiche le r<>pertoire courant. Faisons donc le
script suivant&nbsp;:</p>

<pre>
#/bin/sh
# Fichier &quot;mon-pwd&quot;

echo &quot;Bonjour $USER...&quot;
echo &quot;Tu es actuellement dans le r<>pertoire $PWD.&quot;
</pre>

<p>Comme vous pouvez le remarquer, pour citer le contenu d'une variable,
on ajoute le signe dollar ($) devant son nom.</p>


<h2>Un script qui <20>coute&nbsp;: la commande <code>read</code></h2> 

<p>Parler c'est bien, <20>couter c'est mieux. Jusqu'ici, votre programme
est capable de parler, de dire bonjour, mais il n'est m<>me pas capable
de vous appeler par votre nom, tout juste par votre login, ce qui n'est
pas tr<74>s intime...</p>

<p>
Nous allons donc lui donner la facult<6C> d'<27>couter, gr<67>ce <20> la commande
<code>read</code>. Prenons le script suivant&nbsp;:
</p>

<pre>
#!/bin/sh
# Fichier &quot;mon-nom&quot;

echo &quot;Bonjour... Comment vous-appelez-vous ?&quot;
read nom
echo &quot;Je vous souhaite, $nom, de passer une bonne journ<72>e.&quot;
</pre>

<p>Vous connaissez d<>j<EFBFBD> la commande <code>echo</code>. La commande
<code>read</code> permet de lire des variables. Si vous ex<65>cutez ce
script, apr<70>s avoir affich<63> la ligne </p>

<pre>
Bonjour... Comment vous-appelez-vous ?
</pre>

<p class="continue">le shell va attendre que vous tapiez votre
nom. Tapez par exemple <code>Toto</code>, puis appuyez sur Entr<74>e, et
vous verrez&nbsp;:</p>

<pre>
Bonjour... Comment vous-appelez-vous ?
<em>Toto</em>
Je vous souhaite, Toto, de passer une bonne journ<72>e.</pre>

<div class="attention">
La commande <code>read</code> doit <20>tre suivie du seul nom de la
variable, <strong>non pr<70>c<EFBFBD>d<EFBFBD> du signe dollar</strong>. <em>Le signe
dollar ne doit pr<70>c<EFBFBD>der le nom de la variable que lorsque l'on cite son
contenu.</em>
</div>

<h3>Lire plusieurs variables</h3>

<p>
La commande <code>read</code> permet <20>galement de lire plusieurs
variables. Il suffit pour cela d'indiquer <20> la suite les noms des
diff<EFBFBD>rentes variables. Exemple&nbsp;:
</p>

<pre>
#!/bin/sh
# Fichier &quot;administration&quot;

echo &quot;<3B>crivez votre nom puis votre pr<70>nom :&quot;
read nom prenom
echo &quot;Nom : $nom&quot;
echo &quot;Pr<50>nom : $prenom&quot;
</pre>

<p>Vous aurez&nbsp;:</p>

<pre>
<EFBFBD>crivez votre nom puis votre pr<70>nom :
<em>Hugo Victor</em>
Nom : Hugo
Pr<EFBFBD>nom : Victor
</pre>


<h3>Appuyer sur Entr<74>e pour continuer</h3>

<p>Nous avons vu comment utiliser <code>read</code> avec un seul
argument et avec plusieurs arguments&nbsp;; il reste <20> voir l'usage de
<code>read</code> <em>sans</em> argument. Oui, c'est possible&nbsp;!
Cela <20>quivaut simplement <20> attendre un r<>action de l'utilisateur, mais
sans m<>moriser ce qu'il tape.</p>

<p> Concr<63>tement, cela est tr<74>s utile apr<70>s un message <20>&nbsp;Appuyez
sur Entr<74>e pour continuer.&nbsp;<3B> Exemple&nbsp;:</p>

<pre>
#!/bin/sh
# Fichier &quot;continuer&quot;

echo &quot;Quelle est la diff<66>rence entre un canard ?&quot;
echo &quot;(Appuyez sur Entr<74>e pour avoir la r<>ponse)&quot;
read
echo &quot;Les pattes, surtout la gauche.&quot;
</pre>

<h2>Poursuivre l'apprentissage de la programmation shell</h2>

<p>
Vous connaissez maintenant les bases de la programmation en shell. Vous
avez d<>j<EFBFBD> de quoi <20>crire de nombreux scripts qui peuvent vous faciliter
la vie de tous les jours. Pour cela, lorsque vous ressentez un besoin,
ne vous demandez pas si vous avez les connaissances requises pour <20>crire
un programme donn<6E>, mais plut<75>t <em>comment, <20> partir de vos
connaissances actuelles, vous pourriez le r<>aliser</em>.
</p>

<p>
Pour poursuivre votre apprentissage, vous pouvez passer <20> la lecture des
pages suivantes&nbsp;:
</p>

<ul>
<li> <a href="entreesortie.html">entr<74>e, sortie, redirection</a>&nbsp;:
faire interagir les <20>l<EFBFBD>ments du shell pour construire des programmes
<EFBFBD>volu<EFBFBD>s&nbsp;;</li>

<li> <a href="test.html">test et calcul arithm<68>tique</a>&nbsp;:
manipuler les valeurs de vrai et de faux pour orienter le parcours d'un
programme&nbsp;;</li>

<li> <a href="boucle.html">boucles et structures de contr<74>le</a>&nbsp;:
ma<EFBFBD>triser l'aiguillage d'un programme&nbsp;;</li>

<li> <a href="fonction.html">d<>finir et appeler des fonctions</a>&nbsp;:
all<EFBFBD>ger ses programmes et am<61>liorer leur qualit<69> en les concevant d'une
fa<EFBFBD>on modulaire.</li>

</ul>

<p>
Ou bien vous pouvez revenir <20> 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&nbsp;: Baptiste M<>l<EFBFBD>s. 
Derni<EFBFBD>re modification le <date value="$Date: 2005-09-07 23:00:04 $" />.
</div>

</body>
</html>