Ajout de presque tous les exercices Unix et de leurs corrigés
This commit is contained in:
jriou
parent
41f9015549
commit
67e9b0cd55
14 changed files with 3923 additions and 34 deletions
356
unix/exercices/enchainer.tml
Normal file
356
unix/exercices/enchainer.tml
Normal file
|
|
@ -0,0 +1,356 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>Pipes</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
|
||||
<h1><em>Pipes</em>, jokers et redirections</h1>
|
||||
|
||||
|
||||
<h2><a name="cat">La commande <tt>cat</tt></a></h2>
|
||||
|
||||
|
||||
<p>On n'a pas traité de la commande <tt>cat</tt> dans la page consacrée aux
|
||||
commandes de base, parce que <tt>cat</tt> s'utilise le plus souvent avec des
|
||||
redirections.</p>
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#cat1">&icone.solution;
|
||||
</a>
|
||||
Comment visualiser deux fichiers l'un après l'autre à l'aide de la commande
|
||||
<tt>cat</tt> ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#cat2">&icone.solution;
|
||||
</a>
|
||||
Comment faire une copie d'un fichier sans utiliser <tt>cp</tt> ni ouvrir
|
||||
d'éditeur de texte ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#cat3">&icone.solution;
|
||||
</a>
|
||||
Utiliser <tt>cat</tt> pour écrire un peu de texte et mettre le résultat
|
||||
dans un fichier <tt>notes</tt>.</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#cat4">&icone.solution;
|
||||
</a>
|
||||
Quelle différence y a-t-il entre
|
||||
<pre>
|
||||
cat bla blo > blu
|
||||
</pre>
|
||||
<p class="continue">et</p>
|
||||
<pre>
|
||||
cat bla blo >> blu
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Que se passe-t-il, pour chaque ligne, selon que le fichier <tt>blu</tt>
|
||||
existe ou n'existe pas ?</p> </li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#cat5">&icone.solution;
|
||||
</a>
|
||||
Comment obtenir un fichier <tt>blo</tt> qui corresponde à un fichier
|
||||
<tt>bla</tt> dont les lignes seraient désormais numérotées ?</li>
|
||||
|
||||
</ol>
|
||||
|
||||
<h2> <a name="jokers">Jokers et expressions régulières</a> </h2>
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#jokers1">&icone.solution;
|
||||
</a>
|
||||
Vous avez chez vous des fichiers appelés <tt>essai1</tt>, <tt>essai2</tt>,
|
||||
<tt>essai3</tt> et <tt>essai4</tt>. Comment les effacer en une seule ligne
|
||||
de commande ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#jokers2">&icone.solution;
|
||||
</a>
|
||||
Dans mon répertoire d'accueil, j'ai un certain nombre de fichiers avec un
|
||||
suffixe <tt>.c</tt>. Je désire les regrouper dans un répertoire que
|
||||
j'appelerai <tt>C/</tt>. Quelles sont les commandes que je dois
|
||||
taper ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#jokers3">&icone.solution;
|
||||
</a>
|
||||
Vous désirez regrouper dans un répertoire <tt>Rangement</tt> les fichiers
|
||||
dont le nom contient un caractère minuscule suivi d'un caractère majuscule.
|
||||
Quelle(s) est/sont la/les commande(s) à donner ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#jokers4">&icone.solution;
|
||||
</a>
|
||||
Même chose avec les fichiers dont le nom contient trois voyelles à la
|
||||
suite.</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#jokers5">&icone.solution;
|
||||
</a>
|
||||
En utilisant <tt>ls</tt> et <tt>grep</tt>, affichez la liste des fichiers
|
||||
dans <tt>/bin</tt> dont le nom :
|
||||
|
||||
<ul>
|
||||
|
||||
<li> Commence par «a» et dont la deuxième lettre est «s» ou «t»;</li>
|
||||
|
||||
<li> Contient «un» et se termine par «t»;</li>
|
||||
|
||||
<li> Contient «gre» ou «st».</li>
|
||||
|
||||
<li> Contient exactement deux lettres «m»;</li>
|
||||
|
||||
<li> Contient au moins deux lettres «m»;</li>
|
||||
|
||||
<li> Contient au moins quatre caractères et aucun chiffre;</li>
|
||||
|
||||
<li> Est constitué de deux lettres exactement;</li>
|
||||
|
||||
<li> Commence et finit par un chiffre.</li>
|
||||
|
||||
</ul></li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#jokers6">&icone.solution;
|
||||
</a>
|
||||
Comment éliminer les lignes vides dans un fichier ? Comment éliminer
|
||||
les lignes ne contenant que des blancs ?</li>
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
|
||||
|
||||
<h2><a name="germinal">Exercices sur <em>Germinal</em></a></h2>
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#germinal1">&icone.solution;
|
||||
</a> Combien de
|
||||
fois le mot «mine» apparaît dans chaque chapitre de la première partie de
|
||||
<em>Germinal</em> ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#germinal2">&icone.solution;
|
||||
</a>Combien y
|
||||
a-t-il de lignes blanches dans <tt>zola1.txt</tt> ?</li>
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
<h2><a name="headtail"><tt>head</tt> et <tt>tail</tt></a></h2>
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#headtail1">&icone.solution;
|
||||
</a> Affichez
|
||||
les 15 premières lignes du fichier <tt>/etc/hosts</tt>, les 15 dernières
|
||||
lignes, toutes les lignes à partir de la quinzième, les lignes 15 à 20.
|
||||
|
||||
<div class="attention">
|
||||
<h1>&icone.attention; Attention &icone.attention;</h1>
|
||||
Placez-vous sur clipper pour faire cet exercice. En effet, les
|
||||
<tt>/etc/hosts</tt> des autres machines sont beaucoup plus petits (en
|
||||
particulier peuvent faire moins de 15 lignes).
|
||||
</div></li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#headtail2">&icone.solution;
|
||||
</a> Récupérer
|
||||
les lignes 5 à 9 d'un fichier de 12 lignes.</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#headtail4">&icone.solution;
|
||||
</a> Comment
|
||||
afficher la cinquième ligne d'un fichier ?</li>
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
|
||||
<h2><a name="syst">Filtres et redirections</a></h2>
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst1">&icone.solution;
|
||||
</a>
|
||||
Créez un fichier dont chaque ligne commence par un chiffre, suivi d'un
|
||||
slash (<tt>/</tt>), puis d'un ou plusieurs mots.
|
||||
|
||||
<ol>
|
||||
|
||||
<li> Affichez les lignes de ce fichier triées en ordre croissant, suivant
|
||||
le nombre placé en début de ligne;</li>
|
||||
|
||||
<li> Éliminez de chaque ligne le chiffre et le caractère «<tt>/</tt>»;</li>
|
||||
|
||||
<li> Triez ces lignes par ordre alphabétique inverse.</li>
|
||||
|
||||
</ol></li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst2">&icone.solution;
|
||||
</a> Combien de
|
||||
fichiers de configuration avez-vous ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst3">&icone.solution;
|
||||
</a> Combien de
|
||||
répertoires de configuration avez-vous ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst4">&icone.solution;
|
||||
</a>
|
||||
Comment mettre dans un fichier la liste de tous les fichiers de
|
||||
l'arborescence à partir du répertoire courant ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst5">&icone.solution;
|
||||
</a> Créez un
|
||||
fichier <tt>liste</tt> contenant la liste de tous vos fichiers, avec leur
|
||||
taille, leurs droits, etc.</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst6">&icone.solution;
|
||||
</a>
|
||||
Comment afficher uniquement les fichiers du répertoire courant qui sont des
|
||||
liens symboliques ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst7">&icone.solution;
|
||||
</a> Combien de
|
||||
lignes contiennent le mot «<em>file</em>» dans la page de man de
|
||||
<tt>syst</tt> ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst8">&icone.solution;
|
||||
</a> Quels sont les
|
||||
dix plus gros fichiers de <tt>/usr/bin/</tt> ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#syst9">&icone.solution;
|
||||
</a>
|
||||
Pour chaque ligne du fichier <tt>/etc/hosts</tt>, affichez :
|
||||
|
||||
<ul>
|
||||
|
||||
<li> Le cinquième caractère;</li>
|
||||
|
||||
<li> Les caractères 5 à 10, et le treizième;</li>
|
||||
|
||||
<li> Tous les caractères à partir du quinzième.</li>
|
||||
|
||||
</ul></li>
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
|
||||
|
||||
<h2><a name="yp">Exercices sur les pages jaunes</a></h2>
|
||||
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#yp2">&icone.solution;
|
||||
</a>Combien de
|
||||
personnes de la promotion 1996 ont un login commençant par «l» ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#yp3">&icone.solution;
|
||||
</a>Est-ce que des
|
||||
gens des promotions de la décennie 1980 ont encore un compte sur clipper ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#yp4">&icone.solution;
|
||||
</a>Combien y a-t-il
|
||||
de comptes d'élèves, magistériens, etc (appartenant à une promotion) sur
|
||||
clipper ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#yp5">&icone.solution;
|
||||
</a>Classer les
|
||||
comptes de ces utilisateurs par numéro d'UID.</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#yp6">&icone.solution;
|
||||
</a>
|
||||
Affichez le login des personnes ayant <tt>zsh</tt> comme shell de login.</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#yp7">&icone.solution;
|
||||
</a>
|
||||
Affichez le nom et le prénom des personnes ayant un compte sur
|
||||
<tt>clipper</tt>, et dont le nom de famille contient au moins 2 voyelles
|
||||
côte à côte. Compter ces personnes.</li>
|
||||
|
||||
|
||||
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
|
||||
<h2><a name="divers">Divers</a></h2>
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#divers1">&icone.solution;
|
||||
</a>
|
||||
Comment conserver les informations concernant le disque dans un
|
||||
fichier ?</li>
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#divers3">&icone.solution;
|
||||
</a>
|
||||
Comment connaître la dernière date de connexion au système d'un utilisateur
|
||||
de login <tt>martin</tt> ?</li>
|
||||
|
||||
<!-- <p>
|
||||
<li> <a href="solutions/enchainer-sol.html#divers4">&icone.solution;
|
||||
</a>
|
||||
Créez chez vous un fichier contenant des mots (sur le modèle d'un carnet de
|
||||
vocabulaire), un par ligne, avec des répétitions; par exemple :
|
||||
|
||||
<pre>
|
||||
Pomme
|
||||
Poire
|
||||
Cassis
|
||||
Pomme
|
||||
Fraise
|
||||
Orange
|
||||
Citron
|
||||
</pre>
|
||||
|
||||
Utilisez la commande <tt>uniq</tt> :
|
||||
|
||||
<ul>
|
||||
<li> Pour éliminer les lignes redondantes (dans notre exemple, la ligne
|
||||
«Pomme» en double exemplaire);</li>
|
||||
|
||||
<li> Pour donner le nombre d'occurrences de chaque ligne;</li>
|
||||
|
||||
<li> Pour ne faire apparaître que le ou les mots redondants avec le nombre
|
||||
d'occurrences; ici, ce sera : <br>
|
||||
|
||||
<tt> 2 Pomme </tt>
|
||||
|
||||
|
||||
</ul>
|
||||
!-->
|
||||
|
||||
<li> <a href="solutions/enchainer-sol.html#divers5">&icone.solution;
|
||||
</a>
|
||||
Affichez le type des fichiers <tt>/etc/passwd</tt>,
|
||||
<tt>/usr/include/stdio.h</tt>, <tt>/bin/ls</tt> et de votre répertoire de
|
||||
travail.</li>
|
||||
|
||||
</ol>
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Anonyme, Joël Riou. Dernière modification le 2002-12-08.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
|
||||
|
|
@ -10,23 +10,22 @@
|
|||
|
||||
<h1>Exercices sur <code>grep</code></h1>
|
||||
|
||||
<p>
|
||||
Ces exercices sont des questions de cours : les solutions se trouvent
|
||||
toutes dans les <a href="&url.tuteurs;unix/divers.html#man"
|
||||
target="_top">pages de man</a> des commandes en question. On suppose donc
|
||||
connues les commandes de <a href="&url.tuteurs;unix/fichiers.html#less"
|
||||
target="_top">less</a>, qui servent à se déplacer dans les pages de man...
|
||||
Testez les commandes sur des fichiers et répertoires d'essai pour vous faire
|
||||
la main et comprendre ce qui se passe. Pour une présentation élémentaire de
|
||||
<code>grep</code>, vous pouvez aller lire le <a
|
||||
href="&url.tuteurs;unix/chercher.html">cours</a>.
|
||||
</p>
|
||||
<p> Ces exercices sont des questions de cours : les solutions se
|
||||
trouvent toutes dans les <a
|
||||
href="&url.tuteurs;unix/divers.html#man">pages de man</a> des commandes
|
||||
en question. On suppose donc connues les commandes de <a
|
||||
href="&url.tuteurs;unix/fichiers.html#less">less</a>, qui
|
||||
servent à se déplacer dans les pages de man... Testez les commandes sur
|
||||
des fichiers et répertoires d'essai pour vous faire la main et comprendre
|
||||
ce qui se passe. Pour une présentation élémentaire de <code>grep</code>,
|
||||
vous pouvez aller lire le <a
|
||||
href="&url.tuteurs;unix/chercher.html">cours</a>. </p>
|
||||
|
||||
<p>
|
||||
Pour voir la solution, cliquer sur le bouton &icone.solution;.
|
||||
</p>
|
||||
|
||||
-<h2><a name="options">Les options de <code>grep</code></a></h2>
|
||||
<h2><a name="options">Les options de <code>grep</code></a></h2>
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -62,18 +62,9 @@ Les corrig
|
|||
<li> <a href="find.html">find</a></li>
|
||||
</ul>
|
||||
|
||||
<hr />
|
||||
<h2>Les exercices qui suivent n'ont pas encore été remis à
|
||||
jour !</h2>
|
||||
<hr />
|
||||
|
||||
|
||||
<h2><em>Pipes</em>, redirections et expansion des noms de fichiers</h2>
|
||||
|
||||
<p>Une partie des exercices de cette section ne sont pas encore corrigés
|
||||
(dernier exercice des filtres et redirections, deux exercices à propos
|
||||
des pages jaunes).</p>
|
||||
|
||||
<ol>
|
||||
<li> <a href="enchainer.html#cat">La commande <code>cat</code></a></li>
|
||||
<li> <a href="enchainer.html#jokers">Jokers et expressions
|
||||
|
|
@ -88,6 +79,11 @@ r
|
|||
|
||||
</ol>
|
||||
|
||||
<hr />
|
||||
<h2>Les exercices qui suivent n'ont pas encore été remis à
|
||||
jour !</h2>
|
||||
<hr />
|
||||
|
||||
|
||||
<h2>Système</h2>
|
||||
|
||||
|
|
|
|||
|
|
@ -20,50 +20,50 @@ tuteurs</a>.
|
|||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less1">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less1">&icone.solution;
|
||||
</a> Comment fait-on pour obtenir une page d'aide avec
|
||||
<code>less</code> ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less2">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less2">&icone.solution;
|
||||
</a> Comment examiner plusieurs fichiers à la suite ?
|
||||
Comment passe-t-on au suivant ? Comment revient-on au précédent ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less3">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less3">&icone.solution;
|
||||
</a> Quelles sont les commandes différentes qui permettent de
|
||||
quitter <code>less</code> ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less4">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less4">&icone.solution;
|
||||
</a> Comment dire à <code>less</code> d'ouvrir le fichier en
|
||||
plaçant en haut de l'écran la ligne <em>n</em> ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less5">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less5">&icone.solution;
|
||||
</a> Comment dire à <code>less</code> d'ouvrir le fichier en
|
||||
plaçant en haut de l'écran la première ligne où apparaît un motif
|
||||
donné ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less6">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less6">&icone.solution;
|
||||
</a> Quelles sont les deux commandes de <code>less</code> qui
|
||||
permettent de chercher un motif dans un fichier, respectivement après et avant
|
||||
la position courante ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less7">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less7">&icone.solution;
|
||||
</a> Comment dire à <code>less</code> de chercher le mot à
|
||||
partir de la première ligne du fichier, et ce où que l'on soit dans le
|
||||
fichier ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less8">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less8">&icone.solution;
|
||||
</a> Que se passe-t-il si l'on cherche le motif
|
||||
suivant : «toTo» en donnant l'option <code>-i</code> à
|
||||
<code>less</code> ? Quelle option faut-il mettre à la place de
|
||||
<code>-i</code> pour chercher <code>toTo</code> tout en ignorant la casse des
|
||||
caractères ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less9">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less9">&icone.solution;
|
||||
</a> Quelles sont les commandes qui permettent d'aller à la
|
||||
prochaine (resp. précédente) occurence du motif recherché à travers tous les
|
||||
fichiers édités ?</li>
|
||||
|
||||
<li> <a href="solutions/less_sol.html#less10">&icone.solution;
|
||||
<li> <a href="solutions/less-sol.html#less10">&icone.solution;
|
||||
</a> Comment chercher dans un fichier le caractère
|
||||
<code>/</code> ?</li>
|
||||
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ Que faut-il faire
|
|||
</li>
|
||||
|
||||
<li> <a href="solutions/mkdir_cd-sol.html#mk5">&icone.solution;
|
||||
</a> Est-ce que <code>rmdir</code> peut prendre des
|
||||
</a> Est-ce que <code>mkdir</code> peut prendre des
|
||||
options ?</li>
|
||||
|
||||
<li> <a href="solutions/mkdir_cd-sol.html#mk6">&icone.solution;
|
||||
|
|
@ -86,10 +86,10 @@ droits
|
|||
|
||||
|
||||
<li> <a href="solutions/mkdir_cd-sol.html#mk9">&icone.solution;
|
||||
</a> Quel est l'effet de la commande suivante : </li>
|
||||
</a> Quel est l'effet de la commande suivante :
|
||||
|
||||
<pre>rmdir -p toto/tata/tutu/
|
||||
</pre>
|
||||
</pre></li>
|
||||
|
||||
|
||||
<li> <a href="solutions/mkdir_cd-sol.html#mk10">&icone.solution;
|
||||
|
|
|
|||
262
unix/exercices/solutions/cp_mv-sol.tml
Normal file
262
unix/exercices/solutions/cp_mv-sol.tml
Normal file
|
|
@ -0,0 +1,262 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>cp et mv</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>Corrigé des exercices sur <code>cp</code> et <code>mv</code></h1>
|
||||
|
||||
|
||||
<p>
|
||||
Ces exercices sont des questions de cours : les solutions se trouvent
|
||||
toutes dans les pages de man des commandes en question. On suppose donc
|
||||
connues les commandes de <code>less</code>, qui servent à se déplacer dans les
|
||||
pages de man... et la commande servant à chercher un mot. Testez les
|
||||
commandes sur des fichiers et répertoires d'essai pour vous faire la main et
|
||||
comprendre ce qui se passe.
|
||||
</p>
|
||||
|
||||
<h2><a name="cp"><code>cp</code></a></h2>
|
||||
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
|
||||
<li><a name="cp1"> <strong>Est-il possible de faire une copie d'un répertoire
|
||||
et de l'ensemble de ses sous-répertoires en une seule ligne de
|
||||
commande ?</strong> </a>
|
||||
|
||||
<p>
|
||||
Oui, c'est à cela que sert l'option <code>-r</code> (<em>recursive</em>).
|
||||
Supposons, suivant l'<a href="mkdir_cd.html#arbo">arborescence d'exemple</a>,
|
||||
que vous voulez copier le répertoire <code>Rapport</code> et ses
|
||||
sous-répertoires dans le répertoire <code>www</code>. Il faut
|
||||
taper :</p>
|
||||
|
||||
<pre>
|
||||
cp -r Rapport/ www/
|
||||
</pre>
|
||||
<p class="continue">
|
||||
ou
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
cp -R Rapport/ www/
|
||||
</pre></li>
|
||||
|
||||
<li><a name="cp2"> <strong>Que se passe-t-il si l'on veut faire une copie
|
||||
appelée <code>tentative/</code> de son répertoire <code>essai/</code>, et que
|
||||
le répertoire <code>tentative/</code> existe déjà ?</strong> </a>
|
||||
|
||||
<p>Quand on indique le nom d'un répertoire qui n'existe pas, <code>cp</code>
|
||||
considère qu'il s'agit du nom à donner à la copie du premier répertoire (ou
|
||||
fichier). Quand le répertoire existe déjà, <code>cp</code> considère qu'il
|
||||
s'agit de l'endroit où il faut placer la copie du premier élément (la
|
||||
«cible» : <em>target</em>).</p>
|
||||
|
||||
<p>
|
||||
Si donc on tape
|
||||
</p>
|
||||
<pre>
|
||||
cp -R essai/ tentative/
|
||||
</pre>
|
||||
<p class="continue">
|
||||
et que <code>tentative/</code> existe déjà, on obtient une copie de
|
||||
<code>essai/</code>, également appelée <code>essai/</code>, placée dans le
|
||||
répertoire <code>tentative/</code>.
|
||||
</p>
|
||||
</li>
|
||||
|
||||
<li><a name="cp3"> <strong>Que se passe-t-il si vous voulez faire une copie
|
||||
d'un fichier dans un répertoire où il existe déjà un fichier de ce
|
||||
nom ?</strong> </a>
|
||||
|
||||
<p>
|
||||
Le programme demande si vous voulez vraiment effacer le fichier déjà existant
|
||||
pour le remplacer par celui dont vous faites la copie.
|
||||
</p>
|
||||
|
||||
<div class="attention">
|
||||
<h1>&icone.attention; Attention &icone.attention;</h1>
|
||||
<p> Il en est
|
||||
ainsi parce que vous avez un alias de <code>cp</code> sur <code>cp -i</code>,
|
||||
qui demande confirmation. Ce n'est pas nécessairement le cas partout.
|
||||
</p>
|
||||
|
||||
<p>&icone.note;Pour savoir quels sont vos
|
||||
alias, tapez «<code>alias</code>» ou allez voir dans votre fichier
|
||||
<code>.alias</code>. Avec la config conscrits, les alias sont dans le
|
||||
<code>.zshrc</code> (le fichier de configuration du shell
|
||||
<code>zsh</code>).</p>
|
||||
</div></li>
|
||||
|
||||
<li><a name="cp4"> <strong>Quel est l'effet d'une ligne comme :
|
||||
</strong></a>
|
||||
<pre>
|
||||
cp fichier1 fichier2 fichier3 repertoire/
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Les fichiers <code>fichier1</code>, <code>fichier2</code> et
|
||||
<code>fichier3</code> sont copiés sous leur nom dans le répertoire
|
||||
<code>répertoire/</code>, qui doit exister.
|
||||
</p>
|
||||
</li>
|
||||
|
||||
</ol>
|
||||
|
||||
<h2><a name="mv"><code>mv</code></a></h2>
|
||||
|
||||
<ol>
|
||||
|
||||
<li><a name="mv1"> <strong>Que se passe-t-il si le fichier «cible» existe
|
||||
déjà ?</strong> </a>
|
||||
<p>
|
||||
Si vous avez un alias de <code>mv</code> sur <code>mv -i</code> (cas de la
|
||||
config conscrits), le programme demande si vous voulez réécrire le fichier
|
||||
cible en remplaçant son contenu par celui du fichier de départ :
|
||||
</p>
|
||||
|
||||
|
||||
<pre>
|
||||
<span class="prompt">bireme ~ $</span> ls
|
||||
rapport.tex notes complements
|
||||
<span class="prompt">bireme ~ $</span>mv notes complements
|
||||
mv: overwrite complements (yes/no)? y
|
||||
<span class="prompt">bireme ~ $</span>ls
|
||||
rapport.tex complements
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="mv2"> Supposez que vous avez chez vous l'arborescence</a> <a
|
||||
href="../mkdir_cd.html#arbo">que voici</a>, et que vous vous trouvez dans
|
||||
<code>~/Rapport/docs/</code>.
|
||||
|
||||
<ul>
|
||||
|
||||
<li> <strong>Comment faites-vous pour y amener <code>Rapport.tex</code> qui
|
||||
se trouve dans le répertoire père ?</strong>
|
||||
<pre>
|
||||
mv ../Rapport.tex .
|
||||
</pre>
|
||||
|
||||
<p>Amener le fichier <code>Rapport.tex</code> situé dans répertoire père
|
||||
(<code>../Rapport.tex</code>) dans le répertoire où on se trouve
|
||||
(<code>.</code> : ici).
|
||||
</p></li>
|
||||
|
||||
<li> <strong>Comment faites-vous ensuite pour ramener ce fichier à son
|
||||
emplacement d'origine ?</strong>
|
||||
|
||||
<pre>
|
||||
mv Rapport.tex ..
|
||||
</pre>
|
||||
|
||||
|
||||
<p>Amener le fichier <code>Rapport.tex</code> situé dans le répertoire courant,
|
||||
dans le répertoire père (<code>..</code>).</p></li>
|
||||
|
||||
</ul>
|
||||
</li>
|
||||
|
||||
<li><a name="mv3"> <strong>Comment renommer un répertoire
|
||||
<code>bla/</code> en <code>blo/</code> ? Que se passe-t-il si le
|
||||
répertoire <code>blo</code> existe déjà ?</strong> </a>
|
||||
|
||||
|
||||
<p>Il suffit de taper
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
mv bla/ blo/
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Si jamais <code>blo/</code> existe déjà, <code>bla/</code> devient un
|
||||
sous-répertoire de <code>blo/</code>.
|
||||
</p>
|
||||
</li>
|
||||
|
||||
<li><a name="mv4"> <strong>Comment faire pour à la fois déplacer un fichier
|
||||
et changer son nom ? Que se passe-t-il si il existe déjà un fichier de
|
||||
ce nom dans le répertoire d'arrivée ? </strong></a>
|
||||
|
||||
<p>
|
||||
Supposons que l'on veut amener <code>Rapport.tex</code> dans le répertoire
|
||||
courant, et l'appeler <code>stage</code>. On tape :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
mv ../Rapport.tex stage
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
<code>Rapport.tex</code> est à la fois déplacé et renommé; vous pouvez
|
||||
vérifier qu'il n'est plus dans <code>Rapport</code> et qu'il y a désormais un
|
||||
fichier <code>stage</code> dans <code>docs/</code>.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Si le fichier d'arrivée existe déjà, on se retrouve dans le cas vu tout au
|
||||
début de cet exercice (remplacement ou non).
|
||||
</p>
|
||||
</li>
|
||||
|
||||
|
||||
<li><a name="mv5"> <strong>Mêmes questions avec un répertoire</strong> </a>.
|
||||
|
||||
|
||||
<p>Pour déplacer et renommer, la syntaxe est la même que pour un fichier :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
mv ../bla ble/
|
||||
</pre>
|
||||
|
||||
<p class="continue">
|
||||
déplace le répertoire <code>bla/</code> du répertoire père dans le répertoire
|
||||
courant, et le renomme en <code>ble/</code>. Si jamais <code>ble/</code>
|
||||
existe déjà, <code>bla/</code> y est déplacé sous son nom, et devient un
|
||||
sous-répertoire de <code>ble/</code>.
|
||||
</p>
|
||||
</li>
|
||||
|
||||
|
||||
<li><a name="mv6"> <strong> Que se passe-t-il si on lance <code>mv</code>
|
||||
avec les options <code>-i</code> et <code>-f</code> ensemble ? </strong>
|
||||
</a>.
|
||||
|
||||
<p>
|
||||
L'option <code>-f</code> (<em>force</em>) sert à renommer le fichier
|
||||
impérativement, même si le fichier cible existe déjà, sans demander
|
||||
confirmation. L'option <code>-i</code> (<em>interactive</em>) demande
|
||||
confirmation. Des deux options, c'est <code>-f</code> qui l'emporte :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
<span class="prompt">bireme ~ $</span> ls
|
||||
bla tutu Rapport/
|
||||
<span class="prompt">bireme ~ $</span> alias mv
|
||||
mv='mv -i'
|
||||
<span class="prompt">bireme ~ $</span> mv bla tutu
|
||||
mv: overwrite tutu (yes/no)? n
|
||||
<span class="prompt">bireme ~ $</span> mv -f bla tutu
|
||||
<span class="prompt">bireme ~ $</span> ls
|
||||
tutu Rapport/
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
</ol>
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Émilia Robin, Joël Riou. Dernière modification le 2002-12-08.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
1207
unix/exercices/solutions/enchainer-sol.tml
Normal file
1207
unix/exercices/solutions/enchainer-sol.tml
Normal file
File diff suppressed because it is too large
Load diff
238
unix/exercices/solutions/find-sol.tml
Normal file
238
unix/exercices/solutions/find-sol.tml
Normal file
|
|
@ -0,0 +1,238 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>find</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>Corrigés des exercices sur <code>find</code></h1>
|
||||
|
||||
|
||||
<p>Ces exercices sont des questions de cours : les solutions se trouvent
|
||||
toutes dans les pages de man des commandes en question. On suppose donc
|
||||
connues les commandes de <code>less</code>, qui servent à se déplacer dans les
|
||||
pages de man... et la commande servant à chercher un mot. Testez les
|
||||
commandes sur des fichiers et répertoires d'essai pour vous faire la main et
|
||||
comprendre ce qui se passe.
|
||||
</p>
|
||||
|
||||
|
||||
<h2>Les options de <code>find</code></h2>
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
<li><a name="find1"> <strong>Comment chercher tous les fichiers dont les noms
|
||||
commençent par un «a» majuscule ou une minuscule, suivi d'éventuellement
|
||||
quelques lettres ou chiffres, et se terminent par un chiffre entre 3 et
|
||||
6 ?</strong> </a> <p>
|
||||
|
||||
|
||||
C'est l'option <code>-name</code> qui permet de spécifier le nom du ou des
|
||||
fichiers recherchés. On peut indiquer le nom d'un fichier complet
|
||||
(<code>bofichier.tex</code>), ou utiliser des expressions régulières (celles du
|
||||
shell, pas celles de <code>grep</code>...) :</p>
|
||||
|
||||
<ul>
|
||||
<li> L'étoile (<code>*</code>) désigne «un ou plusieurs caractères»;</li>
|
||||
<li> Le point d'interrogation remplace un (et un seul) caractère
|
||||
quelconque;</li>
|
||||
<li> Les crochets permettent de désigner une série de caractères au
|
||||
choix.</li>
|
||||
</ul>
|
||||
|
||||
<p>
|
||||
Dans notre cas, le premier caractère est un «a» ou un «A» (<code>[aA]</code>),
|
||||
suivi de quelque chose (<code>*</code>) et terminé par un chiffre entre 3 et 6
|
||||
(<code>[3456]</code> ou <code>[3-6]</code>). On écrit donc :
|
||||
</p>
|
||||
|
||||
|
||||
<pre>
|
||||
find . -name '[aA]*[3-6]' -print
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="find2"> <strong>Comment fait-on pour indiquer que le fichier
|
||||
recherché a été modifié il y a plus de 30 jours ? Il y a 30 jours ?
|
||||
Il y a moins de 30 jours?</strong> </a>
|
||||
<p>
|
||||
C'est l'option <code>-mtime</code> qui permet de donner une indication en
|
||||
jours. La syntaxe varie selon ce que l'on souhaite :
|
||||
</p>
|
||||
|
||||
<ul>
|
||||
<li> <code>-mtime 30</code> : le fichier a été modifié il y a 30
|
||||
jours;</li>
|
||||
<li> <code>-mtime +30</code> : le fichier a été modifié il y a 30
|
||||
jours ou plus;</li>
|
||||
<li> <code>-mtime -30</code> : le fichier a été modifié il y a 30
|
||||
jours ou moins.</li>
|
||||
</ul></li>
|
||||
|
||||
<li><a name="find3"> <strong>Comment faire pour dire que le fichier a été
|
||||
modifié plus récemment qu'un autre fichier donné ? </strong> </a><p>
|
||||
|
||||
On utilise l'option <code>-newer</code> («plus récent»). Par exemple, on
|
||||
cherche un fichier <code>.tex</code> modifié plus récemment que
|
||||
<code>bofichier.tex</code> :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
find . -newer bofichier.tex -name '*.tex'
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
On peut raffiner la demande, en combinant cette option avec l'option
|
||||
<code>-mtime</code> : cherchons les fichiers modifiés plus récemment que
|
||||
<code>bofichier.tex</code>, mais il y a plus de 5 jours : </p>
|
||||
|
||||
<pre>
|
||||
find . -newer bofichier.tex -mtime +5 -name '*.tex'
|
||||
</pre></li>
|
||||
|
||||
<li><a name="find4"> <strong>Comment fait-on pour spécifier que le fichier
|
||||
recherché est un répertoire ? </strong> </a><p>
|
||||
On utilise l'option <code>-type</code> pour spécifier le genre de fichier
|
||||
recherché : les principaux sont <code>f</code> (<em>file</em>) pour un
|
||||
fichier normal, et <code>d</code> (<em>directory</em>) pour un répertoire.
|
||||
On tape donc :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
find . -type d
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="find5"> <strong>Comment indiquer que le fichier recherché à une
|
||||
taille supérieure à une taille donnée ? </strong> </a> <p>
|
||||
|
||||
On utilise l'option <code>-size</code>, suivie d'un nombre et d'une lettre
|
||||
indiquant l'unité de mesure (<code>c</code> : octets,
|
||||
<code>k</code> : kilo-octets). Comme pour <code>-mtime</code>, on
|
||||
utilise <code>+</code>, <code>-</code> ou <code>[rien]</code> pour indiquer
|
||||
que la taille est, respectivement, supérieure, inférieure ou égale à la valeur
|
||||
donnée.</p>
|
||||
|
||||
<p>
|
||||
Par exemple, on recherche un fichier modifié il y a moins de 12 jours et dont
|
||||
la taille soit supérieure à 30 K : </p>
|
||||
|
||||
<pre>
|
||||
find . -type f -size +30k -mtime -12 -print
|
||||
</pre></li>
|
||||
|
||||
</ol>
|
||||
|
||||
<h2>Exécuter des commandes sur les fichiers trouvés</h2>
|
||||
|
||||
<p><a name="find6"> <strong>Utiliser <code>find</code> pour effacer tous vos
|
||||
fichiers de sauvegarde (terminés par un tilde) qui ont plus d'un mois.
|
||||
</strong> </a></p> <p>
|
||||
|
||||
|
||||
La ligne utilisée pour trouver ces fichiers et la suivante :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
find . -mtime +30 -name '*~'
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Il y a deux façons de faire exécuter des commandes sur les fichiers trouvés
|
||||
par <code>find</code> : utiliser l'option «<code>-exec</code>
|
||||
<em>commande</em>», ou utiliser un pipe avec <code>xargs</code>.
|
||||
</p>
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <strong><code>-exec</code> <em>commande</em></strong> exécute la commande
|
||||
sur le fichier courant. La commande est terminée par le marqueur
|
||||
<code>;</code>, qu'il faut protéger du shell avec un backslash. Le fichier
|
||||
courant est désigné par la chaîne <code>{}</code>.
|
||||
|
||||
<p>
|
||||
Pour effacer tous les fichiers de sauvegarde vieux de plus d'un mois, on tape
|
||||
donc : </p>
|
||||
|
||||
<pre>
|
||||
find . -mtime +30 -name '*~' -print -exec rm \;
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
On peut faire exécuter la commande de façon interactive en remplaçant
|
||||
<code>-exec</code> par <code>-ok</code> : </p>
|
||||
|
||||
<pre>
|
||||
find . -mtime +30 -name '*~' -print -ok rm \;
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Le programme demande, pour chaque fichier trouvé, si on veut bien exécuter la
|
||||
commande; la réponse doit être «<code>y</code>» ou «<code>Y</code>».
|
||||
</p></li>
|
||||
|
||||
<li> La solution avec <code>-exec</code> est en fait très lourde, car elle
|
||||
crée un nouveau processus pour chaque fichier; il vaut mieux
|
||||
<strong>rediriger le résultat de <code>find</code> avec un pipe et
|
||||
<code>xargs</code></strong>. Dans notre cas, on tapera donc :
|
||||
|
||||
|
||||
<pre>
|
||||
find . mtime +30 -name '*~' | xargs -p rm
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
L'option <code>-p</code> de <code>xargs</code> rend cette commande
|
||||
interactive. Il faut répondre «<code>y</code>» ou «<code>Y</code>» pour
|
||||
confirmer.
|
||||
</p></li>
|
||||
|
||||
</ol>
|
||||
|
||||
<p>
|
||||
Quelle différence y a-t-il entre un simple pipe et
|
||||
«<code>| xargs</code>» ? Pour la comprendre, voici un
|
||||
exercice : cherchez tous les fichiers contenus dans
|
||||
<code>/usr/local/lib/texmf/tex</code> et cherchez dedans le mot «supertab». Il
|
||||
y a deux solutions :
|
||||
</p>
|
||||
|
||||
<ol>
|
||||
|
||||
<li> Vous tapez
|
||||
|
||||
<pre>
|
||||
find /usr/local/lib/texmf/tex -type f | grep supertab
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Vous obtenez une liste de fichiers contenant «supertab» dans leur nom.
|
||||
</p>
|
||||
</li>
|
||||
|
||||
<li> Vous tapez
|
||||
<pre>
|
||||
find /usr/local/lib/texmf/tex -type f | xargs grep supertab
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
<code>grep</code> cherche dans chaque fichier passé en argument la chaîne de
|
||||
caractères «supertab», ce qui est très différent...</p></li>
|
||||
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Émilia Robin, Joël Riou. Dernière modification le 2002-12-09.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
590
unix/exercices/solutions/grep-sol.tml
Normal file
590
unix/exercices/solutions/grep-sol.tml
Normal file
|
|
@ -0,0 +1,590 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>grep</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
|
||||
<h1>Exercices sur <code>grep</code> : corrigés</h1>
|
||||
|
||||
<p>
|
||||
Ces exercices sont des questions de cours : les solutions se trouvent
|
||||
toutes dans les pages de man des commandes en question. On suppose donc
|
||||
connues les commandes de <code>less</code>, qui servent à se déplacer dans les
|
||||
pages de man... et la commande servant à chercher un mot. Testez les
|
||||
commandes sur des fichiers et répertoires d'essai pour vous faire la main et
|
||||
comprendre ce qui se passe.
|
||||
</p>
|
||||
|
||||
|
||||
|
||||
<h2><a name="options">Les options de <code>grep</code></a></h2>
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
<li><a name="grep1"> <strong>Quelles sont les options de <code>grep</code>
|
||||
qui permettent d'obtenir des lignes de contexte (qui précèdent et/ou suivent
|
||||
la ligne où figure le mot) ? </strong> </a> <p>
|
||||
|
||||
Il y en a plusieurs, qui se recoupent :</p>
|
||||
|
||||
<ul>
|
||||
<li> <code>-<em>num</em></code> : le <em>numéro</em> indique le nombre de
|
||||
lignes de contexte que l'on veut voir figurer avant et après la ligne où
|
||||
figure le mot recherché. Par exemple, si on veut trois lignes de contexte,
|
||||
avant et après la mot (soit sept lignes au total), on tape :
|
||||
|
||||
<pre>
|
||||
grep -3 ...
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li> <code>-A <em>num</em></code> (<em>after</em>) : le <em>numéro</em>
|
||||
indique le nombre de lignes qui doivent suivre la ligne où figure le mot. Si
|
||||
on en veut quatre, on tapera :
|
||||
|
||||
|
||||
<pre>
|
||||
grep -A 4 ...
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
|
||||
<li> <code>-B <em>num</em></code> (<em>before</em>) : le
|
||||
<em>numéro</em> indique le nombre de lignes qui doivent précéder la ligne où
|
||||
figure le mot. Si on en veut dix, on tape :
|
||||
|
||||
<pre>
|
||||
grep -B 10 ...
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li> <code>-C</code> (<em>context</em>), qui donne deux lignes de contexte
|
||||
avant et après. En fait, les trois lignes suivantes sont strictement
|
||||
équivalentes :
|
||||
<pre>
|
||||
grep -2 ...
|
||||
grep -C ...
|
||||
grep -A 2 -B 2 ...
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
</ul></li>
|
||||
|
||||
<li><a name="grep2"> <strong>Comment faire apparaître le numéro de la
|
||||
ligne où figure le mot recherché ? </strong> </a>
|
||||
<p>
|
||||
C'est l'option <code>-n</code> (<em>number</em>) qui sert à cela; le numéro
|
||||
figure tout au début de la ligne, suivi d'un deux-points (<code>:</code>) et
|
||||
du texte. Par exemple : </p>
|
||||
|
||||
<pre>
|
||||
<span class="prompt">bireme ~ $</span> grep -n violon verlaine.tex
|
||||
12:des violons de l'automne
|
||||
</pre>
|
||||
<p>
|
||||
Quand on fait une recherche dans plusieurs fichiers, le nom du fichier figure
|
||||
d'abord, puis le numéro de la ligne, et enfin le texte, le tout séparé par des
|
||||
deux-points. Par exemple :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
<span class="prompt">bireme ~ $</span> grep -n violon *
|
||||
verlaine.tex:12:des violons de l'automne
|
||||
orchestre:45:Cordes : contrebasse, violoncelle, alto, violons.
|
||||
</pre>
|
||||
|
||||
<strong>Que se passe-t-il quand on demande également des lignes de
|
||||
contexte ?</strong> <p>
|
||||
|
||||
La disposition générale ne change pas, par contre, le signe utilisé pour
|
||||
séparer la ligne de son numéro est un tiret (<code>-</code>) quand il s'agit
|
||||
des lignes de contexte, et un deux-points quand il s'agit de la ligne voulue.
|
||||
Par exemple : </p>
|
||||
|
||||
<pre>
|
||||
<span class="prompt">bireme ~ $"</span> grep -nC violon verlaine.tex
|
||||
10-
|
||||
11-Les sanglots longs
|
||||
12:des violons de l'automne
|
||||
13-bercent mon coeur
|
||||
14-d'une langueur monotone
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="grep22"> <strong> Comment faire pour afficher le nombre
|
||||
d'occurences du mot recherché ? </strong> </a> <p>
|
||||
|
||||
On utilise l'option <code>-c</code> (<em>count</em>) :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
<span class="prompt">bireme ~ $</span> grep -c violon *
|
||||
verlaine.tex:1
|
||||
orchestre:1
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="grep23"> <strong> Comment faire pour que <code>grep</code>
|
||||
ignore la casse des caractères (différence entre majuscules et minuscules)
|
||||
dans sa recherche ? </strong> </a>
|
||||
<p>
|
||||
Par défaut, <code>grep</code> fait la différence entre les majuscules et les
|
||||
minuscules; pour invalider ce comportement, on utilise l'option
|
||||
<code>-i</code> (<em>ignorecase</em>).</p>
|
||||
</li>
|
||||
|
||||
<li><a name="grep4"> <strong>Comment faire pour faire apparaître non pas les
|
||||
lignes où figurent le mot, mais les noms des fichiers ?</strong> </a>
|
||||
<p>
|
||||
C'est l'option <code>-l</code> qui permet de faire cela : afficher les
|
||||
noms des fichiers où figure au moins une fois la chaîne de caractères
|
||||
recherchée.</p></li>
|
||||
|
||||
<li><a name="grep5"> <strong>Comment faire apparaître les lignes où ne
|
||||
figurent pas le mot recherché ? </strong> </a>
|
||||
<p>
|
||||
On veut en fait inverser le sens de la recherche : c'est l'option
|
||||
<code>-v</code> qui fait cela.
|
||||
</p></li>
|
||||
|
||||
<li><a name="grep51"> <strong> Comment faire apparaître les noms des fichiers
|
||||
ne contenant pas le mot recherché ? </strong> </a>
|
||||
<p>
|
||||
On utilise l'option <code>-L</code>, qui affiche les noms de fichiers où ne
|
||||
figurent pas la chaîne de caractères recherchée. Il ne faut bien sûr pas
|
||||
confondre les options <code>-l</code> et <code>-L</code>...
|
||||
</p></li>
|
||||
|
||||
<li><a name="grep6"> <strong>Comment faire pour que <code>grep</code> ne
|
||||
recherche que les lignes où figure le mot tel quel, et non pas ses
|
||||
variantes ? </strong> </a> <p>
|
||||
|
||||
C'est l'option <code>-w</code> (comme <em>word</em>) qui sert à cela : un
|
||||
mot complet est délimité comme suit :
|
||||
</p>
|
||||
|
||||
<ul>
|
||||
|
||||
<li> Début : la chaîne de caractères est placée au début d'une ligne, ou
|
||||
précédée d'un blanc, d'une tabulation ou d'une ponctuation.</li>
|
||||
|
||||
<li> Fin : la chaîne de caractère est placée en fin de ligne, ou suivie
|
||||
d'un blanc, d'une tabulation ou d'une ponctuation.</li>
|
||||
|
||||
</ul>
|
||||
|
||||
<p>
|
||||
Si donc on veut chercher «travail» et aucune forme dérivée de ce mot, on
|
||||
écrit :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep -w travail mon-fichier
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="grep3"> <strong>Comment faire pour chercher plusieurs mots à la
|
||||
fois en faisant apparaître les numéros des lignes ?</strong> </a> <p>
|
||||
On veut chercher toutes les occurences des mots «terre» et «ciel» dans les
|
||||
deux premiers chapitres de la première partie de <em>Germinal</em>, avec les
|
||||
numéros des lignes. On propose deux solutions, la première utilisant les
|
||||
ressources de la syntaxe de <code>grep</code>, la seconde utilisant l'option
|
||||
<code>-f</code> avec un fichier.</p>
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <strong>Syntaxe de <code>grep</code></strong> : La structure
|
||||
<code>\(mot1\|mot2\)</code> permet de chercher plusieurs mots. Ici, on tape la
|
||||
ligne suivante :
|
||||
|
||||
<pre>
|
||||
grep '\(ciel\|terre\)' <em>fichier</em>
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
On met des apostrophes de part et d'autre de l'expression pour la protéger
|
||||
contre le shell, c'est-à-dire pour que le shell ne cherche pas à interpréter
|
||||
l'expression.
|
||||
</p></li>
|
||||
|
||||
<li> <strong>Option «<code>-f</code> <em>fichier</em>»</strong> : dans un
|
||||
fichier quelconque, que nous appellerons <code>liste</code>, on indique les
|
||||
mots que l'on recherche : «ciel» et «terre». Chaque ligne correspond à un
|
||||
mot recherché. Il ne faut donc pas mettre de ligne comme
|
||||
|
||||
<pre>
|
||||
terre ciel
|
||||
</pre>
|
||||
|
||||
|
||||
<p class="continue">
|
||||
car le programme chercherait la chaîne de caractères «terre ciel», qui est
|
||||
assez improbable en français. Il ne faut pas non plus laisser de ligne
|
||||
blanche : le programme afficherait l'ensemble du texte.
|
||||
</p>
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
<p>
|
||||
Quelle que soit la solution retenue, on veut ensuite afficher le numéro des
|
||||
lignes (option <code>-n</code>); d'autre part, pour que la recherche soit
|
||||
exhaustive, il vaut mieux que <code>grep</code> ne fasse pas de différence
|
||||
entre les majuscules et les minuscules, avec l'option <code>-i</code>
|
||||
(<em>ignore case</em>, ignorer la casse des caractères). Il faut aussi décider
|
||||
si on cherche les mots tels quels, sans leurs variantes (comme «terre» au
|
||||
pluriel), ou si on accepte ces variantes. Si on ne veut que le mot sans ses
|
||||
dérivés, on utilise l'option <code>-w</code>.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Pour désigner les deux fichiers où faire la recherche, on peut les écrire
|
||||
littéralement :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
zola1.txt zola2.txt
|
||||
</pre>
|
||||
<p class="continue">
|
||||
ou, mieux, utiliser les joker du shell :
|
||||
</p>
|
||||
<pre>
|
||||
zola[12].txt
|
||||
</pre>
|
||||
|
||||
<p><code>[12]</code> signifie «le caractère 1 ou le caractère 2».</p>
|
||||
|
||||
<p>
|
||||
<strong>Finalement, on peut taper, au choix</strong> : </p>
|
||||
<pre>
|
||||
grep -inw -f liste zola1.txt zola2.txt
|
||||
grep -inw -f liste zola[12].txt
|
||||
grep -inw '\(ciel\|terre\)' zola1.txt zola2.txt
|
||||
grep -inw '\(ciel\|terre\)' zola[12].txt
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Et on obtient :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
zola1.txt:13:ciel, le pavé se déroulait avec la rectitude d'une jetée, au
|
||||
milieu de
|
||||
zola1.txt:36:brûlaient si haut dans le ciel mort, pareils à des lunes fumeuses.
|
||||
Mais, au
|
||||
zola1.txt:50:besogne. Les ouvriers de la coupe à terre avaient dû travailler
|
||||
tar d, on
|
||||
zola1.txt:124:terre, lorsqu'un accès de toux annonça le retour du charretier.
|
||||
Le ntement,
|
||||
zola1.txt:191:bleues en plein ciel, comme des torches géantes. C'était d'une
|
||||
tristesse
|
||||
zola1.txt:207: Le manoeuvre, après avoir vidé les berlines, s'était assis à
|
||||
terre,
|
||||
zola1.txt:222:fois avec tout le poil roussi, une autre avec de la terre jusque
|
||||
dans le
|
||||
|
||||
(...)
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Le résultat est un peu différent quand on n'utilise pas l'option
|
||||
<code>-w</code>.</p>
|
||||
</li>
|
||||
|
||||
</ol>
|
||||
|
||||
<h2><a name="regexp">Introduction aux expressions régulières</a></h2>
|
||||
|
||||
<p>
|
||||
<code>grep</code> recherche des chaînes de caractères, qui peuvent être un mot
|
||||
complet («terre»), une suite de lettres («tre»), ou une expression régulière.
|
||||
Les expressions régulières sont des formules qui représentent des chaînes de
|
||||
caractères. On cherche alors non pas un mot précis, mais des suites de
|
||||
caractères correspondant aux critères demandés. Elles sont d'un usage fréquent
|
||||
avec <code>grep</code> bien sûr, mais aussi avec des commandes comme
|
||||
<code>less</code>, ou encore au sein d'un éditeur.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
«Expressions régulières» (<em>Regular expressions</em> en anglais) se
|
||||
traduisent en bon français par «expressions rationnelles», mais l'usage est de
|
||||
dire «régulières».
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Ces exercices n'entendent pas remplacer un cours sur les expressions
|
||||
régulières, ni faire le tour de leurs possibilités.
|
||||
</p>
|
||||
|
||||
<ol>
|
||||
<li><a name="reg1"> <strong>Chercher toutes les lignes commençant par «a» ou
|
||||
«A»</strong> </a>. <p>
|
||||
Il faut indiquer que l'on veut le début de la ligne, avec le chapeau
|
||||
(<em>caret</em> en anglais). Ensuite, on veut préciser que la ligne commence
|
||||
par un «a» minuscule ou majuscule. Il y a deux façons de le faire :
|
||||
</p>
|
||||
|
||||
<ul>
|
||||
|
||||
<li> Utiliser l'option <code>-i</code> qui fait ignorer la différence entre
|
||||
les majuscules et le minuscules.</li>
|
||||
|
||||
<li> Dire que l'on cherche un «a» ou un «A». C'est à cela que servent les
|
||||
crochets : <code>[abc]</code> signifie «a ou b ou c». Ici, ce sera
|
||||
<code>[aA]</code>.</li>
|
||||
|
||||
</ul>
|
||||
|
||||
<p>
|
||||
Enfin, il faut protéger les signes contre le shell, pour qu'il ne les
|
||||
interprète pas; on met donc l'expression entre apostrophes. Remarque :
|
||||
la protection des expressions régulières contre le shell est une question
|
||||
complexe....
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Il faut donc écrire :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep -i '^a' fichier
|
||||
</pre>
|
||||
|
||||
<p class="continue">
|
||||
ou
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep '^[aA]' fichier
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
|
||||
<li><a name="reg2"> <strong>Chercher toutes les lignes finissant par
|
||||
«rs»</strong> </a> <p>
|
||||
|
||||
|
||||
C'est le dollar (<code>$</code>) qui représente la fin de la ligne. Il faut
|
||||
donc écrire : </p>
|
||||
|
||||
<pre>
|
||||
grep 'rs$' fichier
|
||||
</pre></li>
|
||||
|
||||
<li><a name="reg3"> <strong>Chercher toutes les lignes contenant au moins un
|
||||
chiffre</strong> </a> <p>
|
||||
|
||||
|
||||
Pour désigner un chiffre, on peut en indiquer une liste entre crochets :
|
||||
<code>[0123456789]</code>. Il est plus simple d'utiliser une classe de
|
||||
caractères : <code>[0-9]</code> qui désigne, comme la solution précédente,
|
||||
n'importe quel chiffre de zéro à neuf.
|
||||
</p>
|
||||
<p>
|
||||
Il faut donc taper : </p>
|
||||
<pre>
|
||||
grep '[0-9]' fichier
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="reg4"> <strong>Chercher toutes les lignes commençant par une
|
||||
majuscule</strong> </a> <p>
|
||||
|
||||
|
||||
Comme on l'a vu, c'est le chapeau qui indique le début de la ligne. Pour
|
||||
indiquer que l'on cherche une majuscule, on peut soit en donner une liste
|
||||
(<code>[ABCDEFGHIJKLMNOPQRSTUVWXYZ]</code>), soit utiliser une classe de
|
||||
caractères : <code>[A-Z]</code>, la seconde solution étant, de loin,
|
||||
préférable...
|
||||
</p>
|
||||
<p>
|
||||
Il faut donc taper :
|
||||
</p>
|
||||
<pre>
|
||||
grep '^[A-Z]' fichier
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="reg5"> <strong>Chercher toutes les lignes commençant par «B»,
|
||||
«E» ou «Q»</strong> </a> <p>
|
||||
|
||||
|
||||
Il faut indiquer entre crochets les trois lettres recherchées :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep '^[BEQ]' fichier
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
|
||||
<li><a name="reg6"> <strong>Chercher toutes les lignes finissant par un point
|
||||
d'exclamation</strong> </a> <p>
|
||||
|
||||
|
||||
Le point d'exclamation n'a pas de signification particulière avec
|
||||
<code>grep</code>, on peut donc le mettre tel quel :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep '!$' fichier
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="reg7"> <strong>Chercher toutes les lignes ne finissant pas par
|
||||
un signe de ponctuation (point, virgule, point-virgule, deux-points, point
|
||||
d'interrogation, point d'exclamation)</strong> </a><p>
|
||||
|
||||
|
||||
Il faut donner une liste de caractères, que l'on ne veut pas voir figurer; la
|
||||
liste sera entre crochets, comme on l'a déjà vu, et c'est le chapeau qui
|
||||
signifiera, dans ce contexte, «sauf». Par exemple, si on cherche tous les «a»,
|
||||
sauf ceux suivi de «b», «c» ou «t», on écrit :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep 'a[^bct]'
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
Il y a une seconde difficulté, qui vient de ce que certains caractères sont
|
||||
spéciaux avec <code>grep</code>. Vous vous doutez que le chapeau est spécial
|
||||
quand il est placé au début de l'expression, et que le dollar l'est quand il
|
||||
est placé en fin d'expression. Dans notre cas :
|
||||
</p>
|
||||
<ul>
|
||||
|
||||
<li> Le point désigne n'importe quel caractère.</li>
|
||||
|
||||
<li> Le point d'interrogation signifie «le caractère qui précède apparaît 0 ou
|
||||
1 fois». Avec <code>egrep</code>, il fonctionne tout seul, avec
|
||||
<code>grep</code>, il faut le faire précéder d'un backslash pour qu'il
|
||||
fonctionne; par exemple (avec <code>grep</code>), pour chercher «charbon» ou
|
||||
«vagabond», on écrit :
|
||||
<pre>
|
||||
grep 'ar?bo' fichier
|
||||
</pre>
|
||||
|
||||
<p class="continue">
|
||||
(chercher la suite de lettre «abo» avec un «r» facultatif entre le «a» et le
|
||||
«b»).</p>
|
||||
</li>
|
||||
|
||||
</ul>
|
||||
|
||||
<p>
|
||||
Pour que <code>grep</code> interprète littéralement ces caractères, et ne les
|
||||
considère plus comme spéciaux, il faut les faire précéder d'un backslash
|
||||
(<code>\</code>). Si par exemple vous cherchez toutes les lignes qui se
|
||||
terminent par un point, il faut taper :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep '\.$' fichier
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
Dans notre cas cependant, ces caractères sont protégés par les crochets. On
|
||||
peut donc écrire :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep '[^.,;:?!]$' fichier
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
On peut aussi utiliser l'option <code>-v</code>, qui prend toutes les lignes
|
||||
où ne figure pas une chaîne de caractères donnée; dans ce cas, on tape :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep -v '[.,;:?!]$' fichier
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
|
||||
<li><a name="reg8"> <strong>Comment chercher tous les mots contenant un «r»
|
||||
précédé de n'importe quelle lettre majuscule ou minuscule ? </strong>
|
||||
</a> <p>
|
||||
|
||||
On cherche une chaîne de caractères qui soit indifféremment au début ou au
|
||||
milieu d'un mot. N'importe quelle lettre, ce sont les classes de caractères
|
||||
<code>[a-zA-Z]</code> ou <code>[:alpha:]</code>, qui sont équivalentes.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Il y a une petite subtilité avec l'emploi de classes du second type; elles
|
||||
désignent un groupe de caractères, et il faut mettre une seconde paire de
|
||||
crochets pour dire «n'importe quel caractère de cette classe prédéfinie».
|
||||
On tape donc au choix :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep '[a-zA-Z]r' fichier'
|
||||
</pre>
|
||||
<p class="continue">
|
||||
ou
|
||||
</p>
|
||||
<pre>
|
||||
grep '[[:alpha:]]r' fichier'
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
Attention, dans ces listes ne sont pas compris les caractères accentués...
|
||||
</p></li>
|
||||
|
||||
<li><a name="reg9"> <strong>Chercher tous les mots dont la seconde lettre est
|
||||
un «r»</strong> </a>.
|
||||
|
||||
<p>
|
||||
C'est le symbole <code>\<</code> qui désigne un début de mot. La première
|
||||
lettre du mot est indifférente, la seconde est un «r». On écrit donc :
|
||||
</p>
|
||||
<pre>
|
||||
grep '\<.r' fichier
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
Il y a cependant un problème avec les caractères accentués, que
|
||||
<code>grep</code> considère comme des blancs. Dans ce cas, il vaut mieux
|
||||
procéder autrement : un mot est précédé d'un début de ligne, ou d'un
|
||||
blanc ou d'une tabulation. Un début de ligne, c'est le chapeau, un blanc ou
|
||||
une tabulation, c'est la classe de caractères <code>[:space:]</code>.
|
||||
</p>
|
||||
<p>
|
||||
On va se servir du pipe (<code>|</code>) qui signifie «ou». Avec
|
||||
<code>grep</code>, il faut backslasher le pipe, avec <code>egrep</code> ce
|
||||
n'est pas nécessaire. On écrit donc (avec <code>grep</code>) :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
grep '^.r|[[:space:]].r' fichier
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Ce n'est quand même pas si simple; les mots peuvent être précédés d'un tiret
|
||||
(mots composés), d'une apostrophe, de guillemets divers (<code>``</code>,
|
||||
<code>"</code>, <code>«</code>, <code><<</code>), et, si l'auteur du
|
||||
texte n'est pas respectueux des règles de typographie, d'une ponctuation. Il y
|
||||
a donc bien des cas à envisager...
|
||||
</p>
|
||||
</li>
|
||||
</ol>
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Émilia Robin, Joël Riou. Dernière modification le 2002-12-08.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
240
unix/exercices/solutions/less-sol.tml
Normal file
240
unix/exercices/solutions/less-sol.tml
Normal file
|
|
@ -0,0 +1,240 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>less</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>Corrigé des exercices sur <code>less</code></h1>
|
||||
|
||||
<p>
|
||||
On aborde ici <code>less</code>, qui est une version plus élaborée de
|
||||
<code>more</code>; ce dernier est toujours détaillé dans dans les ouvrages sur
|
||||
Unix, et de fait il est toujours présent sur ces systèmes, ce qui n'est pas
|
||||
forcément vrai pour <code>less</code> (qui est quand même très courant).
|
||||
<code>more</code> est beaucoup plus rudimentaire, alors que <code>less</code>
|
||||
a beaucoup de fonctionnalités appréciables : vidéo inverse pour les
|
||||
motifs recherchés, déplacements en avant et en arrière pour la recherche, etc.
|
||||
</p>
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
<li><a name="less1"><strong> Comment fait-on pour obtenir une page d'aide avec
|
||||
<code>less</code> ? </strong></a>
|
||||
|
||||
<p>On tape <code>h</code> ou <code>H</code> pour afficher une page d'aide. On s'y
|
||||
déplace comme dans <code>less</code> (flèches, <code>^D</code>,
|
||||
<code>^F</code>, <code>^B</code>, <code>^P</code>, <code>SPC</code>,
|
||||
<code>j</code>, <code>k</code>...). Pour quitter l'aide, ce sont les mêmes
|
||||
commandes que pour quitter <code>less</code> : <code>q</code>,
|
||||
<code>Q</code>, <code>:q</code>, <code>:Q</code>, <code>ZZ</code>.
|
||||
</p></li>
|
||||
|
||||
<li> <a name="less2"><strong> Comment examiner plusieurs fichiers à la
|
||||
suite ? Comment passe-t-on au suivant ? Comment revient-on au
|
||||
précédent ? </strong></a>
|
||||
|
||||
<p>
|
||||
Il suffit de donner plusieurs fichiers en argument à la commande
|
||||
<code>less</code>; par exemple, pour examiner sucessivement les fichiers
|
||||
<code>toto</code>, <code>bla</code> et <code>blu</code>, on tape :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
less toto bla blu
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Pour passer au fichier suivant, on tape <code>:n</code> (<em>next</em>); pour
|
||||
revenir au fichier précédent, on tape <code>:p</code> (<em>previous</em>).
|
||||
<code>:x</code> permet de revenir au premier fichier spécifié.
|
||||
</p></li>
|
||||
|
||||
<li><a name="less3"><strong> Quelles sont les commandes différentes qui
|
||||
permettent de quitter <code>less</code> ? </strong></a>
|
||||
<p>
|
||||
Ce sont : <code>q</code>, <code>Q</code>, <code>:q</code>, <code>:Q</code>,
|
||||
<code>ZZ</code>.
|
||||
</p></li>
|
||||
|
||||
<li><a name="less4"><strong> Comment dire à <code>less</code> d'ouvrir le
|
||||
fichier en plaçant en haut de l'écran la ligne <em>n</em> ?
|
||||
</strong></a>
|
||||
|
||||
<p>
|
||||
On spécifie le numéro de la ligne après le signe <code>+</code>; par exemple,
|
||||
pour ouvrir le fichier <code>rapport</code> sur la ligne 57, on tape :
|
||||
</p>
|
||||
|
||||
|
||||
<pre>
|
||||
less +57 rapport
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="less5"><strong> Comment dire à <code>less</code> d'ouvrir le
|
||||
fichier en plaçant en haut de l'écran la première ligne où apparaît un motif
|
||||
donné ? </strong></a>
|
||||
|
||||
<p>
|
||||
On utilise l'option <code>-p</code> de la commande <code>less</code>; par
|
||||
exemple, pour chercher le mot «toto» dans le fichier <code>rapport</code>, on
|
||||
tape :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
less -p toto rapport
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
On peut aussi indiquer le motif recherché de la façon suivante :
|
||||
</p>
|
||||
<pre>
|
||||
less +/toto rapport
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="less6"><strong> Quelles sont les deux commandes de
|
||||
<code>less</code> qui permettent de chercher un motif dans un fichier,
|
||||
respectivement après et avant la position courante ? </strong></a>
|
||||
|
||||
<p>
|
||||
Pour chercher un motif plus en avant dans le texte, on utilise le slash (barre
|
||||
oblique vers la droite : <code>/</code>). Par exemple :
|
||||
</p>
|
||||
<pre>
|
||||
/mot
|
||||
</pre>
|
||||
|
||||
|
||||
<p>
|
||||
Pour chercher en arrière de la position courante, on utilise le point
|
||||
d'interrogation. Pour aller à la prochaine occurence du mot, il suffit de
|
||||
taper <code>n</code> (<em>next</em>). Pour aller à la précédente occurence du
|
||||
mot, il faut taper <code>N</code>. Évidemment, quand on cherche un motif avec
|
||||
<code>?</code>, <code>n</code> remonte dans le texte et <code>N</code>
|
||||
descend dans le texte.</p>
|
||||
|
||||
<p>
|
||||
Une fois le début ou la fin du fichier atteint, la recherche s'arrête. On
|
||||
peut utiliser les expressions régulières.
|
||||
</p></li>
|
||||
|
||||
|
||||
|
||||
|
||||
<li><a name="less7"><strong> Comment dire à <code>less</code> de chercher le
|
||||
mot à partir de la première ligne du fichier, et ce où que l'on soit dans le
|
||||
fichier ? </strong></a> <p>
|
||||
Il faut taper <code>^F</code> après avoir tapé <code>/</code>. En fait,
|
||||
<code>^F</code> fait commencer la recherche au premier fichier dont on a donné
|
||||
le nom; quand il n'y en a qu'un seul, cela place de fait tout au début du
|
||||
fichier. Par exemple, pour chercher <code>toto</code> alors qu'on se trouve à
|
||||
la fin du fichier, on tape : </p>
|
||||
|
||||
<pre>
|
||||
/^F
|
||||
</pre>
|
||||
|
||||
<p class="continue">
|
||||
Le prompt devient alors :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
First-file /
|
||||
</pre>
|
||||
<p class="continue">
|
||||
et il n'y a plus qu'à taper le motif recherché.
|
||||
</p></li>
|
||||
|
||||
|
||||
<li><a name="less8"><strong> Que se passe-t-il si l'on cherche le motif
|
||||
suivant : «toTo» en donnant l'option <code>-i</code> à
|
||||
<code>less</code> ? Quelle option faut-il mettre à la place de
|
||||
<code>-i</code> pour chercher <code>toTo</code> tout en ignorant la casse des
|
||||
caractères ? </strong> </a>
|
||||
<p>
|
||||
L'option <code>-i</code> signifie <em>ignorecase</em>, c'est-à-dire ignorer la
|
||||
casse des caractères (différence entre majuscules et minuscules). Si donc
|
||||
je tape (au choix) :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
less -ip TOTO rapport
|
||||
less -ip toto rapport
|
||||
less -i +/toto rapport
|
||||
less -i +/TOTO rapport
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
<code>less</code> ne fera pas la différence entre les majuscules et les
|
||||
minuscules, et je trouverai <code>toto</code> comme <code>TOTO</code>. Bien
|
||||
sûr, c'est la même chose si je lance <code>less</code> avec l'option
|
||||
<code>-i</code> et que je cherche ensuite le mot à l'intérieur du fichier avec
|
||||
<code>/</code> ou <code>?</code>.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
<strong>Mais</strong> l'option <code>-i</code> est invalidée si le motif
|
||||
recherché contient des majuscules <em>et</em> des minuscules : si, en
|
||||
lançant <code>less</code> comme ci-dessus, je cherche le motif
|
||||
<code>Toto</code>, je ne trouverai que <code>Toto</code> et pas
|
||||
<code>TOTO</code> par exemple. Pour contourner cette restriction, il faut
|
||||
lancer <code>less</code> avec l'option <code>-I</code>, qui est donc un
|
||||
<em>ignorecase</em> «robuste».
|
||||
</p></li>
|
||||
|
||||
<li><a name="less9"><strong> Quelles sont les commandes qui permettent d'aller
|
||||
à la prochaine (resp. précédente) occurence du motif recherché à travers
|
||||
tous les fichiers édités ? </strong></a>
|
||||
|
||||
<p>
|
||||
Pour aller à l'occurence suivante (resp. précédente) d'un motif dans un
|
||||
fichier, on utilise <code>n</code> (resp. <code>N</code>). Pour faire la même
|
||||
opération mais sans passer manuellement de fichier en fichier, on tape
|
||||
<code>ESC n</code> pour chercher en avant, et <code>ESC N</code> pour chercher
|
||||
en arrière. <code>ESC</code> désigne bien sûr la touche d'échappement
|
||||
(<code>Escape</code>).
|
||||
</p></li>
|
||||
|
||||
<li><a name="less10"><strong>Comment chercher dans un fichier le caractère
|
||||
<code>/</code> ?</strong></a> <p>
|
||||
Le caractère <code>/</code> sert à chercher un mot dans le fichier. Si on tape
|
||||
</p>
|
||||
<pre>
|
||||
//
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
<code>less</code> répond : <code>Pattern not found</code>. Il faut donc
|
||||
dire à <code>less</code> de considérer le <code>/</code> comme un caractère
|
||||
ordinaire, et pas comme un caractère spécial. Comme avec toutes les
|
||||
expressions régulières, c'est le backslash (barre oblique vers la
|
||||
gauche : <code>\</code>) qui sert à cela. Pour chercher un
|
||||
<code>/</code>, on tape donc :
|
||||
</p>
|
||||
<pre>
|
||||
/\/
|
||||
</pre>
|
||||
|
||||
<p>La page de man donne une liste de caractères qui sont spéciaux avec
|
||||
<code>/</code> et <code>?</code>. Ces commandes de recherche utilisent les
|
||||
expressions régulières de <code>ed</code> (et de <code>vi</code> par
|
||||
conséquent).
|
||||
</p></li>
|
||||
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Émilia Robin, Joël Riou. Dernière modification le 2002-12-08.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
315
unix/exercices/solutions/ls-sol.tml
Normal file
315
unix/exercices/solutions/ls-sol.tml
Normal file
|
|
@ -0,0 +1,315 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>ls</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>Corrigé des exercices sur <code>ls</code></h1>
|
||||
|
||||
<p>Ces exercices sont des questions de cours : les solutions se trouvent
|
||||
toutes dans les pages de man des commandes en question. On suppose donc
|
||||
connues les commandes de <code>less</code>, qui servent à se déplacer dans les
|
||||
pages de man... et la commande servant à chercher un mot. Testez les
|
||||
commandes sur des fichiers et répertoires d'essai pour vous faire la main et
|
||||
comprendre ce qui se passe.</p>
|
||||
|
||||
<ol>
|
||||
|
||||
<li><a name="ls1"> <strong>Affichez le contenu de
|
||||
<code>/usr/local/games/bin</code> </strong> </a>
|
||||
|
||||
<pre>
|
||||
ls /usr/local/games/bin
|
||||
</pre>
|
||||
|
||||
<p>Vous obtenez une liste des jeux installés.</p></li>
|
||||
|
||||
<li><a name="ls2"> <strong>Quelle est la taille de votre
|
||||
<code>.flnewsrc.forum</code></strong> </a> ?
|
||||
|
||||
|
||||
<pre>ls -al .flnewsrc.forum</pre>
|
||||
|
||||
|
||||
<p>
|
||||
L'option <code>-a</code> fait apparaître les fichiers de configuration, qui
|
||||
commencent par un point; l'option <code>-l</code> affiche plusieurs
|
||||
renseignements, en particulier la taille. En fait, si vous indiquez le nom
|
||||
complet du fichier cherché, avec le point, l'option <code>-a</code> est
|
||||
inutile; c'est le cas ici.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Le <code>.flnewsrc.forum</code> contient la liste de continua de forum avec
|
||||
des indications sur les contis auxquels vous êtes abonnés et les messages que
|
||||
vous avez déjà lus. Il est remis à jour à chaque fois que vous lisez
|
||||
forum : la date indiquée correspond donc à la dernière fois que vous avec
|
||||
lancé (ou plus précisément, quitté...) forum.
|
||||
</p></li>
|
||||
|
||||
|
||||
<li><a name="ls3"> <strong>À quoi sert l'option <code>-R</code> de
|
||||
<code>ls</code> ? </strong> </a>
|
||||
|
||||
<p>Cette option permet d'afficher une liste récursive, c'est-à-dire qui indique
|
||||
le contenu des répertoires listés, ainsi que de leurs sous-répertoires. Si
|
||||
vous tapez <code>ls -R</code> dans votre répertoire personnel, vous aurez une
|
||||
liste de tout ce que vous avez chez vous.</p></li>
|
||||
|
||||
<li><a name="ls4"> <strong>Dans quel ordre les fichiers et répertoires
|
||||
sont-ils classés par défaut? Quelles sont les options qui peuvent servir à
|
||||
modifier ce critère de classement ?</strong> </a>
|
||||
|
||||
<p>
|
||||
Pour savoir cela, il faut chercher le mot <em>sort</em> dans le man de
|
||||
<code>ls</code>. La première occurence vous dit que par défaut le résultat est
|
||||
trié par ordre alphabétique, selon la première lettre des fichiers. De façon
|
||||
plus précise, l'ordre est le suivant : ponctuations, chiffres,
|
||||
majuscules, minuscules, selon l'ordre défini par la table des caractères
|
||||
ASCII.</p>
|
||||
|
||||
<p>
|
||||
En continuant à chercher, vous trouvez des options intéressantes :
|
||||
<code>-r</code> (<em>reverse</em>), qui inverse l'ordre de classement,
|
||||
<code>-t</code> (<em>time</em>) qui trie en fonction de la date de dernière
|
||||
modification.</p>
|
||||
</li>
|
||||
|
||||
<li><a name="ls5"> <strong>Affichez le contenu de votre répertoire courant de
|
||||
telle sorte que les fichiers modifiés récemment apparaissent en
|
||||
premier.</strong> </a>
|
||||
|
||||
<pre>
|
||||
ls -t
|
||||
</pre>
|
||||
<p class="continue">
|
||||
si vous voulez juste modifier le critère de tri, sans plus de renseignements;
|
||||
ou encore</p>
|
||||
<pre>ls -lt</pre>
|
||||
<p class="continue">
|
||||
si vous voulez une longue liste.
|
||||
</p></li>
|
||||
|
||||
<li><a name="ls6"> <strong>Quels sont les droits de votre répertoire
|
||||
<code>Mail</code> ? Qu'est-ce que cela signifie ?</strong> </a>
|
||||
|
||||
|
||||
<p>
|
||||
La ligne ressemble à ceci :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
drwx------ 2 toto litt98 512 Apr 2 19:02 Mail
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Le <code>d</code> indique qu'il s'agit d'un répertoire (<em>directory</em>).
|
||||
Suivent ensuite neuf caractères, allant par trois; <code>r, w, x</code>
|
||||
correspondent aux droits que vous avez sur le répertoire (ou le
|
||||
fichier) : <code>r</code> (<em>read</em>) pour le droit de lecture,
|
||||
<code>w</code> (<em>write</em>) pour le droit d'écriture, <code>x</code>
|
||||
(<em>execute</em>) pour le droit d'exécution.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Les six tirets qui suivent correspondent aux droits qu'ont le groupe (ici
|
||||
<code>litt98</code>) puis le reste des utilisateurs. Ici il y a des tirets, ce
|
||||
qui signifie qu'ils n'ont aucun droit sur ce répertoire.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Cela veut dire que seul le propriétaire a le droit de lire et écrire dans son
|
||||
répertoire <code>Mail/</code>, ainsi que d'y accéder. Les répertoires et les
|
||||
fichiers de courrier sont protégés contre les indiscrétions.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Un fichier de texte standard a les droits suivants :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
-rw-r--r--
|
||||
</pre>
|
||||
|
||||
|
||||
<p> Il y a un tiret tout au début, ce qui signifie que c'est un fichier
|
||||
normal; vous avez le droit d'écrire et de lire (<code>rw-</code>), votre
|
||||
groupe et les autres utilisateurs ont le droit de lire le fichier
|
||||
(<code>r--</code>). La commande <a
|
||||
href="&url.tuteurs;unix/droits.html"><code>chmod</code></a> permet de
|
||||
changer ces droits, si l'on veut restreindre la lecture, ou rendre un
|
||||
fichier exécutable. </p>
|
||||
|
||||
|
||||
<p>
|
||||
Remarque : ne cédez pas à la paranoïa... vos camarades ne passent pas
|
||||
leur temps à farfouiller sur les comptes des voisins, donc vous n'avez pas
|
||||
besoin d'interdire à la lecture tout ce que vous avez chez vous.
|
||||
</p></li>
|
||||
|
||||
<li><a name="ls7"> <strong>Décrivez le résultat de la commande
|
||||
<code>ls -l</code>. </strong> </a>
|
||||
|
||||
<ul>
|
||||
|
||||
<li>
|
||||
|
||||
<pre>
|
||||
<strong>-rw-r--r--</strong> 1 robin litt95 754 Mar 22 11:59 projet.aux
|
||||
</pre>
|
||||
|
||||
<p>Les dix premiers caractères détaillent les droits du fichier. Le premier
|
||||
caratère identifie le type du fichier : ici, rien n'est spécifié, c'est
|
||||
donc un fichier normal. L'exercice précédent détaille la signification des
|
||||
lettres suivantes. Ce sont les droits normaux d'un fichier standard :
|
||||
tout le monde (propriétaire, groupe et autres utilisateurs) peut lire le
|
||||
fichier, seul le propriétaire peut écrire dedans.
|
||||
</p>
|
||||
</li>
|
||||
|
||||
|
||||
<li>
|
||||
<pre>
|
||||
-rw-r--r-- <strong>1</strong> robin litt95 754 Mar 22 11:59 projet.aux
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Le chiffre indique le nombre de liens. Nous vous renvoyons aux exercices sur
|
||||
les liens pour plus d'explications (qui peuvent attendre à un niveau
|
||||
débutant...).
|
||||
</p></li>
|
||||
|
||||
<li>
|
||||
<pre>
|
||||
-rw-r--r-- 1 <strong>robin</strong> litt95 754 Mar 22 11:59 projet.aux
|
||||
</pre>
|
||||
<p>
|
||||
Le troisième champ donne le nom du propriétaire du fichier. Ici, il s'agit de
|
||||
l'utilisateur <code>robin</code>.</p></li>
|
||||
|
||||
<li>
|
||||
<pre>
|
||||
-rw-r--r-- 1 robin <strong>litt95</strong> 754 Mar 22 11:59 projet.aux
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Ce champ indique le groupe de l'utilisateur. Ici, nous apprenons qu'Émilia est
|
||||
une littéraire de la promotion 1995.
|
||||
</p></li>
|
||||
|
||||
<li>
|
||||
<pre>
|
||||
-rw-r--r-- 1 robin litt95 <strong>754</strong> Mar 22 11:59 projet.aux
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Ce chiffre donne la taille en octets du fichier considéré. Ici, le fichier
|
||||
fait 754 octets, soit moins d'un Ko (1000 octets). C'est un petit fichier.
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
-rw-r--r-- 1 robin litt95 754 <strong>Mar 22 11:59</strong> projet.aux
|
||||
</pre>
|
||||
|
||||
|
||||
<p>Ce champ indique la date de dernière modification du fichier, ici le 22 mars
|
||||
de l'année courante, à 11h59. Quand le fichier date d'une année antérieure,
|
||||
celle-ci est indiquée et l'heure ne figure plus.</p>
|
||||
|
||||
<pre>
|
||||
-rw-r--r-- 1 robin litt95 754 Mar 22 11:59 <strong>projet.aux</strong>
|
||||
</pre>
|
||||
<p>
|
||||
Vient enfin le nom du fichier. Le suffixe <code>.aux</code> montre qu'il s'agit
|
||||
d'un fichier produit par LaTeX lors de la compilation d'un fichier
|
||||
<code>projet.tex</code>.</p></li>
|
||||
|
||||
</ul></li>
|
||||
|
||||
<li><a name="ls8"> <strong> Comment afficher les droits d'un répertoire
|
||||
donné ? </strong> </a>
|
||||
|
||||
<p>
|
||||
Si on tape
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
ls -l repertoire/
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
c'est le contenu du répertoire qui s'affiche, et pas son statut à lui.
|
||||
L'option <code>-d</code> (<em>directory</em>) permet de lister le répertoire
|
||||
lui-même.
|
||||
</p></li>
|
||||
|
||||
<li><a name="ls9"> <strong>Caractères identifiant les fichiers </strong> </a>
|
||||
<p>
|
||||
Ce sont les caractères suivants :
|
||||
</p>
|
||||
|
||||
|
||||
<table class="tableau">
|
||||
<tr>
|
||||
<td>slash</td>
|
||||
<td>(<code>/</code>)</td>
|
||||
<td>pour un répertoire</td>
|
||||
</tr>
|
||||
|
||||
<tr>
|
||||
<td>arobase</td>
|
||||
<td>(<code>@</code>)</td>
|
||||
<td>pour un lien symbolique</td>
|
||||
</tr>
|
||||
|
||||
<tr>
|
||||
<td>étoile</td>
|
||||
<td>(<code>*</code>)</td>
|
||||
<td>pour un exécutable</td>
|
||||
</tr>
|
||||
|
||||
<tr>
|
||||
<td><em>pipe</em></td>
|
||||
<td>(<code>|</code>)</td>
|
||||
<td>pour un <em>pipe</em> nommé</td>
|
||||
</tr>
|
||||
|
||||
<tr>
|
||||
<td>égal</td>
|
||||
<td>(<code>=</code>)</td>
|
||||
<td>pour un socket</td>
|
||||
</tr>
|
||||
</table>
|
||||
|
||||
<p>
|
||||
C'est l'option <code>-F</code> qui permet de les afficher.
|
||||
</p></li>
|
||||
|
||||
|
||||
<li><a name="ls10"> <strong>Droits sur un répertoire </strong> </a>
|
||||
|
||||
<p>
|
||||
Avoir le droit d'«exécuter» un répertoire, c'est avoir le droit d'y accéder,
|
||||
de s'y déplacer; mais je n'ai pas le droit de «lire» son contenu. Donc, à
|
||||
moins d'en être propriétaire, je ne peux pas afficher le contenu d'un
|
||||
répertoire ayant comme droits :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
drwx--x--x
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
</ol>
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Émilia Robin, Joël Riou. Dernière modification le 2002-12-08.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
288
unix/exercices/solutions/mkdir_cd-sol.tml
Normal file
288
unix/exercices/solutions/mkdir_cd-sol.tml
Normal file
|
|
@ -0,0 +1,288 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>Répertoires</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>Corrigé des exercices sur les répertoires
|
||||
(<code>mkdir</code>, <code>rmdir</code>, <code>cd</code>)</h1>
|
||||
|
||||
<p>
|
||||
Ces exercices sont des questions de cours : les solutions se trouvent
|
||||
toutes dans les pages de man des commandes en question. On suppose donc
|
||||
connues les commandes de <code>less</code>, qui servent à se déplacer dans
|
||||
les pages de man... et la commande servant à chercher un mot. Testez les
|
||||
commandes sur des fichiers et répertoires d'essai pour vous faire la main et
|
||||
comprendre ce qui se passe.</p>
|
||||
|
||||
<h2><a name="mkdir"><code>mkdir, rmdir</code></a></h2>
|
||||
|
||||
<ol>
|
||||
|
||||
<li><a name="mk1"> <strong>Créez trois répertoires en une seule ligne de
|
||||
commande</strong></a>.
|
||||
|
||||
<p>
|
||||
Si vous voulez créer trois répertoires <code>bla</code>, <code>ble</code> et
|
||||
<code>bli</code>, tapez
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
mkdir bla ble bli
|
||||
</pre></li>
|
||||
|
||||
<li><a name="mk2"> <strong>Effacez ces trois répertoires en une seule ligne
|
||||
de commande</strong> </a>.
|
||||
|
||||
<p>
|
||||
Il faut taper
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
rmdir bla ble bli
|
||||
</pre></li>
|
||||
|
||||
|
||||
|
||||
<li><a name="mk3"> <strong>Que se passe-t-il si vous tapez <code>mkdir
|
||||
mkdir</code> ?</strong> </a>
|
||||
|
||||
<p>Vous créez chez vous un répertoire appelé <code>mkdir</code>.</p>
|
||||
</li>
|
||||
|
||||
<li><a name="mk4"> <strong>Vous voulez détruire un répertoire
|
||||
<code>bla/</code>... mais ça ne marche pas.</strong> </a>
|
||||
|
||||
<p>
|
||||
<code>ls</code> vous dit qu'il est vide, et pourtant vous ne réussissez pas à
|
||||
l'effacer : c'est qu'il n'est pas vide. Il doit y avoir des fichiers
|
||||
cachés, commençant par un point, que vous ne voyez pas avec <code>ls</code>
|
||||
sans option. Il faut taper
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
ls -a
|
||||
</pre>
|
||||
<p class="continue">
|
||||
et effacer les fichiers trouvés.
|
||||
</p></li>
|
||||
|
||||
<li><a name="mk5"> <strong>Est-ce que <code>mkdir</code> peut prendre des
|
||||
options ?</strong> </a>
|
||||
<p>
|
||||
Oui, une : l'option <code>-p</code>, dont on va parler tout de suite.
|
||||
</p></li>
|
||||
|
||||
<li><a name="mk6"> <strong>À quelle condition est-ce que la ligne de commande
|
||||
«<code>mkdir Rapport/annexes</code>» peut fonctionner et créer effectivement
|
||||
ce sous-répertoire ? </strong> </a>
|
||||
|
||||
<p>
|
||||
Il faut que le répertoire <code>Rapport</code> existe, pour que l'on puisse y
|
||||
créer un sous-répertoire.
|
||||
</p></li>
|
||||
|
||||
<li><a name="mk7"> <strong>Y a-t-il une option de <code>mkdir</code> qui
|
||||
permette de créer à la fois un répertoire et un sous-répertoire de ce
|
||||
répertoire ?</strong> </a>
|
||||
|
||||
<p>
|
||||
Oui, c'est l'option <code>-p</code>. Quand vous tapez
|
||||
</p>
|
||||
|
||||
<pre>mkdir -p Rapport/annexes
|
||||
</pre>
|
||||
|
||||
<p class="continue">
|
||||
un répertoire <code>Rapport</code> est créé, et dans ce répertoire un
|
||||
sous-répertoire <code>annexes</code>.
|
||||
</p></li>
|
||||
|
||||
<li><a name="mk8"> <strong> Comment créer un répertoire en spécifiant des
|
||||
droits ? </strong> </a>
|
||||
|
||||
<p>
|
||||
On utilise l'option <code>-m</code> (<em>mode</em>) de <code>mkdir</code>.
|
||||
Par exemple :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
<span class="bireme ~ $">bireme ~ $</span> mkdir -m 700 Mail
|
||||
<span class="bireme ~ $">bireme ~ $</span> ls -ld Mail
|
||||
drwx------ 2 robin litt95 2048 Jun 2 15:27 Mail/
|
||||
</pre></li>
|
||||
|
||||
|
||||
<li><a name="mk9"> <strong> Quel est l'effet de la commande
|
||||
suivante :</strong></a>
|
||||
<pre> rmdir -p toto/tata/tutu/</pre>
|
||||
|
||||
<p>
|
||||
Cette commande efface toute la hiérarchie des répertoires, à condition qu'ils
|
||||
soient vides; si par exemple <code>tutu/</code> est vide mais
|
||||
<code>toto/</code> ne l'est pas, <code>tutu/</code> sera effacé mais pas
|
||||
<code>toto/</code>, et le programme s'arrête.
|
||||
</p></li>
|
||||
|
||||
|
||||
|
||||
<li><a name="mk10"> <strong>Création récursive sans message d'erreur
|
||||
</strong> </a>
|
||||
<p>
|
||||
On achève avec ceci le tour de l'option <code>-p</code>... Si donc on tape
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
mkdir -p toto/tutu/
|
||||
</pre>
|
||||
<p class="continue">
|
||||
le sous-répertoire <code>tutu/</code> est créé si <code>toto/</code> existe
|
||||
déjà; et si <code>toto/</code> n'existe pas, ce répertoire et son
|
||||
sous-répertoire sont créés. Il n'y a pas de message d'erreur.
|
||||
</p></li>
|
||||
|
||||
</ol>
|
||||
|
||||
<h2><a name="cd"><code>cd</code></a></h2>
|
||||
|
||||
<p>
|
||||
But de l'exercice : apprendre à se servir de <code>.</code> et
|
||||
<code>..</code> («point» et «point point»). <code>..</code> désigne le
|
||||
répertoire père du répertoire courant, et <code>.</code> désigne le répertoire
|
||||
courant. <code>..</code> sert beaucoup avec <code>cd</code>, pour remonter
|
||||
d'un niveau dans une arborescence; <code>.</code> est très utile avec des
|
||||
commandes comme <code>mv</code> ou <code>cp</code>, où il signifie en fait
|
||||
«ici».
|
||||
</p>
|
||||
|
||||
<p class="centre">
|
||||
<a name="arbo">
|
||||
<img src="exocd.gif" alt="[Exemple d'arborescence]" />
|
||||
</a>
|
||||
</p>
|
||||
|
||||
<ol>
|
||||
|
||||
<li><a name="cd1"> <strong>Dans quel répertoire vous trouvez-vous quand vous
|
||||
vous loguez ?</strong> </a>
|
||||
|
||||
<p>
|
||||
Vous vous trouvez dans votre répertoire personnel, dans <code>~</code> (tilde).
|
||||
</p></li>
|
||||
|
||||
<li><a name="cd2"> <strong>Allez directement dans
|
||||
<code>~/Rapport/docs/afaire/</code></strong> </a>
|
||||
|
||||
<p>
|
||||
Taper
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
cd Rapport/docs/afaire
|
||||
</pre></li>
|
||||
|
||||
<li><a name="cd3"> <strong>De là, passez dans
|
||||
<code>~/Rapport/docs/fait/</code></strong> </a>
|
||||
|
||||
|
||||
<pre>
|
||||
cd ../fait
|
||||
</pre></li>
|
||||
|
||||
|
||||
<li><a name="cd4"> <strong>Revenez dans <code>~/Rapport/</code></strong>
|
||||
</a>
|
||||
<p>
|
||||
Taper
|
||||
</p>
|
||||
<pre>
|
||||
cd ../..
|
||||
</pre>
|
||||
<p class="continue">
|
||||
ou
|
||||
</p>
|
||||
<pre>
|
||||
cd ~/Rapport
|
||||
</pre></li>
|
||||
|
||||
|
||||
|
||||
<li><a name="cd5"> <strong>Sans changer de répertoire, regardez avec
|
||||
<code>less</code> le contenu de <code>~/www/index.html</code></strong>
|
||||
</a>
|
||||
|
||||
<p>
|
||||
Il faut taper
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
less ~/www/index.html
|
||||
</pre>
|
||||
<p class="continue">
|
||||
ou
|
||||
</p>
|
||||
<pre>
|
||||
less ../www/index.html
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
|
||||
<li><a name="cd6"> <strong>Passez dans <code>~/Rapport/docs/</code></strong>
|
||||
</a>
|
||||
|
||||
<pre>
|
||||
cd docs/
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="cd7"> <strong>En restant là où vous êtes, affichez les droits de
|
||||
<code>~/Mail/</code></strong> </a>
|
||||
|
||||
|
||||
<p>
|
||||
Il y a un petit piège dans cette question. En effet, si vous tapez</p>
|
||||
<pre>
|
||||
ls -l Mail/
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
vous allez obtenir le contenu du répertoire <code>Mail/</code>, mais pas le
|
||||
statut du répertoire lui-même. Il faut donc utiliser l'option <code>-d</code>
|
||||
de <code>ls</code> :
|
||||
</p>
|
||||
|
||||
<pre>
|
||||
<span class="prompt">bireme ~ $</span> ls -ld Mail
|
||||
drwx------ 2 toto litt98 512 Apr 2 19:02 /users/98/litt/toto/Mail/
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
<li><a name="cd8"> <strong>Revenez dans votre répertoire principal</strong>
|
||||
</a>
|
||||
|
||||
<p>
|
||||
Taper <code>cd</code>, sans arguments.
|
||||
</p>
|
||||
</li>
|
||||
|
||||
<li><a name="cd9"> <strong>Que se passe-t-il si vous vous déloguez alors que
|
||||
vous n'êtes pas dans votre répertoire principal ?</strong> </a>
|
||||
|
||||
<p>
|
||||
Strictement rien ! Ça n'a aucune importance.
|
||||
</p></li>
|
||||
|
||||
</ol>
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Émilia Robin, Joël Riou. Dernière modification le 2002-12-08.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
|
||||
398
unix/exercices/systeme.tml
Normal file
398
unix/exercices/systeme.tml
Normal file
|
|
@ -0,0 +1,398 @@
|
|||
<?xml version="1.0" encoding="ISO-8859-1"?>
|
||||
<!DOCTYPE html
|
||||
PUBLIC "-//ENS/Tuteurs//DTD TML 1//EN"
|
||||
"tuteurs://DTD/tml.dtd">
|
||||
<html>
|
||||
<head>
|
||||
<title>Système</title>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<h1>Exercices sur le système</h1>
|
||||
|
||||
|
||||
<h2><a name="droits">Les droits </a> </h2>
|
||||
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#droits1">&icone.solution;
|
||||
</a>
|
||||
Changez les droits d'un fichier <tt>fic1</tt> pour que tous ceux de votre
|
||||
groupe puissent écrire dedans.</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#droits2">&icone.solution;
|
||||
</a>
|
||||
Donnez en une seule ligne le droit d'exécution à tous les utilisateurs d'un
|
||||
fichier <tt>script</tt> qui n'a jusqu'alors que des droits standards
|
||||
(<tt>-rw-r--r--</tt>).</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#droits3">&icone.solution;
|
||||
</a>
|
||||
Le fichier <tt>toto</tt> a les droits suivants : <tt>-rwxr--r--</tt>.
|
||||
Modifiez-en les droits en une ligne de commande de sorte que le
|
||||
propriétaire n'ait plus que le droit de lecture.</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#droits4">&icone.solution;
|
||||
</a>
|
||||
Modifier les droits du fichier <tt>toto</tt> (<tt>-rwxr--r--</tt>) de sorte
|
||||
que le groupe et les autres utilisateurs aient les mêmes droits que le
|
||||
propriétaire.</li>
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#droits5">&icone.solution;
|
||||
</a>
|
||||
Quelle option permet de modifier récursivement les droits d'un répertoire
|
||||
et des fichiers qu'il contient ?</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#droits6">&icone.solution;
|
||||
</a>
|
||||
Quelle option de <tt>mkdir</tt> permet de créer un répertoire en spécifiant
|
||||
les droits sur ce répertoire ?</li>
|
||||
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#droits7">&icone.solution;
|
||||
</a>
|
||||
Affichez et interprétez les droits de <tt>/bin/mount</tt>. </li>
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
<h2><a name="liens"> Les liens</a> </h2>
|
||||
<!-- ################################# !-->
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#liens1">&icone.solution;
|
||||
</a>
|
||||
Vous avez chez vous un répertoire <tt>tmp/</tt> qui contient un fichier
|
||||
<tt>bidon</tt>. Créez un lien physique sur <tt>tmp/bidon</tt> appelé
|
||||
<tt>blo</tt>, dans votre répertoire d'accueil (<tt>HOME</tt>). Comparez
|
||||
les contenus de <tt>tmp/bidon</tt> et de <tt>blo</tt>. Que contient
|
||||
<tt>blo</tt> ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#liens2">&icone.solution;
|
||||
</a>
|
||||
Même question avec un lien symbolique.</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#liens3">&icone.solution;
|
||||
</a>
|
||||
Quelles sont les différences entre les liens durs et les liens
|
||||
symboliques ?</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#liens4">&icone.solution;
|
||||
</a>
|
||||
Dans quel cas ne peut-on pas faire de lien physique ? Que faut-il
|
||||
faire ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#liens5">&icone.solution;
|
||||
</a>
|
||||
Quel est l'effet de <tt>chmod</tt> sur un lien ?</li>
|
||||
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
<h2><a name="processus"> Les processus </a></h2>
|
||||
<!-- ######################################### !-->
|
||||
|
||||
<ol>
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#processus1">&icone.solution;
|
||||
</a>
|
||||
Affichez la liste des processus associés à votre terminal. Affichez la
|
||||
liste des processus dont vous êtes propriétaire. Recommencez en utilisant
|
||||
les options <tt>-l</tt> et <tt>-f</tt>. À quoi correspondent les colonnes
|
||||
<tt>PID</tt> et <tt>PPID</tt> ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#processus2">&icone.solution;
|
||||
</a>
|
||||
Lancez une commande longue en arrière plan. Quel est le comportement du
|
||||
processus associé lorsqu'il reçoit les signaux suivants :
|
||||
|
||||
<ul>
|
||||
|
||||
<li> <tt>sigkill</tt> (9)</li>
|
||||
|
||||
<li> <tt>sigstop</tt> (23)</li>
|
||||
|
||||
<li> <tt>sigcont</tt> (25)</li>
|
||||
|
||||
</ul></li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#processus3">&icone.solution;
|
||||
</a>
|
||||
Utilisez la commande <tt>nice</tt> pour lancer des commandes ayant une
|
||||
faible priorité.</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#processus4">&icone.solution;
|
||||
</a>
|
||||
Interprétez la hiérarchie des processus qui vous appartiennent. Quelle est
|
||||
la hiérarchie des processus communiquant par un tube ? Utilisez par
|
||||
exemple <tt>ls -R / | grep 'a' | cut -c1-3</tt>.</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#processus5">&icone.solution;
|
||||
</a>
|
||||
La commande <tt>ps | wc</tt> compte deux processus en plus de ceux qui
|
||||
existent réellement lorsqu'on lance la commande. Pourquoi ?</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#processus6">&icone.solution;
|
||||
</a>
|
||||
Donner deux commandes pour reprendre l'exécution d'une instruction
|
||||
interrompue par un <tt>^Z</tt>.</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#processus7">&icone.solution;
|
||||
</a>
|
||||
À quoi correspondent les colonnes <tt>PID</tt> et <tt>PPID</tt> qui
|
||||
apparaissent après l'exécution de la commande <tt>ps</tt> ?</li>
|
||||
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
<h2><a name="shell">Programmation du shell</a></h2>
|
||||
<!-- ############################################### !-->
|
||||
|
||||
|
||||
|
||||
|
||||
<ol>
|
||||
<li> <a href="solutions/systeme-sol.html#shell2">&icone.solution;
|
||||
</a>
|
||||
Faites deux scripts qui vous disent bonjour en affichant votre login
|
||||
(«Bonjour, toto») :
|
||||
|
||||
<ul>
|
||||
<li> Quand vous tapez <tt>saluer [votre-login]</tt></li>
|
||||
<li> Quand vous tapez juste <tt>saluer</tt></li>
|
||||
</ul></li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell3">&icone.solution;
|
||||
</a>
|
||||
Faites un script qui vous dit «Bonjour, [toto]», que vous indiquiez ou
|
||||
non votre login.</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell4">&icone.solution;
|
||||
</a>
|
||||
Faire un script qui affiche la phrase : <tt>Le script [script] a [n]
|
||||
paramètre(s), que voici : [paramètres]</tt>, en remplaçant les mots entre
|
||||
crochets par leur valeur; par exemple :
|
||||
|
||||
|
||||
<pre>
|
||||
<span class="prompt">chaland ~ $</span>script bla ble bli blo blu
|
||||
La commande script a 5 paramètre(s), que voici : bla ble bli blo blu
|
||||
</pre></li>
|
||||
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell5">&icone.solution;
|
||||
</a>
|
||||
Créez une commande qui, lorsqu'elle est appelée, renvoie le nombre
|
||||
d'arguments qui lui ont été fournis, ainsi que le premier de ces
|
||||
arguments.</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell6">&icone.solution;
|
||||
</a>
|
||||
Vous voulez écrire un script qui vous dit combien de personnes sont loguées
|
||||
sur une machine donnée; par exemple :
|
||||
|
||||
<pre>
|
||||
<span class="prompt">drakkar ~ $</span> combien galion
|
||||
Il y a 5 personne(s) loguées sur galion en ce moment.
|
||||
<span class="prompt">drakkar ~ $</span>
|
||||
</pre></li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell7">&icone.solution;
|
||||
</a> On veut remplacer
|
||||
le suffixe <tt>.htm</tt> d'un ensemble de fichiers en
|
||||
<tt>.html</tt>.</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell8">&icone.solution;
|
||||
</a> Un ensemble de
|
||||
noms de fichiers sont en majuscules. On veut tout basculer en minuscules.</li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell9">&icone.solution;
|
||||
</a>
|
||||
Créez un script <tt>indice</tt> qui affiche l'indice de son premier
|
||||
argument dans la liste des arguments suivants. Par exemple,
|
||||
<pre>
|
||||
indice toto tata titi toto tutu
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
renvoie l'indice de <tt>toto</tt> dans la liste <tt>tata titi toto
|
||||
tutu</tt>, c'est-à-dire 3.</p></li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell10">&icone.solution;
|
||||
</a>
|
||||
On ne s'intéresse ici qu'à des fichiers contenant un mot par ligne. Écrire
|
||||
un script qui compte le nombre de mots contenant une des lettres «r», «s»
|
||||
ou «t», et parmi eux, ceux qui ont au moins deux telles lettres. On
|
||||
donnera aussi le nombre de mots ne contenant aucune voyelle. Cela donnera
|
||||
par exemple :
|
||||
|
||||
<pre>
|
||||
Dans ce fichier, vous avez :
|
||||
45 mots contenant «r», «s» ou «t», et parmi eux,
|
||||
12 contiennent deux de ces lettres au moins.
|
||||
Il y a aussi 10 mots ne contenant aucune voyelle.
|
||||
</pre>
|
||||
</li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell11">&icone.solution;
|
||||
</a>
|
||||
On veut chercher toutes les occurences des quatre éléments (terre, air, eau,
|
||||
feu) dans la première partie de <em>Germinal</em>.
|
||||
|
||||
<p>
|
||||
On veut aussi que le résultat soit placé dans un fichier, et que le résultat
|
||||
soit classé : toutes les lignes qui contiennent «air», puis toutes celles qui
|
||||
contiennent «eau», etc. </p></li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell12">&icone.solution;
|
||||
</a>
|
||||
Chercher le mot «mine» dans les chapitres 3, 4 et 5 de la première partie de
|
||||
<em>Germinal</em>, et obtenir un fichier dans lequel figure le nombre
|
||||
d'occurences du mot dans les fichiers, avec le numéro des lignes.</li>
|
||||
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell13">&icone.solution;
|
||||
</a>
|
||||
Créez un script <tt>coupe</tt> qui prend trois arguments, le premier étant
|
||||
un nom de fichier et les deux autres des entiers <em>l</em> et <em>l'</em>,
|
||||
et qui affiche les lignes comprises entre <em>l</em> et <em>l'</em> dans le
|
||||
fichier. Par exemple,
|
||||
<pre>
|
||||
coupe fic 4 8
|
||||
</pre>
|
||||
<p class="continue">
|
||||
affichera les lignes 4 à 8 du fichier <tt>fic</tt>. Affichez des messages
|
||||
en cas d'erreur (nombre de paramètres incorrect, fichier inexistant, etc).
|
||||
</p></li>
|
||||
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell14">&icone.solution;
|
||||
</a>
|
||||
Pour transformer une arborescence en un seul fichier compressé, on utilise
|
||||
l'instruction <pre>tar zcvf nouveaunom fichiersaregrouper</pre>
|
||||
|
||||
|
||||
<p>
|
||||
Avant d'envoyer des fichiers <tt>tar</tt>, on utilise <tt>uuencode</tt>.
|
||||
</p>
|
||||
|
||||
<p>
|
||||
Écrivez une commande <tt>tarmail</tt> qui prend deux arguments, une
|
||||
adresse et un nom de répertoire, et qui envoie par mail le contenu de
|
||||
l'arborescence du répertoire précédée d'un message expliquant comment la
|
||||
récupérer.</p>
|
||||
|
||||
|
||||
<p>
|
||||
Note : pour récupérer un fichier uuencodé, on tape <tt>uudecode</tt> et
|
||||
pour reconstruire l'arborescence, on utilise <tt>tar zxvf fichier</tt>.
|
||||
</p></li>
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell15">&icone.solution;
|
||||
</a>
|
||||
La commande suivante affiche le path complet de tous les fichiers finissant
|
||||
par <tt>~</tt> (tilde) dans la sous-arborescence du répertoire
|
||||
courant.
|
||||
|
||||
<pre>
|
||||
find . -name \( '*~' -0 'core' \) -print
|
||||
</pre>
|
||||
|
||||
<p>
|
||||
Écrivez un script qui prend en argument un nom de répertoire et qui
|
||||
détruit tous les fichiers :</p>
|
||||
|
||||
<ol>
|
||||
|
||||
<li> Finissant par <tt>~</tt>;</li>
|
||||
|
||||
<li> Commençant et finissant par un dièse;</li>
|
||||
|
||||
<li> S'appelant <tt>core</tt>;</li>
|
||||
|
||||
<li> S'appelant <tt>a.out</tt>.</li> </ol></li>
|
||||
|
||||
|
||||
|
||||
<li> <a href="solutions/systeme-sol.html#shell16">&icone.solution;
|
||||
</a>
|
||||
Écrire un sript permettant d'appliquer divers filtres sur un fichier. Ce
|
||||
script est lancé avec un argument, qui doit être un nom de fichier appelé
|
||||
fichier de travail; dans le cas contraire, on afficher un message d'erreur.
|
||||
On attend ensuite une commande en mode interactif, qui peut être :
|
||||
|
||||
<ul>
|
||||
|
||||
<li> <tt>end</tt> : le programme s'arrête;</li>
|
||||
|
||||
<li> <tt>cherche</tt> : le programme lit alors une ligne au clavier
|
||||
contenant un motif et une autre contenant un nom de fichier, puis écrit
|
||||
dans ce fichier les lignes du fichier de travail contenant le motif;</li>
|
||||
|
||||
<li> <tt>tete</tt> ou<tt>fin</tt> : le programme lit une ligne au clavier
|
||||
contenant un entier <em>n</em> puis une ligne contenant un nom de fichier.
|
||||
Il écrit ensuite les <em>n</em> premières (resp. dernières) lignes du
|
||||
fichier de travail dans le fichier précisé;</li>
|
||||
|
||||
<li> autre chose : message d'erreur.</li>
|
||||
|
||||
</ul></li>
|
||||
|
||||
</ol>
|
||||
|
||||
|
||||
<div class="metainformation">
|
||||
Auteur : Anonyme, Joël Riou. Dernière modification le 2002-12-08.
|
||||
</div>
|
||||
|
||||
</body>
|
||||
</html>
|
||||
|
||||
BIN
unix/exercices/zola.tgz
Normal file
BIN
unix/exercices/zola.tgz
Normal file
Binary file not shown.
Loading…
Add table
Reference in a new issue