501 lines
16 KiB
Text
501 lines
16 KiB
Text
|
<?xml version="1.0" encoding="ISO-8859-1"?>
|
|||
|
|
<!DOCTYPE html
|
|||
|
|
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
|||
|
|
"tuteurs://DTD/tml.dtd">
|
|||
|
|
<html>
|
|||
|
|
<head>
|
|||
|
|
<title>Commandes</title>
|
|||
|
|
</head>
|
|||
|
|
<body>
|
|||
|
|
|
|||
|
|
<h1>Le shell en ligne de commande</h1>
|
|||
|
|
|
|||
|
|
<h2>Cr<43>er des processus</h2>
|
|||
|
|
|
|||
|
|
<p> Le shell a la facult<6C> de lancer de nombreux programmes, sinon
|
|||
|
|
tous. C'est une des raisons pour lesquelles on peut dire que c'est un
|
|||
|
|
outil extr<74>mement puissant.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<h3>Qu'est-ce qu'un processus ?</h3>
|
|||
|
|
|
|||
|
|
<p> Lancer un programme, c'est cr<63>er un
|
|||
|
|
<em>processus</em>. Tautologisons : <strong>un processus est une
|
|||
|
|
instance d'ex<65>cution d'un programme</strong>, c'est-<2D>-dire
|
|||
|
|
l'ex<65>cution particuli<6C>re d'un programme universel (<i>i.e</i> qui
|
|||
|
|
n'est pas r<>ductible <20> l'une de ses ex<65>cutions). </p>
|
|||
|
|
|
|||
|
|
<p>Par exemple, si je lance Mozilla, un processus se cr<63>e, du nom de
|
|||
|
|
<code>mozilla</code>. Ensuite, sans fermer ce programme, je lance une
|
|||
|
|
deuxi<EFBFBD>me fois Mozilla ; un nouveau processus se cr<63>e, du nom
|
|||
|
|
de <code>mozilla</code> <20>galement. J'ai donc deux processus
|
|||
|
|
distincts, m<>me s'ils concernent le m<>me programme. Et <20> chaque
|
|||
|
|
fois que je lance un programme, un processus se cr<63>e.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<h3>G<>n<EFBFBD>alogie des processus</h3>
|
|||
|
|
|
|||
|
|
<p> Dans notre exemple, nous avons deux processus
|
|||
|
|
<code>mozilla</code>. Ils sont ind<6E>pendants l'un de l'autre :
|
|||
|
|
quoi qu'il puisse se passer dans l'un, cela ne devrait pas influer sur
|
|||
|
|
le comportement de l'autre.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p> Toutefois, s'ils sont ind<6E>pendants l'un de l'autre, tous deux
|
|||
|
|
d<EFBFBD>pendent du processus qui les a lanc<6E>s. Eh oui, <strong>le shell
|
|||
|
|
est un programme comme un autre, donc chacune de ses ex<65>cutions
|
|||
|
|
correspond <20>galement <20> la cr<63>ation d'un processus</strong>. Si
|
|||
|
|
vous lancez trois shells en m<>me temps, par exemple dans trois
|
|||
|
|
terminaux diff<66>rents, vous aurez trois processus <code>shell</code>
|
|||
|
|
distincts. </p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Les processus entretiennent entre eux des relations de parent<6E>. Mais
|
|||
|
|
comme les processus ont tous le m<>me sexe, <strong>chaque processus
|
|||
|
|
n'a qu'un parent. Un processus peut avoir plusieurs enfants</strong>.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p> Le shell est, comme nous venons de le voir, <strong>un processus qui
|
|||
|
|
peut enfanter d'autres processus</strong>. Par exemple, <20> chaque fois
|
|||
|
|
que je tape <code>mozilla</code>, mon shell cr<63>e un processus
|
|||
|
|
<code>mozilla</code>. </p>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h3>Lancer des processus en arri<72>re-plan</h3>
|
|||
|
|
<p>
|
|||
|
|
<strong>Par d<>faut, le shell met le processus enfant en
|
|||
|
|
avant-plan</strong>. Cela veut dire que si je tape simplement :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~</span> mozilla
|
|||
|
|
</pre>
|
|||
|
|
|
|||
|
|
<p class="continue">
|
|||
|
|
le processus <code>mozilla</code> prend la main, et le shell ne
|
|||
|
|
r<EFBFBD>agit plus (il n'affiche m<>me plus l'invite de commande) avant
|
|||
|
|
la fin du processus enfant. Ce n'est que lorsque le processus
|
|||
|
|
<code>mozilla</code> prend fin (si je ferme ce programme, par exemple)
|
|||
|
|
que le shell reprend la main.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>Ce comportement par d<>faut n'est parfois pas tr<74>s pratique. Par
|
|||
|
|
exemple, si je veux lancer Mozilla, mais aussi Emacs et d'autres
|
|||
|
|
programmes qui s'ouvrent dans leur propre fen<65>tre, je suis oblig<69>
|
|||
|
|
d'ouvrir <20> chaque fois un nouveau terminal avec un nouveau shell, et
|
|||
|
|
ce uniquement pour y taper une commande, apr<70>s quoi le shell se
|
|||
|
|
retrouve inutilisable jusqu'<27> la fin de chacun de ces
|
|||
|
|
programmes. </p>
|
|||
|
|
|
|||
|
|
<p>Il faudrait donc que l'on puisse <strong>lancer des processus enfants en
|
|||
|
|
arri<EFBFBD>re-plan</strong>, de telle sorte que ces processus se lancent
|
|||
|
|
dans leur propre fen<65>tre et me permettent toutefois de dialoguer avec
|
|||
|
|
le shell sans avoir <20> :</p>
|
|||
|
|
<ul>
|
|||
|
|
<li> ouvrir un nouveau shell dans une nouvelle fen<65>tre ;</li>
|
|||
|
|
<li> attendre la fin de l'un de ces processus.</li>
|
|||
|
|
</ul>
|
|||
|
|
|
|||
|
|
<p>Pour cela, il faut ajouter le signe <20> & <3B> <20> la
|
|||
|
|
fin d'une ligne de commande. On peut ainsi taper :</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~</span> mozilla &
|
|||
|
|
<span class="prompt">chaland ~</span> mozilla &
|
|||
|
|
<span class="prompt">chaland ~</span>
|
|||
|
|
</pre>
|
|||
|
|
|
|||
|
|
<p class="continue">et de la sorte, un m<>me shell peut engendrer
|
|||
|
|
autant de processus que vous voulez.</p>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h3><3E>manciper un processus enfant</h3>
|
|||
|
|
<p>La vie est d<>j<EFBFBD> plus pratique comme cela. Mais parfois, on
|
|||
|
|
aimerait que le processus enfant survive au processus parent. Car par
|
|||
|
|
d<EFBFBD>faut, <strong>la mort d'un processus parent entra<72>ne celle de
|
|||
|
|
tous ses enfants</strong>. Par exemple, si le shell qui a enfant<6E> les
|
|||
|
|
deux processus <code>mozilla</code> vient <20> d<>c<EFBFBD>der (si je le
|
|||
|
|
ferme brutalement, ou s'il plante), les deux processus
|
|||
|
|
<code>mozilla</code> le suivront dans la mort. </p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Il faudrait donc qu'un processus parent puisse <20>manciper des
|
|||
|
|
processus enfants, pour que sa propre mort n'entra<72>ne pas les
|
|||
|
|
leurs. Pour cela, il faut utiliser les symboles
|
|||
|
|
<EFBFBD> &! <3B>. Par exemple, si je tape :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~</span> mozilla &!
|
|||
|
|
<span class="prompt">chaland ~</span> mozilla &!
|
|||
|
|
<span class="prompt">chaland ~</span>
|
|||
|
|
</pre>
|
|||
|
|
|
|||
|
|
<p class="continue">puis que je ferme brutalement le shell en tapant
|
|||
|
|
Ctrl-D et en ignorant d'<27>ventuels avertissements, le shell
|
|||
|
|
dispara<EFBFBD>tra, mais pas les processus <code>mozilla</code>. </p>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h2>Arguments et options</h2>
|
|||
|
|
<p> Jusqu'ici, l'exemple de processus enfant que nous avons pris
|
|||
|
|
<EFBFBD>tait relativement simple : il s'agissait de la commande
|
|||
|
|
<code>mozilla</code>, que l'on peut lancer en tapant simplement son
|
|||
|
|
nom. </p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Jusqu'ici, on peut se dire que la ligne de commande, c'est comme quand
|
|||
|
|
on clique sur une ic<69>ne, sauf que c'est plus fatigant. Effectivement,
|
|||
|
|
pourquoi se fatiguer <20> taper une suite de caract<63>res quand il
|
|||
|
|
suffit d'appuyer une ou deux fois sur le bouton d'une souris ?
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
C'est dans l'usage des arguments et des options que la ligne de commande
|
|||
|
|
commence <20> r<>v<EFBFBD>ler une partie de sa puissance, et de sa nette
|
|||
|
|
sup<EFBFBD>riorit<EFBFBD> sur les interfaces graphiques.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h3>Les arguments</h3>
|
|||
|
|
<p>Un argument est une suite de caract<63>res que l'on donne <20> une
|
|||
|
|
commande et qui lui indique comment se comporter. Les options sont un
|
|||
|
|
type d'argument. </p>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h4>Exemples</h4>
|
|||
|
|
|
|||
|
|
<p>Par exemple, si je veux ouvrir le fichier <code>hermocrate.txt</code>
|
|||
|
|
avec l'<27>diteur de texte <code>nano</code>, j'ai le choix entre deux
|
|||
|
|
possibilit<EFBFBD>s :</p>
|
|||
|
|
|
|||
|
|
<ul>
|
|||
|
|
<li> ou bien je tape :
|
|||
|
|
<pre><span class="prompt">chaland ~</span> nano </pre>
|
|||
|
|
puis Ctrl-R pour indiquer d'ouvrir un fichier, puis Ctrl-T
|
|||
|
|
pour voir la liste des fichiers, puis les fl<66>ches pour choisir mes
|
|||
|
|
fichiers, enfin Entr<74>e pour s<>lectionner
|
|||
|
|
<code>hermocrate.txt</code> — mais tout cela est bien
|
|||
|
|
fastidieux ; </li>
|
|||
|
|
|
|||
|
|
<li> ou bien je tape directement :
|
|||
|
|
<pre><span class="prompt">chaland ~</span> nano hermocrate.txt</pre>
|
|||
|
|
</li>
|
|||
|
|
</ul>
|
|||
|
|
|
|||
|
|
<p>Ou encore, pour reprendre l'exemple de Mozilla, si je veux aller voir
|
|||
|
|
la page des tuteurs et que ce n'est pas ma page d'accueil par d<>faut
|
|||
|
|
(ce qui est un tort !), je peux taper :</p>
|
|||
|
|
|
|||
|
|
<pre><span class="prompt">chaland ~</span> mozilla http://www.tuteurs.ens.fr/</pre>
|
|||
|
|
|
|||
|
|
<h3>Les options</h3>
|
|||
|
|
<p>
|
|||
|
|
Les options sont un cas particulier d'arguments, qui donnent au
|
|||
|
|
programme que l'on ex<65>cute toutes sortes d'information, souvent
|
|||
|
|
plus ou moins p<>riph<70>riques, en g<>n<EFBFBD>ral moins importantes
|
|||
|
|
que les arguments.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>Sous Unix, les options commencent g<>n<EFBFBD>ralement par un
|
|||
|
|
tiret. Certaines options peuvent <20> leur tour prendre des
|
|||
|
|
arguments.</p>
|
|||
|
|
|
|||
|
|
<p>Par exemple, si l'on veut ouvrir un fichier au format MS-DOS, on peut
|
|||
|
|
taper :</p>
|
|||
|
|
|
|||
|
|
<pre><span class="prompt">chaland ~</span> nano -D hermocrate.txt</pre>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h4>Options <20> arguments</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
L'option <code>-r</code> de <code>nano</code> prend un argument ;
|
|||
|
|
ainsi, si l'on veut que Nano coupe les lignes au bout de 75
|
|||
|
|
caract<EFBFBD>res, on doit ouvrir Nano en tapant :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre><span class="prompt">chaland ~</span> nano -r 75 hermocrate.txt</pre>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h4>Options <20> nom long</h4>
|
|||
|
|
|
|||
|
|
<p>Traditionnellement, et pur des raisons de concision, la majorit<69>
|
|||
|
|
des options, sous Unix, est compos<6F>e d'un tiret et d'une seule
|
|||
|
|
lettre. Toutefois, pour des raisons pratiques, il peut <20>galement
|
|||
|
|
exister des noms d'option longs ; ils sont en g<>n<EFBFBD>ral
|
|||
|
|
pr<EFBFBD>c<EFBFBD>d<EFBFBD>s, non d'un, mais de deux tirets. Exemple :</p>
|
|||
|
|
|
|||
|
|
<pre><span class="prompt">chaland ~</span> nano --fill=75 hermocrate.txt</pre>
|
|||
|
|
|
|||
|
|
<p class="continue">Dans cet exemple, il se trouve que l'option <20> nom
|
|||
|
|
long <code>--fill=</code> <20>quivaut <20> l'option <20> nom
|
|||
|
|
court <code>-r</code>. Mais toutes les commandes courtes n'ont pas
|
|||
|
|
syst<EFBFBD>matiquement leur <20>quivalent <20> nom long, et vice versa.</p>
|
|||
|
|
|
|||
|
|
<h2>Jokers et citations</h2>
|
|||
|
|
|
|||
|
|
<h3><a name="raccourcis">Raccourcis pour les noms de fichiers : les
|
|||
|
|
jokers</a></h3>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Il est souvent ennuyeux d'avoir <20> taper une longue liste de fichiers
|
|||
|
|
pour les donner en arguments <20> une commande, comme :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>cc -o foo bar.c gee.c buz.c gog.c</pre>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Pour <20>viter ces probl<62>mes, on peut utiliser des <em>jokers</em>
|
|||
|
|
(<em>wildcards</em> en anglais). Pourquoi ce nom ? Eh bien, dans
|
|||
|
|
certains jeux de cartes, le joker permet de remplacer n'importe quelle
|
|||
|
|
carte ; dans le shell, les jokers permettent de remplacer n'importe
|
|||
|
|
quel caract<63>re ou n'importe quelle s<>quence de caract<63>res.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Il existe principalement trois types de jokers :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<ul>
|
|||
|
|
<li> l'<27>toile (*), qui remplace n'importe quelle s<>quence de
|
|||
|
|
caract<EFBFBD>res ;</li>
|
|||
|
|
<li> le point d'interrogation, qui remplace n'importe quel
|
|||
|
|
caract<EFBFBD>re ;</li>
|
|||
|
|
<li> les crochets ([]), qui remplacent n'importe quel caract<63>re d'une
|
|||
|
|
liste d<>termin<69>e.</li>
|
|||
|
|
</ul>
|
|||
|
|
|
|||
|
|
<h4>L'<27>toile : *</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Une <strong><3E>toile</strong> <code>*</code> dans un nom de fichier est
|
|||
|
|
interpr<EFBFBD>t<EFBFBD>e par le shell comme <20><>n'importe quelle s<>quence de
|
|||
|
|
caract<EFBFBD>res<EFBFBD><EFBFBD> (mais <20>a ignore les fichiers dont le nom commence par un
|
|||
|
|
point). Exemple :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>cc -o foo *.c</pre>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Pour interpr<70>ter l'<27>toile, le shell va faire la liste de tous les noms de
|
|||
|
|
fichiers du r<>pertoire courant qui ne commencent pas par <code>.</code> et
|
|||
|
|
qui finissent par <code>.c</code>. Ensuite, il remplace <code>*.c</code>
|
|||
|
|
par cette liste (tri<72>e par ordre alphab<61>tique) dans la ligne de commande, et
|
|||
|
|
ex<EFBFBD>cute le r<>sultat, c'est-<2D>-dire par exemple<6C>:
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>cc -o foo bar.c buz.c foo.c gee.c gog.c</pre>
|
|||
|
|
|
|||
|
|
<h4>Le point d'interrogation : ?</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
On a aussi le <strong>point d'interrogation</strong> <code>?</code>, qui
|
|||
|
|
remplace un (et exactement un) caract<63>re quelconque (sauf un point en d<>but
|
|||
|
|
de nom). Par exemple, <code>ls *.?</code> liste tous les dont l'extension
|
|||
|
|
ne comporte qu'un caract<63>re (<code>.c</code>, <code>.h</code>...).
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<h4>Les crochets : []</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
La forme <code>[abcd]</code> remplace un caract<63>re quelconque parmi
|
|||
|
|
<code>a</code>, <code>b</code>, <code>c</code>, <code>d</code>. Enfin,
|
|||
|
|
<code>[^abcd]</code> remplace un
|
|||
|
|
caract<EFBFBD>re quelconque qui ne se trouve pas parmi <code>a</code>, <code>b</code>,
|
|||
|
|
<code>c</code>, <code>d</code>.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<h4>Exemple</h4>
|
|||
|
|
|
|||
|
|
<pre>echo /users/*</pre>
|
|||
|
|
|
|||
|
|
<p class="continue">
|
|||
|
|
affiche <20> peu pr<70>s la m<>me chose que
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>ls /users</pre>
|
|||
|
|
|
|||
|
|
<p class="continue">
|
|||
|
|
(La commande <code>echo</code> se contente d'afficher ses arguments.)
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<div class="attention">
|
|||
|
|
<p>
|
|||
|
|
&icone.attention; Attention<6F>:
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<ul>
|
|||
|
|
|
|||
|
|
<li><strong>C'est le shell qui fait le remplacement des arguments
|
|||
|
|
contenant un joker</strong>. On ne peut donc pas faire <code>mv *.c
|
|||
|
|
*.bak</code>, car le shell va passer <20> <code>mv</code> les arguments
|
|||
|
|
<code>foo.c bar.c foo.bak bar.bak</code>, et <code>mv</code> ne sait pas
|
|||
|
|
quel fichier remplacer. </li>
|
|||
|
|
|
|||
|
|
<li> <strong>Attention aux espaces</strong>. Si vous tapez <code>rm *
|
|||
|
|
~</code>, le shell remplace l'<27>toile par la liste des fichiers pr<70>sents,
|
|||
|
|
et ils seront tous effac<61>s. Si vous tapez <code>rm *~</code>, seuls les
|
|||
|
|
fichiers dont le nom finit par un tilde seront effac<61>s. </li>
|
|||
|
|
|
|||
|
|
</ul>
|
|||
|
|
</div>
|
|||
|
|
|
|||
|
|
<div class="encadre">
|
|||
|
|
<p>
|
|||
|
|
<strong>Interlude :</strong> comment effacer un fichier nomm<6D>
|
|||
|
|
<code>?*</code><3E>? On ne peut pas taper <code>rm<72>?*</code> car le shell
|
|||
|
|
remplace <code>?*</code> par la liste de tous les fichiers du r<>pertoire
|
|||
|
|
courant. On peut taper <code>rm -i *</code> qui supprime tous les
|
|||
|
|
fichiers, mais en demandant confirmation <20> chaque fichier. On r<>pond
|
|||
|
|
<code>n</code> <20> toutes les questions sauf <code>rm: remove <20>?*</code>.
|
|||
|
|
Autre m<>thode: utiliser les m<>canismes de citation.
|
|||
|
|
</p>
|
|||
|
|
</div>
|
|||
|
|
|
|||
|
|
<h3><a name="quotation">Contourner les jokers : la citation (<i
|
|||
|
|
lang="en">quotation</i>)</a></h3>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Avec tous ces caract<63>res sp<73>ciaux, comment faire pour passer des
|
|||
|
|
arguments bizarres <20> une commande ? Par exemple, comment faire
|
|||
|
|
afficher un point d'interrogation suivi d'une <20>toile et d'un dollar par
|
|||
|
|
<code>echo</code> ?</p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
On ne peut pas les taper directement dans la ligne de commande (ici,
|
|||
|
|
avec le shell <code>zsh</code>), car le shell essaye de les interpr<70>ter
|
|||
|
|
comme des jokers :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre><span class="prompt">chaland ~</span> echo ?*$
|
|||
|
|
zsh: no matches found: ?*$</pre>
|
|||
|
|
|
|||
|
|
<p> Il faut donc indiquer au shell de ne pas interpr<70>ter ces caract<63>res
|
|||
|
|
comme des jokers. Pour cela, nous allons utiliser des m<>canismes fournis
|
|||
|
|
par le shell : les <i lang="en">quotations</i> (mot anglais
|
|||
|
|
signifiant <em>citation</em>).
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Les m<>canismes de citation sont les suivants :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<ul>
|
|||
|
|
<li> le backslash (<code>\</code>), qui prot<6F>ge un caract<63>re de
|
|||
|
|
l'interpr<70>tation par le shell ;</li>
|
|||
|
|
<li> les apostrophes ou <i lang="en">simple quotes</i>
|
|||
|
|
(<code>'</code>), qui prot<6F>gent une cha<68>ne de caract<63>res de
|
|||
|
|
l'interpr<70>tation par le shell ;</li>
|
|||
|
|
<li> les guillemets doubles ou <i lang="en">double quotes</i>
|
|||
|
|
(<code>"</code>), qui prot<6F>gent <20>galement une cha<68>ne de caract<63>res
|
|||
|
|
de l'interpr<70>tation par le shell, mais avec plus de souplesse que les
|
|||
|
|
pr<EFBFBD>c<EFBFBD>dents ;</li>
|
|||
|
|
<li> les <i lang="en">backquotes</i> (<code>`</code>), qui cite la
|
|||
|
|
sortie d'une commande.</li>
|
|||
|
|
</ul>
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
<h4>Le backslash (<code>\</code>)</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Il suffit de pr<70>c<EFBFBD>der un caract<63>re sp<73>cial d'un backslash, et le shell
|
|||
|
|
remplace ces deux caract<63>res par le caract<63>re sp<73>cial seul. <20>videmment, le
|
|||
|
|
backslash est lui-m<>me un caract<63>re sp<73>cial.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Exemples :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~ $</span> echo \?\*\$
|
|||
|
|
?*$
|
|||
|
|
<span class="prompt">chaland ~ $</span> echo \\\?\\\*\\\$
|
|||
|
|
\?\*\$</pre>
|
|||
|
|
|
|||
|
|
<h4>Les apostrophes ou simples quotes (<code>'</code>)</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Un autre moyen est d'inclure une cha<68>ne de caract<63>res entre apostrophes
|
|||
|
|
(simples quotes) <code>'</code>. Tout ce qui se trouve entre deux
|
|||
|
|
apostrophes sera pass<73> tel quel par le shell <20> la
|
|||
|
|
commande. Exemple :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~ $</span> echo '$?*'
|
|||
|
|
$?*</pre>
|
|||
|
|
|
|||
|
|
<h4>Les guillemets doubles ou doubles quotes (<code>"</code>)</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Les guillemets se comportent comme les apostrophes, <20> une exception pr<70>s: les
|
|||
|
|
dollars et les backslashes sont interpr<70>t<EFBFBD>s entre les guillemets.
|
|||
|
|
Exemple :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~ $</span> echo "$HOME/*"
|
|||
|
|
/users/87/maths/doligez/*</pre>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Une technique utile: Quand on juxtapose deux cha<68>nes de caract<63>res
|
|||
|
|
quot<EFBFBD>es, le shell les concat<61>ne, et elles ne forment qu'un argument.
|
|||
|
|
Exemple :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~ $</span> echo "'"'"'
|
|||
|
|
'"</pre>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Quant aux interactions plus compliqu<71>es (backslashes <20> l'int<6E>rieur des
|
|||
|
|
guillemets, guillemets <20> l'int<6E>rieur des apostrophes, etc.), le meilleur moyen
|
|||
|
|
de savoir si <20>a donne bien le r<>sultat attendu est d'essayer. La commande
|
|||
|
|
<code>echo</code> est bien utile dans ce cas.
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<h4>Les backquotes (<code>`</code>)</h4>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
Derni<EFBFBD>re forme de citation : <code>`<em>commande</em>`</code>. Le
|
|||
|
|
shell ex<65>cute la <em>commande</em> indiqu<71>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 :
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~ $</span> echo `ls`
|
|||
|
|
Mail News bin foo lib misc mur notes.aux notes.dvi notes.log
|
|||
|
|
notes.tex planar text
|
|||
|
|
<span class="prompt">chaland ~ $</span> ls -l `which emacs`
|
|||
|
|
-rwxr-xr-t 1 root taff 978944 Jul 16 1991 /usr/local/bin/emacs</pre>
|
|||
|
|
|
|||
|
|
<p>
|
|||
|
|
La commande <code>which <em>cmd</em></code> employ<6F>e ci-dessus affiche sur sa
|
|||
|
|
sortie le nom absolu du fichier ex<65>cut<75> par le shell quand on lance la
|
|||
|
|
commande it <em>cmd</em><3E>:
|
|||
|
|
</p>
|
|||
|
|
|
|||
|
|
<pre>
|
|||
|
|
<span class="prompt">chaland ~ $</span> which emacs
|
|||
|
|
/usr/local/bin/emacs</pre>
|
|||
|
|
|
|||
|
|
|
|||
|
|
|
|||
|
|
<p>Vous <20>tes maintenant en mesure de faire ces <a
|
|||
|
|
href="&url.tuteurs;unix/exercices/">exercices</a> pour vous
|
|||
|
|
entra<EFBFBD>ner.</p>
|
|||
|
|
|
|||
|
|
|
|||
|
|
<div class="metainformation">
|
|||
|
|
Bas<EFBFBD> sur un polycopi<70> de Roberto Di Cosmo, Xavier Leroy et Damien Doligez.
|
|||
|
|
Modifications : Nicolas George, Baptiste M<>l<EFBFBD>s.
|
|||
|
|
Derni<EFBFBD>re modification le <date value="$Date: 2005-05-31 11:33:37 $" />.
|
|||
|
|
</div>
|
|||
|
|
|
|||
|
|
</body>
|
|||
|
|
</html>
|