Culture et Pratique de l’Informatique

TPs de shell

Arash HABIBI

Département d’informatique
Première année de licence
Semestre 1
2
Table des matières

1 Les systèmes d’exploitation et le shell 9

1.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Préalable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2.1 Un système d’exploitation . . . . . . . . . . . . . . . . . . . . . 9
1.2.2 L’utilisateur et le système . . . . . . . . . . . . . . . . . . . . . 11
1.2.3 Shell et navigateur de fichiers . . . . . . . . . . . . . . . . . . . 12
1.2.4 Les différents shells . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.3 Lancements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.3.1 Lancement d’un navigateur de fichiers . . . . . . . . . . . . . . 14
1.3.2 Lancement d’un terminal + shell . . . . . . . . . . . . . . . . . 14
1.3.3 Configuration pour les trois premiers TPs . . . . . . . . . . . . 14
1.4 Les commandes shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.1 structure générale . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.2 l’instruction ls . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.4.3 Lancer/arrêter une application . . . . . . . . . . . . . . . . . . 16
1.4.4 Opérations simples sur les fichiers . . . . . . . . . . . . . . . . 18
1.4.5 Complétion automatique et historique . . . . . . . . . . . . . . 18
1.5 La commande man . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.5.1 Un manuel très fourni . . . . . . . . . . . . . . . . . . . . . . . 18
1.5.2 Atelier syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.5.3 Atelier man . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2 L’arborescence des fichiers 21

2.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2 Préalable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.1 Le système de fichiers est un arbre . . . . . . . . . . . . . . . . 21
2.2.2 Quelques repères . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2.3 Un navigateur de fichier se déplace sur cette arborescence . . . 23
2.3 Se déplacer dans l’arborescence avec le shell . . . . . . . . . . . . . . . 23
2.3.1 Savoir se repérer : pwd . . . . . . . . . . . . . . . . . . . . . . . 23
2.3.2 Se déplacer pas à pas . . . . . . . . . . . . . . . . . . . . . . . 24
2.4 Chemins : relatif et absolu . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4.1 Chemin relatif . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4.2 Chemin absolu . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.4.3 Le répertoire courant, le répertoire parent, le dossier personnel 28
2.5 Toutes les commandes (ou presque) utilisent des chemins . . . . . . . 28
2.5.1 Pour la commande cd . . . . . . . . . . . . . . . . . . . . . . . 28
2.5.2 Pour les autres commandes . . . . . . . . . . . . . . . . . . . . 29
2.5.3 Copier et déplacer des fichiers et des répertoires . . . . . . . . . 31

3
 2.5.4 Développement et programmation . . . . . . . . . . . . . . . . 32
2.6 Les motifs et les jokers (ou wildcards) . . . . . . . . . . . . . . . . . . 34

3 Les droits d’accès aux fichiers et aux répertoires 37

3.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.2 Préalable : la version longue de la commande ls . . . . . . . . . . . . 37
3.3 Préalable : les utilisateurs, les groupes, les propriétaires . . . . . . . . 38
3.3.1 Le nom et le numéro d’utilisateur . . . . . . . . . . . . . . . . . 38
3.3.2 Le groupe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.4 Les droits d’accès . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.4.1 Lire les droits d’accès . . . . . . . . . . . . . . . . . . . . . . . 40
3.4.2 Modifier les droits d’accès . . . . . . . . . . . . . . . . . . . . . 42
3.5 Signification de l’accessibilité . . . . . . . . . . . . . . . . . . . . . . . 44
3.5.1 Droits de lecture/écriture/exécution d’un fichier . . . . . . . . 44
3.5.2 Droits de lecture/écriture/exécution d’un répertoire . . . . . . 45
3.6 Changer le propriétaire d’un fichier et son groupe . . . . . . . . . . . . 47

4 Les processus 49
4.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.2 Préalable : les processus . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.2.1 En substance . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.2.2 Processeur, Processus . . . . . . . . . . . . . . . . . . . . . . . 49
4.2.3 Process Identifier ou le pid . . . . . . . . . . . . . . . . . . . . 50
4.2.4 User Identifier ou le uid . . . . . . . . . . . . . . . . . . . . . . 50
4.2.5 La généalogie des processus . . . . . . . . . . . . . . . . . . . . 50
4.2.6 Le statut ou état d’un processus . . . . . . . . . . . . . . . . . 50
4.2.7 Mono-tâche, multi-tâche, priorités, ordonnancement . . . . . . 51
4.2.8 La "gentillesse" des processus . . . . . . . . . . . . . . . . . . . 51
4.3 Atelier : Lister les processus . . . . . . . . . . . . . . . . . . . . . . . . 52
4.3.1 La commande top . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.3.2 La commande ps . . . . . . . . . . . . . . . . . . . . . . . . . . 53
4.4 Les commandes nice et renice . . . . . . . . . . . . . . . . . . . . . . 55
4.5 Les signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5.1 Fonctionnement général . . . . . . . . . . . . . . . . . . . . . . 56
4.5.2 Utilité des signaux . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.5.3 La commande kill . . . . . . . . . . . . . . . . . . . . . . . . 56

5 D’autres commandes 59
5.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
5.2 Afficher un message à l’écran . . . . . . . . . . . . . . . . . . . . . . . 59
5.3 Créer/extraire une archive . . . . . . . . . . . . . . . . . . . . . . . . . 60
5.3.1 Archivage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
5.3.2 Compression . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.3.3 Archivage et compression . . . . . . . . . . . . . . . . . . . . . 61
5.4 Commandes diverses . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.4.1 La commande wc . . . . . . . . . . . . . . . . . . . . . . . . . . 62
5.4.2 Les commandes head et tail . . . . . . . . . . . . . . . . . . . 62
5.4.3 La commande cut . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.4.4 La commande sort . . . . . . . . . . . . . . . . . . . . . . . . 63
5.4.5 La commande grep . . . . . . . . . . . . . . . . . . . . . . . . 63
5.5 Lire les données depuis le terminal ? . . . . . . . . . . . . . . . . . . . 64
5.5.1 La commande bc . . . . . . . . . . . . . . . . . . . . . . . . . . 65

4
 5.5.2 La commande tr . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.5.3 La commande sed . . . . . . . . . . . . . . . . . . . . . . . . . 66
5.5.4 Les autres commandes . . . . . . . . . . . . . . . . . . . . . . . 66
5.6 Pour aller plus loin : les expressions régulières . . . . . . . . . . . . . . 66

6 Les redirections 67
6.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
6.2 Préalable : les fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
6.2.1 les Entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . 67
6.2.2 Sous Unix, tout est fichier . . . . . . . . . . . . . . . . . . . . . 68
6.2.3 Entrée standard, sortie standard, sortie standard erreur . . . . 69
6.3 Atelier : Rediriger les entrée/sorties standards . . . . . . . . . . . . . . 70
6.3.1 Rediriger la sortie standard vers un fichier . . . . . . . . . . . . 70
6.4 Atelier : Rediriger la sortie standard erreur vers un fichier . . . . . . . 70
6.5 Rediriger la sortie standard vers un autre terminal . . . . . . . . . . . 72
6.6 Atelier : Rediriger l’entrée standard . . . . . . . . . . . . . . . . . . . . 72
6.7 Atelier : Rediriger la sortie d’un fichier vers l’entrée d’un autre fichier 73
6.7.1 Redirection via un fichier intermédiaire . . . . . . . . . . . . . 73
6.7.2 Redirection via un tube (ou pipe) . . . . . . . . . . . . . . . . . 75
6.7.3 Plusieurs niveaux de traitements : le filtrage . . . . . . . . . . . 76

7 Les variables 79
7.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7.2 Les variables shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
7.2.1 Syntaxe de la définition . . . . . . . . . . . . . . . . . . . . . . 79
7.2.2 Expansion de variables . . . . . . . . . . . . . . . . . . . . . . . 80
7.2.3 Utilisation des accolades . . . . . . . . . . . . . . . . . . . . . . 80
7.2.4 Le type des données et l’utilisation des guillemets . . . . . . . . 81
7.2.5 Les apostrophes et les guillemets . . . . . . . . . . . . . . . . . 82
7.2.6 Les substitutions de commandes . . . . . . . . . . . . . . . . . 82
7.3 Variables de type numérique . . . . . . . . . . . . . . . . . . . . . . . . 83
7.4 La variable de status . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

8 Les scripts shell 87

8.1 Compétences visées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
8.2 Votre premier shell script . . . . . . . . . . . . . . . . . . . . . . . . . 87
8.3 Les variables d’environnement . . . . . . . . . . . . . . . . . . . . . . . 88
8.3.1 Définition, suppression, liste . . . . . . . . . . . . . . . . . . . . 88
8.3.2 Les variables d’environnement prédéfinies . . . . . . . . . . . . 89
8.3.3 Différence entre les variables shell et variables d’environnement 89
8.3.4 La variable PATH . . . . . . . . . . . . . . . . . . . . . . . . . . 90
8.4 Ce qui suit un caractère # . . . . . . . . . . . . . . . . . . . . . . . . . 92
8.4.1 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . 92
8.4.2 Le Shebang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
8.5 Les paramètres de position . . . . . . . . . . . . . . . . . . . . . . . . 93
8.6 La variable status ou diagnostique d’un script . . . . . . . . . . . . . . 94
8.6.1 La commande exit . . . . . . . . . . . . . . . . . . . . . . . . 94
8.6.2 Le diagnostique . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
8.7 La structure if, then, else . . . . . . . . . . . . . . . . . . . . . . . 94
8.8 Les boucles for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
8.9 Les boucles while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
8.10 Projets divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

5
8.10.1 Chercher les fichiers erronés . . . . . . . . . . . . . . . . . . . . 97
8.10.2 Traiter un fichier csv . . . . . . . . . . . . . . . . . . . . . . . 98

6
Introduction
Maîtriser le shell
Le cours de Culture et Pratique de l’Informatique et les TPs sont assez légèrement
corrélés. En d’autres termes, vous n’avez pas besoin d’avoir suivi les cours pour réussir
les TPs et réciproquement. L’objectif de ces TPs est d’introduire l’usage du shell.

Les compétences
Chaque chapitre de ce document contient deux composantes :
— une partie introductive préalable ;
— une partie expérimentale, avec des ateliers ;
L’objectif est de vous apprendre à utiliser le shell. Chaque chapitre est associé à un
certain nombre de compétences listées au début de ce chapitre. Le chapitre contient
une partie appelée préalable avec des éléments de connaissances résumés dans les
encadrés bleus, que vous devrez connaître. Il contient aussi des ateliers, dans des
encadrés roses, que vous devez avoir faits pour acquérir les compétences visées.

Les quiz
À la fin de chaque séance de TP, votre enseignant vous demandera de lire la partie
préalable du chapitre suivant (sans nécessairement avoir fait les ateliers). La séance
suivante débutera par une séance de questions portant sur cette partie préalable.
Lorsque vous aurez posé toutes vos questions, la séance se poursuivra par un quiz sur
Moodle qui évaluera :
— les compétences pratiques que vous aurez acquises à la séance précédente ;
— la lecture de la partie préalable pour la séance courante.
Pendant ces quiz, les cours et documents, papier ou numériques seront interdits. Vous
aurez seulement droit à une antisèche : une feuille A4 recto-verso manuscrite sur
laquelle vous pouvez écrire ou dessiner tout ce que vous souhaitez. Le premier quiz,
qui aura lieu dès la première séance de TP, sera un quiz d’essai. Sa note ne comptera
pas dans votre moyenne. Il portera sur la lecture de la section préalable du chapitre
1.
Avant chaque quiz, l’enseignant vous donnera un mot de passe qui vous permettra
de vous connecter sur le quiz de son groupe.
Si vous êtes absent à une séance de TP, vous avez 7 jours ouvrés pour déposer à
la scolarité du pôle L1 un justificatif d’absence. Il est tout à fait possible de scanner
ces justificatifs et les envoyer à la scolarité par mail. Si votre absence est jugée comme
justifiée, alors la note correspondante ne comptera pas dans votre moyenne. Dans le
cas contraire, la note du quiz correspondant sera de 0/20. Les critères de recevabilité
des justificatifs sont énoncés dans un texte de loi et ne sont pas décidés par le ou la
responsable de la scolarité.

7
 À la dernière séance, si vous le souhaitez, vous pouvez choisir un quiz, parmi les
huit, qui ne comptera pas dans votre moyenne.

8
Chapitre 1

Les systèmes d’exploitation et

le shell

Dans ce chapitre, nous allons introduire la notion de système d’exploitation et de

shell. Nous allons aussi découvrir les premières commandes du shell, en particulier
celles correspondant à des opérations locales à un répertoire.

1.1 Compétences visées

1. Lancer un navigateur de fichiers, lancer un shell ;
2. Connaître la liste des fichiers dans le répertoire ;
3. Lancer une application ;
4. Créer ou modifier un fichier texte ;
5. Copier, renommer et supprimer un fichier ;
6. Créer et supprimer un répertoire ;
7. Utiliser la complétion automatique et l’historique des commandes ;
8. Interrompre un programme ;
9. Lancer un programme en tâche de fond ;
10. En lisant la page man d’une commande, de savoir si une ligne de commande
est syntaxiquement valide.

1.2 Préalable
1.2.1 Un système d’exploitation
Le matériel seul ne peut rien faire

Un ordinateur, en tant qu’objet, est constitué de composantes électroniques :

disque(s), mémoires, processeurs etc.

Le disque contient des données sous la forme de 0 ou de 1, mais il ne sait pas ce

qu’est un fichier. Plus précisément, le disque seul ne contient aucune information
qui puisse associer ces 0 et ces 1 à un fichier ou un autre ;

9
La mémoire contient des données sous la forme de 8 bits (octets), chaque octet
ayant une adresse. Mais la mémoire ne sait pas ce qu’est un caractère, un en-
tier, un flottant, un pixel dans une image, une variable globale, locale etc. Plus
précisément la mémoire seule ne contient aucune information qui puisse associer
un octet de données à une application ou à une autre, à un nombre, à une image
etc.
Un processeur , enfin, sait exécuter des instructions en langage machine, permet-
tant de transférer des données entre le disque, la mémoire et ses registres, mais il
ne sait pas ce qu’est une application, un processus, ou une périphérique (clavier,
souris, écran, touchpad etc). Plus précisément, le processeur seul, ne contient au-
cune information permettant de savoir si l’instruction qu’il exécute correspond
à une application ou à une autre.

Figure 1.1 – Un processeur.

Image provenant de
https://www.networkworld.com/article/3306447/a-new-arm-based-server-processor-challenges-for-the-data-c

Ce que fait le système d’exploitation

Un système d’exploitation (en anglais Operating System ou OS) est un programme

qui s’occupe de gérer, pour nous, les composants matériels de l’ordinateur. Un système
d’exploitation permet de :
— organiser le disque en une arborescence de fichiers ;
— lancer un ou plusieurs programmes/applications pouvant marcher simultané-
ment sur le processeur ;
— fournir de l’espace mémoire à ces programmes ;
— faire communiquer le processeur et les périphériques : clavier, touchpad, souris,
écran etc.
Dans ce cours, nous n’allons pas apprendre le fonctionnement d’un système d’ex-
ploitation. Ceux d’entre vous qui s’orienteront vers l’informatique le verront dans
quelques semestres. En revanche, nous allons voir de plus près comment utiliser le
système d’exploitation.

10
Exemples de systèmes d’exploitation
Linux : Par défaut, les ordinateurs de l’UFR de Math-Info utilisent le système Linux
dont se réclament plusieurs disbrituions : Ubuntu (qui tourne sur les machines
de notre UFR), Redhat, Suze, Debian, Fedora etc.
Unix : Les systèmes Linux utilisés sur les ordinateurs de type PC, fait partie d’une
famille plus grande appelée Unix. Les systèmes de type MacOS font aussi partie
de la famille Unix.
Windows : La plupart des ordinateurs (PC) achetés dans le commerce sont livrés
avec le système d’exploitation Windows mis au point par microsoft corporation.
Les machines de l’UFR de Math-Info permettent également d’utiliser le système
Windows.
Téléphones : Les téléphones portables sont de véritables ordinateurs et qui utilisent
aussi un système d’exploitation iOS (pour les iPhones) ou androïd.

Figure 1.2 – Windows, MacOs, Android et Linux.

Image provenant de
https://www.howtogeek.com/361572/what-is-an-operating-system/

On dit qu’une machine marche SOUS Linux ou SOUS windows.

Dans la suite de ce cours, lorsqu’on perlera de système, on entendra système d’ex-
ploitation.

1.2.2 L’utilisateur et le système

Applications, système, matériel

Comme le montre la figure 1.3, l’uti-

lisateur ne peut agir sur l’ordinateur
qu’au travers d’applications (ou pro-
grammes). Par exemple un navigateur
web, une calculatrice ou un éditeur de
texte comme Word sont des applica-
tions.
Ces applications utilisent le système
d’exploitation pour gérer les fichiers et
les processus.
Enfin, à son tour, le système d’ex-
ploitation traduit les interactions avec
les processus et fichiers en instructions Figure 1.3 – L’utilisateur ne peut
exécutables par le matériel. agir sur l’ordinateur qu’au travers
d’applications.

11
 Quelquefois, certaines applications pourraient presque faire oublier l’existence de
fichiers et de processus. Dans ce cours, notre objectif est précisément d’étudier des
applications appelées shell permettant d’interagir avec le système et, en particulier,
avec les fichiers et les processus.

1.2.3 Shell et navigateur de fichiers

La plupart d’entre vous avez déjà interagi avec les fichiers de votre ordinateur au
moyen d’un navigateur (ou explorateur) de fichiers comme ceux représentés sur les
figures 1.4 et 1.5.

Figure 1.5 – Le navigateur de fichiers

Figure 1.4 – Explorateur de appelé nautilus utilisé sur les machines
fichiers sous windows. Ubuntu de l’UFR.
Image provenant Image provenant de
https://www.computerhope.com/jargon/ https://askubuntu.com/questions/856918/
e/explorer.htm loss-of-nautilus-menu-functionality-in-ubuntu-16-04-lts

Les systèmes d’exploitation fournissent aussi une autre façon d’interagir avec le
système au moyen de lignes de commande. Sous windows, il s’agit de l’invite de
commandes (figure 1.6). Sous Unix (MacOs et Linux et, en particulier, Ubuntu) il
s’agit du shell (figure 1.7).

Figure 1.6 – Invite de commande

sous Windows.
Image provenant de http://duduf.com/ Figure 1.7 – Un terminal exécutant
using-the-command-line- on-windows/ un shell sous Ubuntu.
Que choisir ?
Historiquement, on a d’abord utilisé les invites de commande et le shell. Les navi-
gateurs de fichiers ont été inventés bien plus tard. Ces derniers constituent indénia-
blement un élément de confort. Alors quel intérêt d’utiliser le shell ?
Je me permets de prendre une image. Pour vos déplacements, vous avez le choix
entre un train de luxe (figure 1.8) ou un avion à décollage vertical (figure 1.9).
Le train est bien plus confortable, vous donne localement une bonne vue sur les
lieux que vous traversez, vous permet d’atteindre la plupart des destinations quoti-
diennes, sans que vous ayez besoin d’apprendre à conduire quoi que ce soit.

12
 Dans un avion à décollage vertical, le confort est très spartiate, et on ne peut le
maîtriser qu’après de longues périodes de formation. Mais il vous permet de tout voir
à des kilomètres à la ronde, d’aller absolument où vous voulez, et ce, à de très grandes
vitesses.

Figure 1.8 – Un train de luxe Figure 1.9 – Le AV-8B Harrier à

Image provenant de décollage vertical
https://www.lemonde.fr/m-styles/article/ Image provenant de https://www.military.com/
2016/02/28/le-luxe-de-la-lenteur-cinq
video/aircraft/jet-fighters/av-8b-harrier-2-mid-air-
-voyages-de-reve-en-train_4873145_4497319.html
vertical-takeoff/1630296686001

De même, pour utiliser le navigateur de fichier, personne n’a besoin d’un manuel.
On peut facilement explorer son arborescence, copier, déplacer et supprimer des fi-
chiers et des répertoires. Mais pour des tâches plus complexes ou plus longues et
répétitives, le navigateur de fichiers laisse l’utilisateur démuni.

Le shell vous permet de faire absolument tout ce que fait le navigateur et bien au
delà. Un exemple : il vous permet de trouver, dans votre arborescence, tous les fichiers
dont le nom se termine par ."txt", qui datent de plus de 3 jours et dont le deuxième
mot de la troisième ligne est "pixels" et, dans tous ces fichiers, il vous permet de
remplacer ce mot par un autre mot.

L’utilisation du shell est relativement simple, mais il nécessite un minimum d’ap-

prentissage. C’est l’objectif de ce cours.

1.2.4 Les différents shells

Il existe différents shells. Chacun a sa syntaxe et ses spécificités, mais pour les
questions traitées dans les premiers chapitres, tous les shells sont équivalents. Voici
quelques exemples de shell :

sh Bourne shell
csh C shell
ksh Korn shell
bash Bourne again shell

Le shell utilisé dans ce cours est celui qui est lancé par défaut sur la plupart des
systèmes Linux : il s’agit du bash.

Le premier quizz, portera sur tout ce qui précède.

13
1.3 Lancements
1.3.1 Lancement d’un navigateur de fichiers

Vous le savez sans doute déjà, mais pour lancer un na-

vigateur de fichiers, vous pouvez examiner la bande de
boutons qui se trouve sur le bord gauche de l’écran et
presser le bouton qui ressemble à celui de la figure 1.10.
Figure 1.10 – Une fenêtre devrait s’ouvrir ressemblant à celle de la
nautilus, navigateur figure 1.5.
de fichiers

1.3.2 Lancement d’un terminal + shell

Il suffit de presser simultanément : Ctrl + Alt + t

Vous devriez obtenir une fenêtre ressemblant à celle de la figure 1.7. Ce qui est
affiché en haut à gauche de la fenêtre est l’invite (en anglais prompt) et qui signifie
que le shell est prêt à recevoir vos commandes.

1.3.3 Configuration pour les trois premiers TPs

Atelier :
Pour ce TP et les deux suivants, je vous invite à ouvrir deux fenêtres côte à côte (cf
figure 1.11).
— un navigateur de fichiers
— et un terminal avec un shell

L’intérêt du navigateur de fichiers est de vous montrer l’effet des commandes que
vous donnerez au shell.

Figure 1.11 – navigateur de fichier et terminal côte à côte

14
1.4 Les commandes shell
1.4.1 structure générale

Les commandes shell :

Une commande shell est composée :
1. du nom de la commande (un programme à exécuter) ;
2. de 0, 1 ou plusieurs options ;
3. de 0, 1 ou plusieurs arguments ;

1.4.2 l’instruction ls

Atelier : la commande ls
Dans le shell, entrer la commande suivante et valider avec la touche Entrée

ls

Comparer le résultat de cette commande et le comparer avec ce que vous voyez

dans le navigateur de fichiers. Quelle est l’utilité de la commande ls ? Dans la com-
mande ci-dessus, il n’y a aucune option et aucun argument. Cette commande peut
également être utilisée avec des options.

Atelier : la commande ls avec une option

Dans le shell, entrer la commande suivante et valider avec la touche Entrée

ls -F

Quelle est la légère et importante différence entre le résultat de cette commande

et celui de la commande précédente ? La commande ls peut aussi être utilisée avec
un argument :

Atelier : la commande ls avec un argument

Dans le shell, entrer la commande suivante et valider avec la touche Entrée

ls Documents

Cette commande affiche le contenu du répertoire Documents (vérifier sur le navi-

gateur de fichiers). Vous pouvez aussi utiliser l’option et l’argument :

Atelier : la commande ls avec une option et un argument

Dans le shell, entrer la commande suivante et valider avec la touche Entrée

ls -F Documents

Vous pouvez même utiliser plusieurs options :

15
Atelier : plusieurs options
Dans le shell, entrer la commande suivante et valider avec la touche Entrée

ls -F -1 -t -r

Cette commande affiche la même liste mais sur une seule colonne (-1) ordonnée dans
l’ordre inverse (-r) de l’ordre chronologiquement (-t). On peut enfin regrouper
plusieurs options devant un seul tiret. La commande précédente est équivalente à :

ls -F1tr

De façon générale (pour la commande ls, mais aussi pour toutes les commandes) :

Règles régissant les commandes :

— Contrairement à l’invite de commande windows, le shell est sensible à la casse.
ls est une commande, mais Ls n’en est pas une.
— Les différents éléments de la ligne de commande sont séparés par un ou plu-
sieurs caractères espace ;
— L’utilisation d’une option débute par le caractère un tiret ou un double tiret
(- ou --) ;
— L’utilisation des options peut être cumulée devant un seul tiret (comme ci-
dessus) ;

Il existe de nombreuses commandes et chaque commande admet un nombre plus

ou moins important d’options. C’est pourquoi il est nécessaire d’avoir une référence
qui décrit chaque commande, ses arguments, ses options, son usage et les erreurs
possibles. Toutes ces informations sont elles-mêmes fournies par la commande man cf
section 1.5

1.4.3 Lancer/arrêter une application

Pour lancer une application
Pour lancer une application, le nom suffit :
En réalité, le nom des commandes correspond à des programmes lancés par le shell.
ls est le nom d’un programme. De fait, pour lancer une application, il suffit sim-
plement d’entrer le nom de cette application dans le terminal :

Atelier : lancer un éditeur de texte

Lancer l’éditeur de texte gedit en écrivant dans le shell :

gedit

Dans la fenêtre qui apparaît, entrer n’importe quel texte. Puis presser le bouton
Enregistrer en haut de la fenêtre et sauver votre texte dans le dossier personnel
sous le nom de toto. Assurez-vous que vous le voyez apparaître dans le navigateur
de fichiers. Ne pas encore quitter l’éditeur de texte. Est-ce que vous le voyez aussi
apparaître avec la commande ls ?
Si vous ne voyez rien, ne vous inquiétez pas. Lisez la suite.

16
La tâche de premier plan

Foreground job :
Par défaut, lorsque vous lancez une commande dans un shell, cette tâche est au
premier plan 1 . Dans un shell, à chaque instant, il peut y avoir au plus une tâche
au premier plan. Vous ne pourrez lancer une autre tâche que lorsque la précédente
tâche de premier plan sera terminée et que l’invite de commande sera réapparue.

Lorsque vous lancez l’éditeur gedit, il est la tâche de premier plan. Vous ne pourrez
exécuter ls ou n’importe quelle commande que lorsque gedit aura cessé et que l’invite
de commande sera réapparue.

Arrêter un programme

Pour arrêter le programme gedit, il suffit de le quitter ou de fermer la fenêtre.

Mais il arrive quelquefois qu’un programme ne réagisse plus ou n’ait pas de fenêtre ou
encore qu’il ne quitte pas lorsqu’on ferme sa fenêtre. S’il s’agit de la tâche de premier
plan, le shell permet de l’arrêter. Pour cela, il suffit de presser simultanément les deux
touches :

Ctrl + C

Atelier :
À titre d’essai, essayer d’interrompre l’éditeur gedit de cette façon.

Les tâches de fond

Background job :
Le shell vous permet aussi de lancer des tâches qui ne sont pas des tâches de premier
plan, mais des tâches de fond 2 . Une telle tâche permet au shell de lancer d’autres
tâches sans pour autant avoir à quitter. Pour lancer une application en tâche de
fond, il faut le faire suivre du caractère &.

Atelier :
Lancer l’éditeur gedit en tâche de fond. (Commande : gedit &). Écrire un nouveau
ficher texte et le sauvegarder sous le nom titi. Sans quitter gedit, vérifier qu’il a
été crée avec la commande ls.

17
1.4.4 Opérations simples sur les fichiers
Atelier :

Dans cette section, vous devez deviner l’usage des commandes suivantes : cat,
cp, mv, rm, touch, mkdir et rmdir. Pour cela, vous pouvez mener les expé-
rimentations que vous voulez. Voici des propositions. Que se passe-t-il lorsque
vous entrez les commandes suivantes en regardant leur effet dans le navigateur de
fichiers. Notez que, pour l’instant les fichiers tata, tutu et tete n’existent pas
(encore).
— cat toto
— cp toto tata
— mv toto tutu
— touch tete
— rm tutu
— mkdir rep
— rmdir rep
Noter vos hypothèses sur un papier. Nous les vérifierons à la section 1.5.

1.4.5 Complétion automatique et historique

History
Le shell garde en mémoire toutes les commandes que vous avez écrites. Pour les
retrouver, utiliser les touches haut et bas. Cela vous permet de relancer une même
commande plusieurs fois sans avoir à la réécrire en toutes lettres.

Complétion automatique
Écrire la commande : cat to puis presser la touche TAB. Si le fichier toto est le
seul de votre répertoire commençant par to, alors le shell complète automatiquement
le nom de votre fichier : cat toto. Cela se révéle d’autant plus utile que le nom des
fichiers et répertoires est long.

1.5 La commande man

1.5.1 Un manuel très fourni
man :
La commande man (pour MANuel d’utilisation) décrit toutes les commandes shell
(et bien d’autres choses) de façon très détaillée.

Ne vous inquiétez pas, le résultat de la commande man n’est pas fait pour être lu
du début à la fin. Soit on se réfère à la page man d’une commande pour savoir à quoi
il sert de façon globale (et, dans ce cas, on lit seulement les premières lignes), soit on
connaît déjà la commande et on souhaite connaître son comportement dans certaines
situations particulières et, dans ce cas, on se réfère à la rubrique concernée.
Par exemple pour connaître les arguments et options de la commande ls, il suffit
d’entrer la commande :
man ls

18
 Voici les rubriques les plus courantes :

— NAME : le nom de la commande dont la fonction est brièvement décrite ;

— SYNOPSIS : la syntaxe de la commande. Les éléments entre crochets droits [
] peuvent être omises sans que la syntaxe de la commande en soit affectée.
Mais évidemment, le sens de la commande n’est plus la même. Par exemple, le
synopsis de la commande ls est :

ls [-ABCFGHLOPRSTUW@abcdefghiklmnopqrstuwx1] [file ...]

ce qui signifie que toutes les options sont facultatives et l’argument aussi. Par
contre, le synopsis de la commande mkdir est :

mkdir [-pv] [-m mode] directory_name

ce qui signifie que :

— les options -p et -v sont facultatives.

— Par contre, l’argument directory_name, lui, est obligatoire car elle n’est
pas entre crochets.
— L’option -m est facultative mais, si elle est présente, doit être suivie par
l’argument mode.

— DESCRIPTION : une explication courte des conséquences de la commande

— EXAMPLES : exemple d’utilisation de la commande ;
— DIAGNOSTICS : explications des messages d’erreurs que peut retourner la com-
mande ;

Par exemple :

— mkdir sans option, sans argument n’est pas syntaxiquement valable, car l’argu-
ment est obligatoire ;
— mkdir -q toto n’est pas valable car -q n’est pas un argument prévu par le
synopsis ;
— mkdir -m n’est pas valable car -m doit etre suivi du mode ;
— mkdir -m 700 titi est valable car -m est suivi d’un argument qui représente
le mode ;
— mkdir -p dossier est valable.

Attention ! Le synopsis vous permet de savoir si la syntaxe est correcte, mais elle
ne vous permet pas nécessairement de savoir si la commande réussira ou non. Par
exemple si le répertoire toto existe déjà ou que le répertoire est bloqué en écriture,
ou si l’argument suivant -m ne peut pas être interprété comme un mode, la commande
ne réussira pas.

19
1.5.2 Atelier syntaxe
Atelier :
Le synopsis de la commande locate est le suivant :
locate [-0Scims] [-l limit] [-d database] pattern
Parmi les commandes suivantes, quelles sont celles qui sont syntaxiquement va-
lides ?
— locate
— locate cpi.txt
— locate -l cpi.txt
— locate -c cpi.txt
— locate -cis cpi.txt
— locate -c -d -s cpi.txt

1.5.3 Atelier man

Atelier :
Utiliser la commande man pour connaître l’utilité des commandes que vous avez
testées plus haut (cat, cp, mv, rm, touch, mkdir et rmdir). Est-ce que la des-
cription de man est bien conforme à ce que vous aviez découvert de façon expéri-
mentale ?
Il n’est pas nécessaire de retenir par cœur l’utilité de toutes les commandes que
nous allons voir. Mais les commandes ci-dessus, je vous demande des connaître par
cœur (sans les options).

Pour vous préparer au quizz, retenez au moins les encadrés bleus et, surtout,
reprenez la liste des compétences de la section 1.1 et assurez-vous que vous savez faire
ces opérations. Le quizz portera aussi sur la section préalable du chapitre suivant.

20
Chapitre 2

L’arborescence des fichiers

Dans le chapitre précédent, nous étions restés toujours dans le même répertoire.
Dans le présent chapitre, nous allons apprendre à naviguer dans cette arborescence
et à accéder n’importe fichier dans cette arborescence.

2.1 Compétences visées

1. Connaître les emplacements importants dans l’arborescence : la racine, le

dossier personnel etc ;
2. Savoir se répérer dans l’arborescence ;
3. Aller dans un répertoire et en sortir ;
4. Se déplacer pas à pas dans l’arborescence des répertoires et fichiers de l’or-
dinateur, jusqu’à la racine et retour ;
5. Se déplacer avec une seule commande en utilisant des chemins relatifs ou
des chemins absolus ;
6. Utiliser les commandes vues à la section précédente, mais avec des chemins ;
7. En particulier, copier et déplacer des fichiers d’un répertoire à un autre ;
8. Utiliser des motifs au moyen des wildcards pour désigner plusieurs fichiers.

2.2 Préalable
2.2.1 Le système de fichiers est un arbre
Dans le système Unix, comme dans le système Windows, les données sont orga-
nisées sous la forme de fichiers regroupés en répertoires, chaque répertoire pouvant
contenir d’autres répertoires et d’autres fichiers. Ainsi, les répertoires forment une
structure d’arbre (à l’envers, mais arbre tout de même). Tous les fichiers et réper-
toires, sauf un, sont dans un autre répertoire. La seule exception est la racine de
l’arbre. Dans les systèmes windows, la racine de l’arbre (tout en haut) est le disque
(C:, D:, etc). Dans les systèmes de type Unix, la racine de l’arbre est un répertoire qui
s’appelle simplement / (lisez "slash"). Par exemple la figure 2.1 représente un extrait
de l’arborescence des fichiers sur une machine de l’UFR de Math-Info. Chaque nœud
de l’arbre est un répertoire et chaque feuille de l’arbre est un fichier.

21
 Figure 2.1 – Un extrait de l’arobrescence sur les machines de l’UFR

2.2.2 Quelques repères

Répertoires utilisateurs
Sur les machines de notre UFR, tous les répertoires des utilisateurs se trouvent
dans le répertoire adhome rangés dans l’ordre alphabétique. Chaque utilisateur dispose
d’un Dossier personnel. En anglais, ce répertoire est appelé le Home directory ou tout
simplement Home. Ce répertoire porte le nom de l’utilisateur. Le dossier personnel
ou home de l’utilisateur ahabibi est le répertoire ahabibi.

Attention ! Sur les machines de l’UFR, comme sur la plupart des

machines sous linux, il existe aussi un répertoire appelé home et
que vous pouvez voir sur la figure 2.1. Dans beaucoup de machines,
ailleurs qu’à l’UFR, les dossiers personnels des utilisateurs sont dans
ce répertoire home. Sur les machines de l’UFR, ce répertoire ne contient
rien d’intéressant pour les utilisateurs. Donc, dans ce cours, lorsqu’on
vous parlera de "votre home" ou simplement de "home", il ne s’agira
jamais du répertoire appelé home sur la figure 2.1, mais de votre dos-
sier personnel et qui porte votre nom.

Par défaut, chaque utilisateur peut lire et modifier tous les fichiers et répertoires
qui se trouvent dans son dossier personnel et ses sous-répertoires. Il peut se déplacer
dans les répertoires supérieurs et lire la plupart des fichiers, mais il ne peut pas les
modifier. Evidemment, par défaut, il ne peut ni lire ni écrire dans les répertoires des
autres utilisateurs.

Autres répertoires
— La plupart des commandes systèmes sont des programmes exécutables se trou-
vant dans le répertoire /bin ;

22
 — Beaucoup de programmes installés par défaut (comme les éditeurs de texte, les
compilateurs, les navigateurs web etc) se trouvent dans le répertoire /usr/bin ;
— Les programmes installés par l’utilisateur sont souvent dans /usr/local/bin ;
— Le répertoire /proc contient des fichiers, mis à jour par le système et donnant
des informations sur l’état de celui-ci ;
— Enfin répertoire /etc n’est pas le répertoire "et cetera", mais le répertoire Edi-
table Text Configuration, contenant, comme son nom l’indique, divers fichiers
de configuration editables.

2.2.3 Un navigateur de fichier se déplace sur cette arbores-

cence
Lorsqu’on ouvre un navigateur de fichiers sous Linux ou sous Windows (figures
1.4 et 1.5), il donne la possibilité de montrer cette arborescence, sous une autre forme,
dans le panneau de gauche. Le panneau de droite, montre seulement le contenu d’un
seul répertoire. Ce répertoire est appelé répertoire courant ou encore répertoire de
travail 1 . Par exemple, d’après la figure 2.1, l’utilisateur ahabibi, lorsqu’il ouvre un
navigateur de fichiers, voit la liste des répertoires :
— Bureau
— Documents
— Images
— Téléchargements
— etc
Son répertoire de travail est au nœud ahabibi de l’arborescence. S’il double-clique
sur le répertoire Documents, il voit les fichiers :
— CPI.txt
— AlgoProg.txt
À présent, le répertoire courant est le nœud Documents de l’arborescence. Ainsi, le
navigateur de fichier peut se déplacer sur cette arborescence.
Le shell, comme le navigateur de fichier, est, à chaque instant, caractérisé par un
répertoire courant. Le fait d’entrer la commande ls affiche la liste des fichiers et des
répertoires dans le répertoire courant. Jusqu’ici, nous avons toujours travaillé dans
votre dossier personnel (votre home directory). Mais nous allons, à présent, explorer
les autres répertoires.

2.3 Se déplacer dans l’arborescence avec le shell

Nous allons voir comment on peut faire la même chose avec un shell. Organisez
de nouveau votre espace de travail comme sur la figure 1.11 de façon à avoir un shell
et un navigateur de fichiers visibles en même temps.

2.3.1 Savoir se repérer : pwd

pwd :
La commande pwd 2 permet de situer le répertoire courant. Il affiche le chemin absolu
de ce répertoire, qui est constitué des répertoires qu’il faut traverser pour aller du
répertoire racine (/) vers le répertoire courant.
1. working directory en anglais

23
Par exemple, en regardant la figure 2.1, vous pouvez voir que, pour aller du répertoire
racine jusqu’à ahabibi, il faut passer par adhome, a, ah et enfin, ahabibi. De fait,
lorsque l’utilisateur ahabibi ouvre un shell, et lance la commande pwd, il obtient :
/adhome/a/ah/ahabibi
Atelier :
Ouvrir un shell et vérifier ce que vous obtenez en entrant la commande pwd.

2.3.2 Se déplacer pas à pas

Descendre
Quelque soit l’endroit de l’arborescence où vous vous trouvez, vous pouvez entrer
la commande ls -F de façon à distinguer les fichiers des répertoires. Vous obtiendrez
sans doute quelque chose ressemblant à :
Documents/ Images/ Videos/ Téléchargements/ toto titi
Ainsi, dans notre cas, Documents, Images, Videos et Téléchargements sont des
répertoires alors que toto et titi sont des fichiers. Pour entrer dans le répertoire
Documents, c’est à dire pour faire de façon à ce que Documents soit le répertoire de
travail, il suffit d’écrire :

cd Documents

Si, en entrant ls -F, vous voyez des répertoires, comme par exemple AlgoProg1/
et CPI/, alors vous pouvez aussi entrer dans ces répretoires en entrant cd AlgoProg1
ou encore cd CPI.

Remonter
Quelque soit l’endroit de l’arborescence où vous vous trouvez (sauf à la racine),
vous pouvez faire le chemin inverse, c’est à dire remonter dans le répertoire qui
contient le répertoire courant. Pour cela, il suffit d’écrire :

cd ..

Aller jusqu’à la racine et retour

Atelier1 :

— Exécuter pwd et noter le chemin de votre dossier personnel (votre home

directory) ;
— Monter : répéter plusieurs fois la commande cd .. puis pwd jusqu’à ce que
le répertoire courant soit la racine de l’arborescence (/) ;
— Redescendre : exécuter ls -F pour connaître les répertoire accessibles, re-
connaître le répertoire qui mène jusqu’à votre home, avec la commande cd,
redescendre d’un niveau vers votre répertoire home ; Répéter l’opération
jusqu’à arriver à votre répertoire home.
— Si vous vous perdez en chemin, le fait d’entrer la commande cd, sans argu-
ments, vous permettra de revenir directement dans votre répertoire home.

24
 Figure 2.2 – Le sous-arbre à créer dans Documents

Créer un sous-arbre dans Documents

Toutes les commandes que vous avez apprises au chapitre précédent, peuvent être
utilisées dans n’importe quel répertoire de travail. Il va de soi que les opérations de cet
atelier (comme les autres atelier) doivent être effectuées avec des commandes shell et
non dans le navigateur de fichiers. L’objectif de cet atelier est de créer l’arborescence
représentée sur la figure 2.2.
Atelier2 :

Créer, dans votre répertoire Documents l’arborescence représentée sur la figure

2.2. Pour cela :

— Placez-vous dans le répertoire Documents (Autrement dit, faites de façon à

ce que le répertoire de travail soit votre répertoire Documents).
— créer deux répertoires : AlgoProg1 et CPI (dans Documents) ;
— Entrer dans le répertoire CPI ;
— créer un répertoire TP ;
— entrer dans ce répertoire et créer, au moyen de gedit un fichier texte
TP1.txt ;
— copier ce fichier sous le nom TP2.txt
— remonter jusqu’à Documents et redescendre jusqu’à AlgoProg1 et, là aussi,
créer deux fichiers texte.

2.4 Chemins : relatif et absolu

Nous avons besoin de désigner chaque fichier et chaque répertoire de l’ordinateur
sans ambiguité. Or il ne suffit pas de donner le nom du fichier ou du répertoire. Par
exemple, ne serait-ce que sur la figure 2.1, il y a deux répertoires appelés bin :
— celui qui est juste sous le répertoire racine et qui contient les fichiers ls, cp,
mv et mkdir ;

25
 — celui qui est juste sous le répertoire usr et qui contient les fichiers gedit, php
et firefox.

Donc le nom ne suffit pas. Pour désigner chaque fichier/répertoire de l’ordinateur, on

utilise la notion de chemin 3

2.4.1 Chemin relatif

Supposons que nous soyons dans le répertoire local (cf figure 2.1 dans le répertoire
usr). Pour aller de ce répertoire vers le répertoire ab, il faut d’abord remonter vers la
racine / puis descendre vers ab. Dans les différents ateliers ci-dessus, nous avons vu
que ce déplacement peut être obtenu par la suite de commande suivante :

cd ..
cd ..
cd adhome
cd a
cd ab

Le shell nous permet de faire toutes ces commandes en une seule commande com-
pacte :

cd ../../adhome/a/ab

Lorsque le répertoire courant est local, alors le texte : ../../adhome/a/ab consti-

tue ce qu’on appelle le chemin relatif du répertoire aa. Ainsi, pour chaque fichier et
chaque répertoire de l’ordinateur, on peut trouver un chemin relatif unique.

Chemin relatif :
Le chemin relatif d’un fichier ou d’un répertoire f est la suite des déplacements à
effectuer pour aller du répertoire courant vers f . Chaque déplacement est séparé des
autres par un slash /. Un déplacement vers un sous-répertoire est noté par le nom
de ce sous-répertoire et un déplacement vers le répertoire parent (vers le haut) est
noté ..

Par exemple, si on se place dans l’arborescence de la figure 2.2,

— si le répertoire courant est AlgoProg1, alors le chemin relatif du fichier TP1.txt

est : ../CPI/TP1.txt ;

— si le répertoire courant est CPI, alors le chemin relatif du fichier TP1.py est :
../AlgoProg1/TP1.py ;

— si le répertoire courant est AlgoProg1, alors le chemin relatif du répertoire

Documents est simplement .. ;

— si le répertoire courant est AlgoProg1, alors le chemin relatif du répertoire

TP2.py est simplement TP2.py.

3. path en anglais

26
 Atelier :
Cet atelier vous demande de vous placer dans différents répertoires et de chercher
le chemin relatif d’un autre répertoire. Afin de tester si le chemin relatif est cor-
rect, il suffit de le placer devant la commande cd. La commande devrait déplacer
le répertoire courant vers le répertoire visé (vérifier avec pwd).
— Placez-vous dans votre dossier personnel (commande cd sans argument).
Quel est le chemin relatif du répertoire Documents ?
— Placez-vous dans votre dossier personnel. Quel est le chemin relatif du ré-
pertoire adhome ?
— Placez-vous dans votre dossier personnel. Quel est le chemin relatif du ré-
pertoire ahabibi ?
— Placez-vous dans le répertoire adhome. Quel est le chemin relatif de votre
dossier personnel ?

2.4.2 Chemin absolu

Le chemin relatif permet de désigner tous les fichiers de l’ordinateur par un nom
unique. Par contre, ce nom dépend du répertoire courant. Il est intéressant de pouvoir
désigner chaque fichier ou répertoire par un nom unique et indépendant du répertoire
courant. Pour cela, on utilise toujours la notion de chemin, mais on choisit, pour ce
chemin, un point de départ toujours identique : la racine. On parle alors du chemin
absolu.
Chemin absolu :
Le chemin absolu d’un fichier ou d’un répertoire f est la suite des déplacements à ef-
fectuer pour aller du répertoire racine vers f . Tous les chemins absolus commencent
par un slash / et chaque déplacement est également séparé des autres par un slash
/. Les déplacements sont notés de la même façon que dans le chemin relatif.

Par exemple, si on se place dans l’arborescence de la figure 2.2,

— le chemin absolu du fichier php est : /usr/bin/php ;

— le chemin absolu du fichier proc est : /proc ;
— le chemin absolu du fichier cecile.jpg est : /adhome/a/ah/ahabibi/Images/cecile.jpg ;

À votre avis, comment est-ce que la machine reconnaît un chemin absolu d’un
chemin relatif ? Autrement dit, comment sait-il s’il faut partir de la racine ou de votre
répertoire courant ?
Atelier :
Sur votre machine, donner les chemins absolus suivants. De même que dans l’ate-
lier précédent, je vous invite à vérifier que ces chemins sont corrects en utilisant
la commande cd suivi du chemin absolu. Si le chemin est correcte, alors après
cette commande, vous devriez vous trouver dans le répertoire visé.
— Donner le chemin absolu de la racine.
— Donner le chemin absolu de votre dossier personnel.
— Donner le chemin absolu du répertoire Documents de votre compte.
— Donner le chemin absolu du répertoire za (qui se trouve dans le répertoire
z du répertoire adhome).

27
2.4.3 Le répertoire courant, le répertoire parent, le dossier
personnel
À retenir :
— Le caractère ~ représente votre dossier personnel ;
— Le caractère . (un point) représente le répertoire courant ;
— Les caractères .. représentent le répertoire parent du répertoire courant.

Vous connaissiez déjà la dernière notation, puisque vous l’utilisez pour monter du
répertoire courant au répertoire parent. Vous savez aussi que .. peut faire partie d’un
chemin relatif ou absolu. À présent, vous avez appris aussi que :
cd ~
vous ramène directement à votre dossier personnel. Mais le caractère tilde (~) peut
aussi être utilisé au début d’un chemin. Par exemple ~/Documents/toto.txt re-
présente un chemin absolu vers le fichier toto.txt qui se trouve dans le répertoire
Documents de votre dossier personnel.
Enfin, vous avez aussi appris que le point "." représente le répertoire courant. Mais,
pour l’instant, cette notation ne vous est pas très utile car la commande :
cd .
ne fait que vous placer à l’endroit où vous êtes déjà. Nous verrons plus loin l’utilité
de cette notation.

2.5 Toutes les commandes (ou presque) utilisent des

chemins
2.5.1 Pour la commande cd
Dans la section 2.3.2, nous pouvions déjà parcourir toute l’arborescence, mais en
y allant pas à pas. L’argument que nous donnions à la commande cd était :
— soit le nom d’un répertoire qui se trouve dans le répertoire courant ;
— soit .. ;
Dans la section précédente (2.4) nous avons pu parcourir l’arborescence en allant
d’un point à un autre de l’arborescence avec une seule commande cd. L’argument que
nous avons donné à la commande cd était :
— soit un chemin relatif ;
— soit un chemin absolu.
Mais en réalité, la première façon de procéder n’est qu’un cas particulier de la
seconde. Dès le début, nous utilisions déjà, sans le savoir, des arguments qui étaient
des chemins relatifs. En effet, le chemin relatif d’un répertoire qui se trouve dans le
répertoire courant est simplement le nom de ce répertoire. De même, le chemin relatif
du répertoire parent est simplement ... Ainsi, on peut le dire de façon plus générale :

L’argument de cd est toujours un chemin absolu ou un chemin relatif.

cd <chemin>

28
2.5.2 Pour les autres commandes
Ceci est vrai pour la commande cd, mais aussi pour toutes les commandes que
nous avons vues jusqu’ici : ls, mkdir, rm, cp, mv etc.

La commande ls
Ce que nous avons expérimenté est que, si le répertoire rep se trouve dans le
répertoire courant, alors la commande

ls rep

liste à l’écran le contenu de ce répertoire. Mais en réalité, si le répertoire rep se trouve

dans le répertoire courant, alors le chemin relatif de rep est justement et simplement
rep. En fait, de façon générale :

Si la commande ls a un argument, alors il s’agit toujours du chemin absolu

ou relatif du répertoire dont on veut lister le contenu.
ls [<chemin>]

Les crochets droits signifient que l’argument est facultatif. Pour des raisons de
concision, je n’ai pas mentionné les options possibles.
Par exemple :
— Supposons que vous vous trouviez dans le répertoire Documents dans votre dos-
sier personnel. Pour connaître le contenu du répertoire Images, on peut désigner
ce répertoire :
+ par un chemin absolu : ls /adhome/a/ah/ahabibi/Images
+ par un chemin relatif : ls ../Images
En l’occurrence, l’utilisation d’un chemin relatif donne une commande plus
courte.
— Supposons que vous vous trouviez dans votre répertoire personnel. Pour connaître
le contenu du répertoire etc (cf figure 2.1), on peut désigner ce répertoire :
+ par un chemin absolu : ls /etc
+ par un chemin relatif : ls ../../../../etc
Dans ce cas, c’est le chemin absolu qui donne la commande la plus courte.

Atelier :
Sur votre machine, placez-vous dans votre dossier personnel et, avec la commande
ls, listez le contenu des répertoires suivants avec un chemin absolu, puis avec un
chemin relatif.
— le répertoire ah ;
— le répertoire z ;
— le répertoire /usr/bin ;
— le répertoire TP dans le répertoire CPI qui se trouve dans votre répertoire
Documents.

29
La commande mkdir

Il en va de même pour la commande mkdir . L’argument de cette commande est le

chemin absolu ou relatif du répertoire à créer. Attention ! parmi tous les répertoires
mentionnés dans le chemin, tous sauf le dernier devraient déjà exister.
mkdir [<chemin du répertoire à créer>]

L’administrateur d’une machine peut créer des répertoires n’importe où sur la

machine avec la commande mkdir. En tant qu’utilisateurs, vous et moi n’avons le
droit de créer des répertoires que dans nos dossiers personnels respectifs.

Atelier :
Sur votre machine, placez-vous dans votre dossier personnel et, avec la commande
mkdir, créer les répertoires suivants :
— un répertoire jeux dans votre dossier personnel ;
— un répertoire toto dans votre répertoire Documents (sans vous déplacer
dans ce répertoire) ;
— deux répertoires titi1 et titi2 dans le répertoire toto que vous venez de
créer (toujours sans vous déplacer).

La commande rm

Il en va de même pour les commandes rm et rmdir :

— L’argument de rm est le chemin absolu ou relatif du fichier à supprimer ;
— L’argument de rmdir est le chemin absolu ou relatif du répertoire (vide) à
supprimer ;
— Avec l’option -r la commande rm peut supprimer des répertoires non vides ;

La commande rm -r est à manipuler avec une extrême prudence ! ! ! Combien

d’entre nous ont perdu le résultat de journées de travail avec un rm -r sur un réper-
toire qui contenant plus de choses que ce qu’on croyait ?

Atelier :
Avant de commencer cet atelier, ouvrir un éditeur de textes (par exemple gedit)
et créer un fichier texte avec n’importe quel contenu dans le répertoire titi1 créé
ci-dessus. Dans cet atelier, je vous demande de vous placer dans votre dossier
personnel et d’utiliser les commandes rm et rmdir. Utilisez des chemins relatifs
et supprimer :
— le fichier texte que vous venez de créer dans le répertoire titi1 ;
— le répertoire vide titi1 ;
— le répertoire non vide toto ;

30
2.5.3 Copier et déplacer des fichiers et des répertoires
Ce qui a été au sujet des commandes cd, ls, rm, mkdir vaut aussi pour cp et mv.
Ces deux commandes admettent deux arguments qui sont des chemins relatifs ou
absolus.
Arguments de cp et mv
cp <arg1> <arg2>
mv <arg1> <arg2>
1. arg1 doit être le chemin absolu ou relatif d’un fichier qui existe ;
2. arg2 doit être le chemin absolu ou relatif d’un fichier (qui existe ou non)
ou celui d’un répertoire qui existe ;
Si arg2 représente un fichier, alors cp copie arg1 dans le répertoire de arg2
—
avec le nom qui se trouve à la fin de arg2 ;
Par exemple :

cp toto Documents/CPI/titi

copie le fichier toto du répertoire courant vers le dossier CPI sous le nom titi.
La commande mv fait la même chose mais, au lieu de réaliser une copie, elle
—
réalise un déplacement avec renommage ;
Si arg2 représente un répertoire, alors cp copie arg1 dans le répertoire de
—
arg2 en gardant le même nom.
Par exemple :

cp toto Documents/CPI

copie le fichier toto du répertoire courant vers le dossier CPI en gardant le même
nom toto. De même :

cp Documents/CPI/titi .

copie le fichier titi du répertoire CPI vers le répertoire courant (le point ".")
en gardant le même nom titi.
Dans le cas de la commande mv, le premier argument arg1 peut aussi être un réper-
toire.
Dans ce cas :
— si arg2 est un répertoire qui existe déjà, alors mv déplace arg1 dans arg2 ;
Par exemple :

mv Documents/CPI/TP Documents/AlgoProg1

Le répertoire Documents/Algoprog1 existe donc le répertoire TP est déplacé de

Documents/CPI vers Documents/AlgoProg1.
si arg2 est un répertoire qui n’existe pas, alors mv déplace arg1 dans le réper-
—
toire parent de arg2 en lui donnant le nom de arg2.
Par exemple :

31
 mv Documents/CPI/TP Documents/nouveau

Le répertoire Documents/nouveau n’existe pas, donc le répertoire TP est déplacé

de Documents sous le nom nouveau.

Atelier :
Placez-vous dans votre dossier personnel. Pendant tout cet atelier vous resterez
dans ce répertoire.
1. Créer un répertoire toto dans votre dossier personnel
2. Créer un fichier texte txt et le sauvegarder dans le répertoire Documents ;
3. Grâce à la commande cp, copier le fichier txt vers le répertoire toto sous
le nom copie ;
4. Grâce à la commande cp, copier le fichier txt vers le répertoire toto sous
le même nom ;
5. Grâce à la commande cp, copier le fichier bashrc du répertoire /etc vers
le répertoire toto sous le même nom ;
6. Grâce à la commande mv, déplacer le fichier txt vers le répertoire toto sous
le même nom ;
7. Grâce à la commande mv, déplacer le répertoire toto vers le répertoire
Bureau sous le nom titi ;

2.5.4 Développement et programmation

Lorsque vous écrivez un programme, vous pouvez, soit utiliser un IDE (Environ-
nement de Développement Intégré) comme Geany, soit utiliser un simple éditeur de
texte comme gedit. Pour certains langages, l’utilisation d’un IDE est plus pertinent
que dans d’autres. En particulier pour la programmation en C (cf le cours de BAI),
l’utilisation d’un IDE comme Geany peut s’avérer déroutante. Dans ce paragraphe,
nous allons écrire des programmes très simples (en python et en C ) et exécuter les
programmes correspondants.

Lancer un programme python

Vous avez sans doute déjà effectué des TPs en AlgoProg1. Ce n’est pas le sujet
du présent atelier, mais je vous invite fortement à créer un répertoire par matière sur
votre compte : un répertoire pour AlgoProg1, un autre pour CPI et BAI etc. Et, dans
ces répertoires, je vous encourage à faire un répertoire différent pour chaque TP.

Atelier :
Ouvrir un terminal. Placez-vous dans un répertoire contenant un programme
python que vous avez écrit en TP d’AlgoProg1. Lancer ce programme avec la
commande python3. Par exemple, si votre fichier s’appelle toto.py, la commande
pour l’exécuter est python3 toto.py. Mais pour cela, évidemment, il faut se
placer dans le même répertoire que toto.py.

32
 Les deux programmes suivants, l’un en py-
thon et l’autre en langage C, suivants font
le même travail : ils génèrent une image
avec un algorithme aléatoire. L’image pro-
duite s’appelle un bruit de Perlin (Per-
lin noise). Cet algorithme est utilisé très
souvent en informatique graphique, notam-
ment pour la création de textures (cf figure Figure 2.3 – Un exemple de bruit de
2.5.4). Perlin produit par les programmes de
cette section.

Atelier noise en python :

1. Depuis la plateforme Moodle, télécharger le fichier noise.py.

2. Ouvrir un terminal.
3. Placez-vous dans le répertoire contenant le fichier téléchargé.
4. Avec la commande cp, copier, depuis le répertoire
/adhome/a/ah/ahabibi/Public, le fichier Vector.py, nécessaire au
fonctionnement du programme noise.py.
5. Exécuter noise.py avec python3.
6. Cela produit un fichier appelé noise.pgm que vous pouvez visualiser.
7. Combien de temps dure l’exécution de cette commande ? (Utiliser la com-
mande : time python3 noise.py)

Compiler et lancer un programme en C

Atelier noise en C :

1. Depuis la plateforme Moodle, télécharger le fichier noise.c.

2. Ouvrir un terminal.
3. Placez-vous dans le répertoire contenant le fichier téléchargé.
4. Avec la commande cp, copier, depuis le répertoire
/adhome/a/ah/ahabibi/Public, les fichiers Vector.c et Vector.h,
nécessaires au fonctionnement du programme.
5. Compiler ce programme avec la commande :
gcc Vector.c noise.c -lm -o noise
6. Cette commande créer le fichier exécutable noise que vous pouvez exécuter
avec la commande ./noise et qui réalise le même travail que le programme
python ci-dessus. Vous pouvez visualiser l’image produite.
7. Cela produit un fichier appelé noise.pgm que vous pouvez visualiser.
8. Combien de temps dure l’exécution de cette commande ? (Utiliser la com-
mande : time ./noise)

33
2.6 Les motifs et les jokers (ou wildcards)

Atelier :
— Depuis la plateforme Moodle, télécharger l’archive
03_arborescences_ex.zip et la décompresser ;
— Entrer dans le répertoire 03_arborescence_ex ainsi crée et en examiner le
contenu (ls) ;
— Quel est l’effet des commandes suivantes :
— ls GR_*
— ls *R_*
— ls *.txt
— ls t?t?.txt En particulier, est-ce que le fichier toutou.txt est listé ?
— ls t*t*.txt Et maintenant ?

Un joker (ou wildcards)

— Un nom de fichier ou de répertoire ne peut pas contenir de caractère * ou ?.

Ces caractères ont une signifcation particulière dans le shell.
— Ils sont appelés des wildcards (qu’on pourrait traduire en français par joker).
— Il existe d’autres wildcards (les crochets et les accolades) qu’on ne verra pas
dans ce cours.
— Le wildcard ? représente un et un seul caractère ;
— Le wildcard * représente 0, 1 ou plusieurs caractères ;
— Un motif (ou pattern) peut être composé de 0, 1 ou plusieurs wildcards.
— Un nom de fichier ou de répertoire est conforme à un motif si et seulement
si on peut obtenir ce nom :
— en remplaçant chaque * du motif par 0, 1 ou plusieurs caractères ;
— en remplaçant chaque ? du motif par 1 caractère.

Par exemple :

— les nom image1.jpg, image2.jpg, iamgeA.jpg sont tous conformes au motif

image?.jpg ;
— les nom toto, titi, tate sont conformes au motif t?t? ;
— le nom toutou n’est pas conforme au motif t?t? ;
— le nom image24.jpg n’est pas conforme au motif image?.jpg ;
— le nom toutou est conforme au motif t*t* ;
— le nom tarentelle est conforme au motif t*t* ;
— le nom tetard est conforme au motif t?t*, mais pas au motif t*t?.

Les motifs en bash

En bash, un motif donné en argument à une commande désigne l’ensemble de
tous les fichiers et répertoires conformes à ce motif.

34
Atelier :

— Entrer dans le répertoire 03_arborescence_ex ;

— En une seule commande, supprimer tous les fichiers dont le nom commence
par GR_ ;
— En une seule commande, supprimer tous les fichiers dont le nom se termine
par .txt ;
— Créer un répertoire et déplacer dans ce répertoire tous les fichiers dont le
nom commence par ZR_.

35
36
Chapitre 3

Les droits d’accès aux fichiers

et aux répertoires
Dans un système de type Unix, l’accessibilité de chaque fichier, de chaque réper-
toire peut être réglée de façon individuelle et fine. Nous allons voir ce que signifie
l’accessibilité, comment la lire et comment la modifier.

3.1 Compétences visées

1. Chercher la nature d’un fichier, sa taille et sa date de dernière
modification ;
2. Chercher son nom d’utilisateur et ses groupes ;
3. Connaître ce que signifie l’accès à un fichier ou à un répertoire
en lecture, écriture et exécution ;
4. Déchiffrer les droits d’accès à un fichier ou un répertoire ;
5. Modifier les droits d’accès en apportant des modifications à
l’état courant ;
6. Définir de façon absolue les droits d’accès ;
7. Changer le propriétaire d’un fichier ou son groupe ;

3.2 Préalable : la version longue de la commande ls

Avant d’entrer dans le vif du sujet, voici une commande extrêmement utile. Ouvrir
un terminal et entrer la commande : ls -l
Sur mon compte, lorsque j’entre cette commande j’obtiens le résultat suivant :
total 48
drwx------ 2 ahabibi GG_MAI 4096 Jul 8 09:45 Bureau
drwx--x--x 3 ahabibi GG_MAI 4096 Nov 30 2018 Documents
-rwxr--r-- 1 ahabibi GG_MAI 10 Nov 30 2018 document.txt
drwx------ 9 ahabibi GG_MAI 12288 Jul 8 11:10 Images
drwx------ 2 ahabibi GG_MAI 4096 Sep 12 2016 Modeles
drwx------ 2 ahabibi GG_MAI 4096 Sep 12 2016 Musique
drwxr--r-- 2 ahabibi GG_MAI 4096 Sep 12 2016 public_html
drwx------ 2 ahabibi GG_MAI 4096 Nov 30 2018 Telechargements
drwx------ 2 ahabibi GG_MAI 4096 Sep 12 2016 Videos
drwx------ 3 ahabibi GG_MAI 4096 Jan 19 2017 workspace

37
 Chaque ligne est associée à un fichier ou à un répertoire. Le nom de ce fichier
ou répertoire se trouve en fin de ligne. Par exemple la première ligne est associée au
répertoire Bureau. Cet affichage fournit beaucoup d’informations que nous verrons
tout au long de ce chapitre. Dans un premier temps, retenez les données suivantes :
nature : Le premier caractère de chaque ligne est soit un caractère - (lorsque la
ligne correspond à un fichier ordinaire), soit un caractère d (lorsque la ligne
correspond à un répertoire. D’autres options sont possibles pour désigner les
liens symboliques, les sockets unix, les pipes etc. Mais je vous demande de savoir
ainsi distinguer les fichiers et les répertoires ;
taille : Le cinquième mot de chaque ligne (celui qui, dans cet exemple, suit GG_MAI)
représente la taille du fichier ou du répertoire. Sur les machines de l’UFR, cette
taille est exprimée en octets (ou bytes). Dans d’autres circonstances, cette taille
peut être exprimée en blocks mémoire.
date de dernière modification : Les dernières colonnes avant le nom représentent
la date et, pour les fichiers récents, l’heure de dernière modification du fichier
ou du répertoire.
Nous verrons plus loin la signification des autres colonnes.
Atelier :
Entrer cette commande et assurez-vous que vous savez extraire de cet affichage les
informations mentionnées ci-dessus.

3.3 Préalable : les utilisateurs, les groupes, les pro-

priétaires
3.3.1 Le nom et le numéro d’utilisateur
user name :
L’ordinateur identifie chaque utilisateur par un entier (user identifier ou uid) qu’on
peut obtenir avec la commande :
id -u
user name :
Mais comme, pour nous humains, il est difficile d’associer un entier à un utilisateur,
on associe à chaque uid un nom d’utilisateur qu’on peut obtenir avec la commande :
whoami
Ce nom est celui qui vous a permis de vous connecter sur la machine. La commande
suivante :
Atelier :
Quel est votre nom d’utilisateur ?

3.3.2 Le groupe
group :
Chaque utilisateur connecté sur un ordinateur appartient au moins à un groupe
qu’on appelle son groupe primaire. Les utilisateurs peuvent aussi appartenir à un
ou plusieurs groupes secondaires.
La commande suivante :
id -g -n martin

38
 affiche le groupe primaire auquel appartient l’utilisateur martin. La commande :
id -G -n martin

affiche tous les groupes secondaires auxquels appartient l’utilisateur martin. Quel
est l’intérêt des groupes secondaires ? Il arrive souvent qu’un utilisateur appartienne
seulement à son groupe primaire. Prenons un exemple,
— personnel (les employés permanents de l’entreprise)
— invite (les utilisateurs de passage : stagiaires, consultants, free lance)
— dev (les programmeurs)
— admin (les utilisateurs chargés de la bonne marche des ordinateurs)
Dans cet exemple, on peut imaginer que tous les utilisateurs ont un groupe pri-
maire qui est soit personnel soit invite. Parmi les utilisateurs permanents, certains
peuvent aussi avoir un groupe secondaire qui serait dev ou admin ou les deux. Comme
nous le verrons, on peut décider de donner ou de retirer à certains utilisateurs /
groupes d’utilisateurs, des droits d’accès à certains fichiers ou répertoires.
Atelier :
— Quel est le nom de votre groupe primaire ?
— Appartenez-vous à des groupes secondaires ? Si oui combien ?
— À combien de groupes secondaires appartient l’utilisateur ahabibi ?
— À combien de groupes secondaires appartient l’utilisateur root ?

3.3.2.1 Les propriétaires

propriétaire :
Chaque fichier appartient à :
— un utilisateur et un seul ;
ET
— un groupe d’utilisateurs et un seul.
Il en va de même pour les répertoires.
Reprenons l’exemple ci-dessus. Soit un fichier toto appartenant à martin qui ap-
partient au groupe dev. Le groupe propriétaire de ce même fichier peut être le groupe
dev (auquel appartient martin). Il peut aussi être appartenir au groupe personnel
ou au groupe admin (auquel martin n’appartient pas). Suivant les cas, martin ne
partagera pas la propriété de ce fichier avec les mêmes personnes.

Lorsque vous entrez la commande ls -l :

— la troisième colonne représente le nom du propriétaire du fichier ou du répertoire.
Dans l’exemple, le propriétaire de tous les fichiers et répertoire est ahabibi ;
— la quatrième colonne représente le nom du groupe propriétaire du fichier ou du
répertoire. Dans l’exemple, le groupe propriétaire de tous les fichiers et répertoire
est GG_MAI.

3.4 Les droits d’accès

Les systèmes de type Unix permet au propriétaire d’un fichier de décider les droits
de chaque type d’utilisateur sur chaque fichier ou répertoire. Dans cette section, tout

39
ce qu’on dira au sujet des fichiers sera aussi vrai pour les répertoires. Pour chaque
fichier (ou répertoire) :
les trois catégories d’utilisateurs sont :
user : L’utilisateur propriétaire du fichier/répertoire ;
group : Les utilisateurs membres du groupe propriétaire du fichier/répertoire ;
other : Tous les autres utilisateurs.

Pour chaque catégorie d’utilisateur, on peut spécifier :

r : le droit de lecture ou non ;
w : le droit d’écriture (modification du contenu) ou non ;
x : le droit d’exécution ou non.

Par exemple, le propriétaire se donne les droits de lecture et de modification sur

ses fichiers, il peut donner le droit de lecture aux membres du groupe et aucun droit
aux autres. Mais, s’il craint de modifier un fichier par mégarde, il peut se refuser
les droits de modification à lui-même. Et, inversement, s’il s’agit d’un fichier qu’il
souhaite partager avec d’autres utilisateurs, il peut leur donner le droit d’écriture aux
membres du groupe, voire à tous les autres.
Le mode d’un fichier
Pour un fichier, l’ensemble des droits de lecture/écriture/exécution pour le pro-
priétaire/groupe/autres utilisateurs constituent le droit d’accès à ce fichier. On
parle aussi du mode de ce fichier.

Atelier :
— Pour un fichier donné, combien y a-t-il de possibilités pour les droits de
lecture ? (Vous pouvez les compter : première possibilité : lisible par per-
sonne. Deuxième possibilité : lisible seulement par le propriétaire, troisième
possibilité : ...). Indication : il y en a plus de 4.
— Pour un fichier donné, combien y a-t-il de possibilités pour tous les droits ?

3.4.1 Lire les droits d’accès

Dans les informations fournies par la commande ls -l, la toute première colonne
indique les droits d’accès. Nous avons vu que le tout premier caractère indiquait
la nature (- pour fichier ordinaire et d pour répertoire). Mais, dans cette première
colonne, il y a 9 autres caractères que vous pouvez diviser en trois paquets de trois
caractères (cf figure 3.1).
Catégories :
Chaque paquet de trois caractères représente une catégorie d’utilisateurs :
— Les trois premiers caractères concernent les droits du propriétaire du fichier ;
— Les trois caractères suivants concernent les droits des membres du groupe
propriétaire du fichier ;
— Les trois derniers caractères concernent les droits de tous les autres utilisa-
teurs.

Chacun des trois caractères d’un paquet représente un droit spécifique :

40
 Types de droits :
Dans chaque paquet de trois caractères :
— Le premier caractère peut être - (lecture interdite) ou r (lecture autorisée) ;
— Le deuxième caractère peut être - (modification interdite) ou w (modifica-
tion autorisée) ;
— Le troisième caractère peut être - (exécution interdite) ou x (exécution
autorisée).

Par exemple la figure 3.1 montre deux exemples de droits d’accès. Dans le premier
cas, il n’y a que des tirets -. Cela signifie que le fichier concerné n’est ni lisible ni
modifiable ni exécutable par personne (ni le propriétaire, ni le groupe ni les autres).
Dans le deuxième cas, il n’y a plus aucun tiret. Cela signifie que le fichier concerné
est lisible, modifiable et exécutable par tout le monde. Bien entendu, en pratique tous
les cas intermédiaires sont possibles.

Figure 3.1 – Lire les droits d’accès

Autres exemples : un fichier dont les droits s’écrivent de la manière suivante :

— rw- r-- --- (configuration très usuelle) signifie que ce fichier peut être lu et
modifié (mais pas exécuté) par son propriétaire. Il peut être seulement lu par
les membres du groupe propriétaire et. Tous les autres utilisateurs n’ont aucun
droit.

— r-- -w- --x (configuration étrange, mais possible) signifie que ce fichier peut
être lu par son propriétaire mais pas modifié ni exécuté. Il ne peut pas être lu ni
exécuté par les membres du groupe, mais il peut être modifié. Enfin il ne peux
être ni lu ni modifié par les autres utilisateurs, mais il peut être exécuté. Si le
propriétaire appartient aussi au groupe, alors il peut, à la fois lire et modifier le
fichier.

41
 Atelier : Décrire en détail les droits des fichiers suivants pour le propriétaire,
pour le groupe et pour les autres utilisateurs :
rwx --- ---
rw- r-- r--
--- rw- r--

3.4.2 Modifier les droits d’accès

Il y a deux façons de modifier les droits d’un fichier ou d’un répertoire :
— On peut spécifier des modifications à apporter à son état courant (cf section
3.4.2.1) ;
— On peut spécifier tous les droits en une seule fois, indépendamment de l’état
courant (cf section 3.4.2.2).

La commande chmod
Dans les deux cas, pour modifier les droits d’accès à un fichier ou à un répertoire,
la commande à utiliser est chmod. En voici la syntaxe :

chmod <mode> <chemin>

Le second argument <chemin> est le chemin du fichier dont on souhaite changer
les droits. Le premier argument <mode> peut prendre plusieurs formes et indique
quel(s) droit(s) on souhaite modifier pour quel(s) utilisateur(s).

La commande chmod admet de nombreuses options dont nous verrons quelques

unes plus loin.

3.4.2.1 Changement de droits par rapport à l’état courant

Syntaxe de mode
Le premier argument de chmod peut être constitué d’un motif comportant :
— un ou plusieurs caractères choisis parmi u, g ou o et qui désignent les caté-
gories d’utilisateurs concernés par le changement ;
— un et un seul caractère valant soit +, soit - et indiquant si on veut ajouter
un droit ou en supprimer ;
— un ou plusieurs caractères choisis parmi r, w ou x indiquant si on veut
changer les droits en lecture et/ou en écriture et/ou en éxécution.
Ceci est résumé sur la figure 3.2
Par exemple :
— chmod o+r toto : donne aux utilisateurs autres que le propriétaire et le groupe
propriétaire de toto le droit de le lire ;
— chmod g-w toto : enlève au groupe propriétaire de toto le droit de modifier
son contenu ;
— chmod u+x toto : donne au propriétaire de toto le droit de l’exécuter ;
— chmod o-rw toto : enlève aux autres utilisateurs le droit de lire ou de modifier
toto ;
— chmod ugo+r toto : donne à tous les utilisateurs le droit de lire toto ;

42
 Figure 3.2 – Écrire un changement de mode avec chmod

— chmod a+r toto : est strictement équivalent à la commande précédente. a (all)

est synonyme de ugo.
Atelier : Quelle est l’argument mode qu’il faut donner à la commande chmod
pour :
— enlever au groupe propriétaire le droit de lire le fichier toto ?
— donner au propriétaire le droit de lire et modifier le contenu de toto ?
— enlever à tous les utilisateurs le droit d’exécuter toto ?
— enlever aux autres utilisateurs le droit de lire, écire et exécuter toto ?
À titre de vérification, créer un fichier quelconque et essayez vos commandes sur
lui et vérifiez qu’elles ont eu l’effet escompté.

3.4.2.2 Spécification des droits de façon absolue

Pour spécifier un mode (tous les droits), on peut utiliser des lettres, comme ci-
dessus, ou on peut utiliser un nombre en octal (base 8).
Notation avec des lettres : Dans le premier argument de chmod, outre + et
-, on peut utiliser =.

Par exemple :
— chmod u=rwx toto : indique que le propriétaire doit avoir le droit de lire, écrire
et exécuter toto ;
— chmod g=rw toto : indique que le groupe propriétaire doit avoir le droit de lire
et modifier le contenu de toto (et, implicitement, ne doit pas avoir le droit de l’exécuter)
— chmod o= toto : indique que les autres utilisateurs n’ont aucun droit d’accès
sur toto.
La notation octale :
L’idée globale est d’associer les droits de lecture, écriture r 4
et exécution à des entiers. On décide d’associer la lecture w 2
à 4, l’écriture à 2 et l’exécution à 1. x 1
Cette association est résumée dans le tableau ci-contre.

43
 Pour composer les droits, il suffit d’ajouter les entiers. Ainsi :
— le droit de lecture et écriture est associé à l’entier 4+2 = 6 ;
— le droit de lecture et exécution est associé à l’entier 4+1 = 5 ;
— le droit d’écriture et d’exécution est associé à l’entier 2+1 = 3 ;
— l’absence de droits est associé à 0.
Donc pour spécifier les droits d’accès pour chaque catégorie d’utilisateur, il suffit
d’un entier compris entre 0 et 7. Pour spécifier les droits d’accès pour le propriétaire,
le groupe et les autres, il suffit de trois entiers juxtaposés dans l’ordre habituel :
propritaire, groupe et autres. Par exemple :

— chmod 700 toto : indique 7 pour le propriétaire, 0 pour le groupe et 0 pour les
autres. Or 7 = 4 + 2 + 1. Donc le propriétaire doit avoir le droit de lire, écrire
et exécuter toto, mais tous les autres utilisateurs n’ont aucun droit ;
— chmod 644 toto : indique 6 pour le propriétaire, 4 pour le groupe et 4 pour les
autres. Or 6 = 4 + 2. Donc le propriétaire doit avoir le droit de lire et écrire
toto, alors que le groupe et les autres utilisateurs ne peuvent que le lire.

Atelier :
Pour chacune des spécifications suivantes pour le fichier toto, écrire la commande
version lettres et version octale. Pour la version lettres, vous pouvez écrire trois
commandes. À titre de vérification, créer un fichier quelconque et essayez vos
commandes sur lui et vérifiez qu’elles ont eu l’effet escompté.
— Donner à l’utilisateur le droit de lecture et écriture et, aux autres utilisateurs
(groupe et autres), le droit d’exécution ;
— Donner au groupe tous les droits, à l’utilisateur le droit de lire et aux autres
aucun droit ;
— Donner à tous les utilisateurs le droit de lire le fichier ;

3.5 Signification de l’accessibilité

Dans cette section, nous allons modifier les droits de différents fichiers et réper-
toires et voir l’effet de ces changements sur leurs propriétés. Le message d’erreur émis
lorsqu’on essaie d’accéder à un fichier ou un répertoire sans les droits suffisants est :
Permission denied.

3.5.1 Droits de lecture/écriture/exécution d’un fichier

Pour les droits en lecture et en écriture, je pense que vous pouvez imaginer ce qui
se passerait si vous essayez de lire ou d’écrire dans un fichier alors que vous n’en avez
pas le droit. Mais peut-être n’avez-vous jamais exécuté un fichier. C’est ce que nous
allons voir. Commencer par lancer un éditeur de texte et écrire un fichier (contenu
quelconque, mais reconnaissable) et créer un fichier que j’appellerai toto, mais que
vous pouvez appeler autrement. Quitter l’éditeur de texte.

44
Lecture
1. Assurez-vous que le fichier toto est bien accessible en lecture, écriture et exé-
cution (Quelle commande utilisez-vous pour le vérifier ?).
2. Assurez-vous que vous pouvez :
— voir le contenu de toto avec la commande cat ;
— créer une copie titi de toto avec la commande cp ;
— ouvrir toto dans un éditeur de textes.
3. Supprimer les droits de lecture pour le propriétaire de toto (c’est-à-dire vous-
mêmes) et recommencer les trois tests de la question précédente. Que se passe-
t-il ?
4. Rendre au propriétaire de toto les droits de lecture.

Écriture
1. Assurez-vous que vous avez les droits d’écriture sur toto et titi ;
2. Assurez-vous que vous pouvez ouvrir toto dans un éditeur de textes, y apporter
des modifications et sauvegarder les modifications ;
3. Supprimer les droits d’écriture pour le propriétaire de toto et titi ;
4. Est-ce que vous pouvez ouvrir toto dans un éditeur de texte, le modifier et
enregistrer les modifications ?
5. Est-ce que vous pouvez supprimer titi ?
6. Rendre au propriétaire de toto les droits d’écriture.

Exécution
1. Ouvrir le fichier toto et remplacer son contenu par les deux lignes suivantes et
sauvegarder ;

echo "Voici la date"

date

2. Dans le terminal, entrer la commande ./toto ; Que se passe-t-il ?

3. Donner au propriétaire les droits d’exécution pour toto ;
4. De nouveau, entrer la commande ./toto ; Que se passe-t-il ?
Félicitations ! Vous avez créé votre premier shell script ;

3.5.2 Droits de lecture/écriture/exécution d’un répertoire

Autant les propriétés des fichiers interdits en lecture/écriture/exécution étaient
prévisibles, autant pour les répertoires, vous serez peut-être surpris. Le paragraphe
conclusion vous donnera quelques explications. Mais je suis certain que, si vous réflé-
chissez aux résultats de vos expériences, vous pourrez trouver ces explications avant
de lire ce paragraphe.
Pour commencer, créer un répertoire rep et y déplacer le fichier toto ou n’importe
quel fichier accessible en lecture/écriture et exécution.

45
Lecture
1. Assurez-vous que le répertoire rep est accessible en lecture ;
2. Assurez-vous que vous pouvez lire le contenu de rep avec la commande ls ;
3. Tout en restant en dehors du répertoire rep, assurez-vous que vous pouvez
afficher le contenu de toto avec la commande cat rep/toto ;
4. Supprimer les droits de lecture pour le propriétaire de rep et refaire les deux
tests précédents ; est-ce que les deux tests donnent des résultats conformes à vos
attentes ? Je suis certain qu’un des deux tests vous aura surpris non ?
5. Rétablir les droits de lecture pour le propriétaire de rep.

Écriture
1. Assurez-vous que le répertoire rep est accessible en écriture ;
2. Assurez-vous que vous pouvez modifier le contenu de toto au moyen d’un édi-
teur de texte ;
3. Assurez-vous que vous pouvez copier toto dans un nouveau fichier titi et que
vous pouvez renommer et supprimer la copie ;
4. Supprimer les droits d’écriture pour le propriétaire de rep et refaire les deux
tests précédents ; est-ce que les deux tests donnent des résultats conformes à vos
attentes ? Là aussi, je suis certain qu’un des deux tests vous aura surpris non ?
5. Rétablir les droits d’écriture pour le propriétaire de rep.

Exécution
1. Assurez-vous que le répertoire rep et le fichier toto est accessible en exécution.
Dans le fichier toto, écrire simplement ls ;
2. Assurez-vous que vous pouvez éxécuter le fichier toto ;
3. Assurez-vous que vous pouvez entrer dans le répertoire rep ;
4. Supprimer les droits d’exécution pour le propriétaire de rep et refaire les deux
tests précédents ; est-ce que les deux tests donnent des résultats conformes à vos
attentes ?
5. Rétablir les droits d’exécution pour le propriétaire de rep.

Conclusions
De fait, le fait de changer les droits d’accès d’un répertoire n’est pas du tout
équivalent au fait de changer les droits d’accès de tous les éléments de ce répertoire.
Tout se passe comme si un répertoire était un fichier ordinaire dont le contenu était
la liste de tous ses éléments. Ainsi, le fait de créer/supprimer/renommer un fichier
dans ce répertoire reviendrait à ajouter/supprimer/modifier un élément de cette liste.
Ainsi :

46
 — Le fait de supprimer les droits en lecture d’un répertoire empêche seulement
d’en lister le contenu, mais n’empêche pas de lire les fichiers de ce répertoire
si on connaît déjà leur nom ;
— Le fait de supprimer les droits en écriture d’un répertoire empêche seule-
ment de créer/renommer/supprimer des éléments de ce répertoire, mais
n’empêche pas de modifier le contenu des fichiers de ce répertoire ;
— Le fait de supprimer les droits en exécution d’un répertoire empêche d’entrer
dans ce répertoire et aussi d’accéder, en lecture, en écriture ou en exécution,
aux éléments de ce répertoire (fichiers ou sous-répertoires).

Je vous invite donc à la plus grande prudence : le fait d’interdire un fichier

en écriture, interdit qu’on modifie son contenu, mais n’interdit pas qu’on le
supprime. Pour cela, il faut interdire l’écriture de son répertoire parent. Et
le fait d’interdire l’écriture d’un répertoire interdit de supprimer les éléments
de ce répertoire (fichiers ou sous-répertoire) mais n’interdit pas d’effacer le
contenu de tous ces fichiers. Le fait d’interdire le répertoire en exécution
verrouille tout le répertoire et ses éléments.

Par ailleurs, si vous souhaitez interdire l’accès (en lecture/écriture et/ou exécution)
à tous les éléments d’un répertoire rep et à tous ceux des sous-répertoires de rep, il
existe une commande simple :
chmod -R o-r rep

Cette commande supprime les droits de lecture aux autres utilisateurs pour tous les
éléments du répertoire rep et tous les sous-répertoires.
Atelier :
Supposons que nous ayons un fichier toto dans un répertoire rep. Quelle com-
mande faut-il entrer pour que :
1. personne ne puisse lire le contenu de toto ?
2. tout le monde puisse entrer dans rep ? ;
3. le groupe et les autres utilisateurs ne puissent pas changer le nom des fichiers
dans rep ?
4. le propriétaire puisse exécuter le fichier toto ?
5. le propriétaire puisse modifier le contenu de tous les fichiers dans rep, y
compris dans des sous-répertoires et des sous-sous-répertoires etc.

3.6 Changer le propriétaire d’un fichier et son groupe

Le droit de modifier les droits :
Il ne faut pas confondre le droit de modifier le contenu d’un fichier et le droit
de changer ses droits. Le propriétaire peut avoir ou non le droit de modifier le
contenu d’un de ses fichiers. Par contre, il peut toujours modifier les droits d’accès
à ses fichiers et il est le seul à pouvoir le faire.

Par exemple, un fichier dont le mode est : ---------, ne peut être lu, modifié ou
exécuté par personne. Mais le propriétaire pourra toujours modifier ces droits d’accès.

47
 Il n’existe aucun moyen de permettre à plusieurs utilisateurs (autres que les admi-
nistrateurs) de changer les droits d’un même fichier. Par contre, un utilisateur peut
donner un de ses fichiers ou répertoires à un autre utilisateur. Il s’agit d’un change-
ments de propriétaire. Le premier utilisateur ne pourra pas faire l’opération inverse. Le
changements d’utilisateur se fait avec la commande chown. La commande suivante :
chown ahabibi toto

ne peut être entrée que par le propriétaire du fichier ou répertoire toto. Elle a pour
effet de faire de ahabibi le nouveau propriétaire de toto.

Il existe aussi un moyen de changer le groupe propriétaire d’un fichier ou répertoire,

au moyen de la commande chgrp. La commande suivante ne peut être entrée que par le
propriétaire de toto et a pour effet de faire de GG_MAI le nouveau groupe propriétaire
de toto.
chgrp GG_MAI toto

48
Chapitre 4

Les processus
4.1 Compétences visées
1. Connaître la liste des processus sur une machine ;
2. Connaître la liste des processus lancés par un utilisateur donné ;
3. Connaître la quantité de ressources (mémoire ou la puissance de calcul)
consommées par un processus ;
4. Connaître les principaux états dans lesquels peut se trouver un processus ;
5. Interrompre un processus ;
6. Changer la priorité d’un processus.

4.2 Préalable : les processus

4.2.1 En substance
Notre objectif, dans cette section est de pouvoir surveiller et contrôler les activités
en cours sur votre ordinateur. Sous windows, lorsque votre ordinateur semble ralentir
de façon gênante, un réflexe est de lancer le gestionnaire de tâches et, lorsqu’une tâche
prend trop de mémoire et ou de temps de calcul, de la réfréner ou de l’interrompre.
Sous Unix, au lieu de parler de tâches, on parle de processus (process en anglais).

4.2.2 Processeur, Processus

Processeur :
Un processeur est une composante électronique capable d’exécuter des instruc-
tions de calcul très rapidement (cf figure 1.1). Pendant longtemps, chaque ordi-
nateur contenait un seul processeur.
Sur votre machine, vous avez certainement de nombreuses applications installées.
Vous avez peut-être un navigateur web, un éditeur de texte, Word, Excel, LibreOffice
etc. Tant que vous n’avez pas lancé ces applications, ce ne sont que des programmes
qui ne nécessitent aucun calcul et aucune mémoire, mais seulement de l’espace disque.

Programme :
Un programme, comme ceux que vous écrivez en python, sont des fichiers com-
posés d’instructions que le processeur peut exécuter.
Dès le moment où vous lancez une application, ses instructions sont chargées
en mémoire et ces instructions commencent à être exécutées par le processeur. Un

49
processus vient d’être créé.

Processus :
Un programme lancé (par l’utilisateur ou par d’autres programmes) et chargé en
mémoire est appelé un processus.
Un même programme peut être à l’origine d’un ou plusieurs processus. En effet,
rien ne vous empêche de lancer plusieurs éditeurs gedit par exemple. Le programme
est unique, mais chaque fenêtre d’éditeur correspond à un processus séparé. Chacun
occupe un espace séparé en mémoire et envoie ses instructions au processeur.

4.2.3 Process Identifier ou le pid

Processus identifier :
Chaque processus lancé sur une machine a un identifiant unique sous la forme
d’un entier, et qui est appelé le process identifier ou, plus communément le pid ;

En particulier, même si deux processus correspondent à l’exécution d’un même

programme, ils ont tout de même des pid différents.

4.2.4 User Identifier ou le uid

User identifier :
Chaque processus a un propriétaire qui est, presque toujours, l’utilisateur qui a
lancé ce processus. Les droits qu’a un processus de lire/écrire/exécuter un fichier
ou un répertoire sont ceux de son propriétaire

Le propriétaire est désigné par un identificateur (uid) comme nous l’avons vu à la

section 3.3.1.

4.2.5 La généalogie des processus

Chaque processus est lancé par un autre processus. Lorsque vous entrez une com-
mande dans un shell (par exemple ls), vous pouvez penser que c’est vous qui avez
lancé le processus correspondant. Mais, pour le système, c’est le shell qui lancé ce
processus. Le shell qui, lui-même, est un processus.
Processus parent :
Quand un processus A a lancé un processus B, on dit que A est le processus
parent de B.

Dans notre exemple, le processus parent du processus ls est le processus shell. Mais
le processus shell, lui-même a un autre processus parent et ainsi de suite. Tous les
processus sur la machine ont un ancêtre commun, qui est le processus de pid 1, et qui
a été lancé par le système au démarrage de la machine. On pourrait représenter tous
les processus d’une machine sous la forme d’un arbre, un peu à l’image d’un arbre
généalogique.

4.2.6 Le statut ou état d’un processus

Au départ, les instructions du processus sont envoyées au processeur qui les exé-
cute. On dit que le programme est en cours d’exécution. Mais il peut arriver qu’un
processus soit en attente d’un événement (qu’un utilisateur entre une donnée, qu’il

50
bouge la souris ou qu’arrive un message sur le réseau etc.). Pendant ce temps, il n’a
pas besoin d’envoyer des instructions au processeur. On dit que ce processus est en-
dormi. Dès que l’événement attendu a lieu, le processus peut repasser dans l’état en
cours d’exécution.

Statut d’un processus :

Un processus est caractérisé par un statut (ou état) : en cours d’exécution (run-
ning), endormi (sleeping), arrêté, en sommeil ininterruptible ou zombie. Dans ce
cours, nous nous intéresserons aux deux premiers statuts.

4.2.7 Mono-tâche, multi-tâche, priorités, ordonnancement

Dans les premiers ordinateurs, lorsqu’un processus était lancé, celui-ci monopoli-
sait le processeur. Aucun autre processus ne pouvait démarrer tant que le processus
précédent n’était pas terminé. Ces systèmes étaient dits mono-tâches. Aujourd’hui,
l’écrasante majorité des systèmes est multi-tâche, même avec un seul processeur. Au-
trement dit, plusieurs processus peuvent tourner sur le même processeur.
En tout cas, c’est l’impression qu’on peut avoir. De fait, en réalité, un processeur
peut exécuter les instructions d’un seul processus à la fois. Mais il passe rapidement
d’un processus à l’autre. Il exécute quelques instructions d’un processus, puis quelques
unes d’un autre et ainsi de suite. Ainsi, l’utilisateur peut avoir l’impression que les
processus s’exécutent en parallèle.
Le vrai parallélisme n’est possible que lorsque la machine est dotée de plusieurs
processeurs. Mais le nombre de processus tournant sur une machine est de l’ordre
de la centaine voire du millier, alors que le nombre de processeurs dans une machine
atteint rarement la dizaine. Donc, même sur une machine avec plusieurs processeurs,
ceux-ci doivent tout de même exécuter les processus à tour de rôle. L’expression "à
tour de rôle" est une image très simplifiée.

Ordonnancement :
Les processus en cours d’exécution se partagent le processeur. Celui-ci exécute
quelques instructions de l’un, puis quelques instructions de l’autre et ainsi de
suite. Un processus est caractérisé par un niveau de priorité. Plus un processus
est prioritaire et plus il peut utiliser le processeur. On dit que le système réalise un
ordonnancement : à chaque instant, en tenant compte des priorités et du temps
passé par chaque processus à attendre son tour, le système détermine le processus
qui peut avoir accès au processeur.

4.2.8 La "gentillesse" des processus

Il est possible de modifier la priorité d’un processus. Lorsque le processeur est très
sollicité, cela peut devenir une compétition : si un processus a une très haute priorité,
il peut avoir un accès privilégié au processeur, mais ce sera au détriment des autres
processus. Inversement, de façon imagée, on peut dire que les processus peuvent faire
preuve de gentillesse en baissant leur priorité pour avantager les autres processus. Les
systèmes d’exploitation Unix ont conservé cette notion de gentillesse et en ont fait un
paramètre réglable. En résumé, plus un processus est gentil et moins il est prioritaire
( !).

51
Nice :
Chaque processus est caractérisé par une valeur de gentillesse (nice) comprise
entre -20 et 19.
— Les processus dont le nice est de -20 sont les plus prioritaires ;
— Les processus dont le nice est de 19 sont les moins prioritaires ;
— Souvent, la valeur par défaut est de 0.
— Tous les utilisateurs peuvent augmenter la gentillesse (diminuer la priorité)
de leurs processus. Seul l’administrateur peut diminuer la gentillesse (aug-
menter la priorité) d’un processus.

4.3 Atelier : Lister les processus

Nous allons voir deux commandes ps et top qui offrent plusieurs façons de lister
les processus ouverts sur une machine. Les deux commandes permettent de connaître,
pour chaque processus, différentes propriétés dont :
PID son identificateur
PPID l’identificateur de son processus parent
UID l’identificateur de son propriétaire
S son statut (R pour running, S pour sleeping, Z pour Zombi)
N son nice
PR sa priorité effective
%CPU le pourcentage du temps de processeur consommé
%MEM le pourcentage de la mémoire consommée
SZ la taille mémoire allouée
TTY le terminal depuis lequel il a été lancé
TIME le temps processeur consommé
CMD la commande qui a lancé le processus

4.3.1 La commande top

C’est sans doute la commande top qui offre la façon la plus confortable et convi-
viale de connaître la liste des processus qui tournent sur une machine, qui plus est, en
temps-réel. Cette commande affiche un certain nombre d’informations générales sur
l’état de la machine, puis la liste des processus tournant sur la machine, à raison d’un
processus sur chaque ligne, en commençant par ceux qui nécessitent le plus de temps
de processeur. Les processus qui n’utilisent aucun temps processeur sont classés par
ordre de pid croissant.
Les commandes ayant permis de lancer ces processus sont sur la dernière colonne
et permettent de les identifier. Il existe de nombreux raccourcis clavier permettant de
mieux contrôler cet affichage. En particulier :

— la touche i permet d’afficher seulement les processus en cours d’exécution (qui

consomment du temps processeur), ce qui raccourcit sensiblement la liste ;

— la touche espace rafraîchit l’affichage à la demande ;

— la touche q permet de quitter top.

52
 Figure 4.1 – La liste affichée par la commande top.

Atelier :
— Veillez à quitter la plupart de vos applications en cours ;
— Dans un terminal, lancer la commande top ;
— Lancer/quitter différents processus (un autre terminal, un autre top, gedit,
navigateur web, etc) et voir les processus correspondant apparaître et dis-
paraître dans la liste.
— Dans top, presser plusieurs fois et de façon rapide la touche espace et voir
comment évolue la consommation CPU du processus top ;
— Quitter top.

4.3.2 La commande ps

La commande top est sans doute une commande conviviale et interactive, qui
montre l’état des processus en temps réel. Mais, comme nous le verrons, il est plus
difficile d’extraire de ses résultats des données spécifiques pour les fournir à d’autres
commandes/traitements. C’est pourquoi, on utilise aussi très souvent une commande
plus classique, appelée ps :

53
ps : (Process Status)
est une commande :
— qui affiche l’état des processus au moment précis où elle est lancée ;
— les résultats ne sont pas mis à jour (à moins de relancer la commande) ;
— mais les résultats sont exploitables par d’autres commandes (cf chapitre 6).
Cette commande possède beaucoup d’options permettant d’afficher différentes in-
formations et de les trier suivant différents critères. Nous n’en verrons que quelques
unes :
Les options de ps :

— ps : sans option, affiche la liste des processus lancés depuis le shell courant
(celui où la commande ps a été lancée) (figure 4.2) ;
— ps -u martin : affiche la liste des processus lancés par l’utilisateur martin ;
— ps -e : affiche la liste de tous les processus existant sur la machine ;
— Dans tous les cas, on peut ajouter l’option -l. Celle-ci affiche les mêmes
processus que si on ne met pas cette option, mais, pour chacune d’elles,
fournit plus d’informations (figure 4.3).

Figure 4.2 – La liste affichée par la commande ps sans options.

Figure 4.3 – La liste (extrait) affichée par la commande ps -l.

Atelier
Commencer par ouvrir deux terminaux. L’un d’eux servira à lancer la commande
ps avec différentes options et l’autre vous permettra de lancer différents pro-
grammes ;
1. Lancer un programme sur le premier terminal (par exemple gedit & et
gimp &) et un top sur le second terminal
2. Quelle est la liste des processus affichée par ps lancé dans le premier termi-
nal ? Contient-il gedit ? top ?
3. Même question pour la commande ps -u ahabibi (en remplaçant ahabibi
par votre nom d’utilisateur) ?
4. Même question pour la commande ps -e.
Certaines commandes (comme par exemple ls) ont les options assez similaires d’un

54
constructeur à un autre et d’un unix à l’autre. Et les résultats produits sont aussi
identiques. Il n’en est pas de même pour ps et pour more. Si vous ne travaillez pas sur
les machines de l’UFR, vous verrez peut-être des résultats sensiblement différents.
Atelier
En regardant la figure 4.3, pouvez-vous dire :
1. quels sont les processus en cours d’exécution (qui ne sont pas endormis) ?
2. pourquoi les autres processus (éditeur de texte, retouche d’image, naviga-
teur web) sont-ils endormis ?
3. quel est le processus parent de gedit ? de gimp ? de ps ? de script-fu ?

4.4 Les commandes nice et renice

Les commandes nice et renice permettent de spécifier et de modifier la priorité
des processus.
nice :
Pour lancer une commande avec un nice de p, la syntaxe est :
nice -n p commande
Par exemple pour lancer firefox avec un nice de 3, la commande est :

nice -n3 firefox

Atelier
Lancer la commande geany avec un nice de 5 et vérifier, en lançant ps, que le
nice du processus est bien de 5.

renice :
Lorsqu’un processus est déjà lancé, il est possible de modifier la valeur de son
nice avec la commande renice. Pour mettre la valeur de son nice à P, la syntaxe
est :
renice P pid
où pid est l’identificateur du processus.
La commande :

renice +1 1105

Change la valeur du nice du processus de pid 1105 pour la mettre à 1. Syntaxi-

quement, on peut utiliser une valeur de nice inférieure à la valeur courante, mais seul
l’administrateur a le droit d’exécuter effectivement une telle commande.
Atelier

1. Trouver le pid du processus Geany lancé précédemment et mettre son nice

à 10.
2. Vérifier, en lançant ps que la valeur du nice a bien été modifiée.
3. Pouvez-vous mettre son nice de nouveau à 5 ?
4. Pouvez-vous augmenter la valeur de son nice de 3 ?
5. Pouvez-vous diminuer la valeur de son nice de 3 ?

55
4.5 Les signaux

4.5.1 Fonctionnement général

Les signaux sont un des outils existant dans les systèmes Unix qui permettent à
des processus de communiquer entre eux.

Signaux :
Lorsqu’un processus A envoie un signal à un processus B, deux cas de figure sont
possibles :
— le processus B a prévu de recevoir ce signal en associant celui-ci à une
fonction de gestion de signal (handler). Dans ce cas, à la réception de ce
signal, le handler est appelée, ce qui permet au processus de réagir d’une
façon ou d’une autre. On dit que le processus a attrapé ce signal.
— si le processus B n’a pas prévu de recevoir ce signal, alors, dans la plupart
des cas, l’arrivée du signal met un terme au processus.

4.5.2 Utilité des signaux

Dans le cadre de ce cours, nous allons utiliser les signaux essentiellement pour
interrompre les processus. Dans les semestres suivants, vous apprendrez comment
attraper les signaux.

— Une des utilités des signaux est de permettre à deux processus de se synchroni-
ser. Un des processus A (a priori le plus lent ou celui dont le cycle dure le plus
longtemps) lance un signal à un processus B pour lui signifier qu’il a terminé son
cycle. Le processus B réagit à ce signal, par exemple en entamant un nouveau
cycle.

— Même dans le cas où le signal vise à mettre un terme au processus, le fait de

pouvoir l’attraper permet au processus de quitter proprement, par exemple en
sauvegardant l’état courant ou en s’assurant que le signal n’était pas accidentel
"Etes-vous sur de vouloir quitter ?"

Dans tous les cas, l’information véhiculée est minimale, mais elle est asynchrone.
Autrement dit, pour le recevoir, le processus B n’a pas besoin d’être à un stade
particulier de son avancement. En particulier, il n’est pas nécessaire qu’il soit en train
d’attendre le signal ou quoi que ce soit d’autre. Il peut le recevoir alors même qu’il
est en plein milieu de l’exécution d’une instruction.

4.5.3 La commande kill

La commande kill permet au shell d’envoyer différents signaux aux processus.

Dans le contexte de ce TP, la commande kill porte bien son nom, parce que nous
allons l’utiliser pour interrompre des processus qui n’ont pas été lancés par un shell
ou dont on a perdu le shell.

56
kill :
Le man page de kill vous donnera toutes les syntaxes possibles. Nous en verrons
une ici :
kill -numero pid
où pid est l’identificateur du processus que nous voulons arrêter et
où numero est un numéro qui identifie le signal.
Voici quatre numéros correspondant à quatre signaux :
2 SIGINT le signal qu’envoie Ctrl + C ;
24 SIGTSTP le signal qu’envoie Ctrl + Z et qui suspend le processus ;
18 SIGCONT un signal qui fait repartir un processus suspendu ;
19 SIGSTOP un signal qui suspend le processus et que celui-ci ne peut ni attraper ni ignorer ;
9 SIGKILL un signal qui tue le processus et que celui-ci ne peut ni attraper ni ignorer.
Par exemple :
— si, depuis un shell, vous lancez gedit et que ce processus a un pid de 60533,
alors la commande :

kill -2 60533

envoie un signal SIGINT à gedit, ce qui est strictement équivalent à un Ctrl +

C.
— si, vous lancez un processus de pid 36644, qui ouvre une fenêtre, alors la com-
mande :

kill 36644

envoie, par défaut, un signal SIGTERM à ce processus.

En principe, l’objectif est effectivement de permettre de quitter un programme
proprement. Mais si vous écrivez un gestionnaire de signaux, rien ne vous empêche
de faire de façon à ce que votre processus ignore simplement les Ctrl + C et d’autres
signaux ou qu’il réagisse à ces signaux autrement (qu’en quittant). Il y a pourtant
des limites. Tous les signaux ne peuvent pas être attrapés.
Terminaison immédiate :
Les signaux : SIGSTOP (19) et SIGKILL (9) ne peuvent être ni attrapés ni ignorés.
Par exemple :
kill -9 60339
ne laisse aucune chance au processus de pid 60339.
Atelier
— Lancer différentes application, depuis votre shell ou depuis la barre latérale
d’Ubuntu ;
— Trouver leur pid avec top ou ps ;
— Terminer ces processus en leur envoyant différents signaux.

57
58
Chapitre 5

D’autres commandes
Dans le chapitre 1, nous avons les premières commandes. En voici d’autres qui
nous seront très utiles dans le(s) prochain(s) chapitre(s).

5.1 Compétences visées

1. Afficher un message à l’écran ;

2. Créer/extraire une archive tar ;
3. Compresser/décompresser un fichier ;
4. Compter le nombre de lignes, de mots et de carctères d’un fichier ;
5. Extraire les n premières/dernières lignes d’un fichier ;
6. Extraire le n-ième mot d’une chaîne de caractère ;
7. Trier une liste ;
8. Remplacer un caractère/un mot par un autre dans un fichier ;
9. Effectuer des calculs simples ;
10. Extraire une chaîne de caractères d’un fichier ;
11. Alimenter ces fonctions par un texte entré au clavier.
Ce chapitre ne contient aucune partie préalable. Il ne contient que des ateliers.

5.2 Afficher un message à l’écran

La commande echo qui permet d’afficher un texte à l’écran :

Atelier echo :
Essayer les commandes :
— echo "bonjour"
— echo Doc*

Voilà une commande qui semble bien innocente, voire inutile. Nous verrons plus
loin son utilité.

59
 Figure 5.1 – L’archivage consiste à rassembler plusieurs fichiers ou toute une
arborescence dans un seul fichier appelé archive.

5.3 Créer/extraire une archive

Certaines applications ne manipulent que des fichiers un par un. Par exemple,
pour les transferts (upload et download) via un navigateur web ou via scp, on peut
transférer des fichiers, alors qu’il serait quelquefois intéressant de transférer plusieurs
fichiers à la fois, voire des répertoires entiers avec leurs fichiers et sous-répertoires.
Dans ces cas, il devient intéressant de pouvoir rassembler plusieurs fichiers ou
des arborescences de fichiers dans un seul grand fichier qu’on appelle une archive. Le
fichier archive peut alors être transféré puis désarchivé pour retrouver les fichiers ou
l’arborescence transmis.
Par ailleurs, il peut être intéressant de compresser un fichier ou un répertoire. Mais
les deux opérations (archivage et compression) sont tout à fait indépendantes.

5.3.1 Archivage

tar :
La commande tar permet de constituer des archives à partir d’un ou plusieurs
fichiers ou arborescences. Elle permet également d’extraire tout ou partie des
fichiers de l’archive. Dans cette commande :
— l’option -f permet de désigner le fichier archive ;
— l’option -v active le mode verbeux et liste à l’écran l’ensemble de tous les
fichiers archivés ou extraits (selon le cas) ;
— l’option -c spécifie qu’on souhaite créer l’archive ;
— l’option -x spécifie qu’on souhaite extraire des éléments de l’archive.
— Étudier la page man de la commande tar pour d’autres options.
Par exemple :

tar -c -f archive.tar mesdocs blah.txt

crée une archive archive.tar en y mettant le contenu du répertoire mesdocs et le

fichier blah.txt. On peut aussi écrire cette commande de la façon suivante :

tar -cf archive.tar mesdocs blah.txt

Dans la suite, nous utiliserons toujours cette notation compacte. La commande

60
tar -tf archive.tar

permet de lister les fichiers archivés dans archive.tar. Enfin, la commande :

tar -xvf archive.tar

extrait tout le contenu de l’archive archive.tar en listant (à cause de l’option -v)

tous les fichiers ainsi extraits. L’extraction fournit une copie des fichiers archivés. Cette
opération ne supprime pas les fichiers extraits de l’archive. Après cette commande, le
fichier archive reste inchangé.

5.3.2 Compression
Il y a de nombreux programmes de compression de fichiers. Sentez-vous libre
d’utiliser celui qui vous convient. Dans cette section, nous en présenterons deux :
gzip et compress.

Atelier compress :

— Télécharger un gros fichier (image ou video) depuis le net ;

— Placez-vous dans le répertoire où ce fichier a été sauvegardé (sans doute
Téléchargements) ;
— Entrer la commande du -h fichier (en remplaçant fichier par le nom
de votre fichier. Quelle est la taille de ce fichier ?
— Entrer la commande compress fichier (en remplaçant fichier par le
nom de votre fichier. Identifier le fichier compressé. Quelle est sa taille ?
— Entrer la commande man compress pour savoir ce qu’il faut faire pour
décompresser le fichier.

Atelier gzip :
Faire de même avec la commande gzip. Dans le cas de votre fichier image, laquelle
des deux commandes a réalisé la compression la plus efficace ?

5.3.3 Archivage et compression

Même si les opérations d’archivage et de compression sont fonctionnellement indé-
pendantes, il arrive souvent qu’on fasse suivre une archivage d’une compression. Dans
cette section, nous allons étudier deux commandes : tar et zip.

Le format tgz :
En ajoutant l’option -z la commande tar permet de compresser en archivant et
de décompresser en désarchivant. L’archive compressée est un fichier au format
tgz ou tar.gz. De fait, pour la compression/décompression, tar utilise gzip.
Par exemple :

tar -czf archive.tgz mesdocs blah.txt

est strictement équivalent à archiver mesdocs et blah.txt puis de compresser l’archive

avec gzip. Par ailleurs,

tar -xzf archive.tgz

61
permet de décompresser et de désarchiver archive.tgz.

Atelier tgz :
— Télécharger, depuis la plateforme Moodle, l’archive 06_commandes_txt.tgz
et la décompresser/désarchiver en une seule commande.

Le format zip :
Le nom de cette commande ressemble beaucoup à celui de gzip. Pourtant, pour
compresser ses archives, la commande zip utilise compress (et non gzip).

Atelier zip :
— Entrer man zip.
— Utilizer zip pour archiver/compresser le répertoire que vous avez décom-
pressé dans l’atelier précédent.
— Quelle commande faut-il utiliser pour faire l’opération dans le sens inverse ?
Dans le répertoire 06_commandes_txt décompressé dans l’atelier précédent, vous
trouverez des fichiers texte que nous utiliserons souvent pour tester les commandes
suivantes.

5.4 Commandes diverses

5.4.1 La commande wc
Placez-vous dans le répertoire 06_commandes_txt contenant le fichier pi.txt.
Regarder le contenu du fichier pi.txt.

Atelier wc :
Quel est le résultat affiché par les commandes suivantes ?
— wc -l pi.txt En
— wc -w pi.txt
— wc -c pi.txt
entrant man wc, déterminer à quoi correspondent les chiffres affichés par chacune des
trois commandes.

5.4.2 Les commandes head et tail

Placez-vous dans le répertoire 06_commandes_txt contenant pi.txt.

Atelier head et /texttttail :

Quel est le résultat affiché par les commandes suivantes ?
— head -n 1 pi.txt
— head -n 2 pi.txt
— head -n 3 pi.txt
— head -n 10 pi.txt
— Faire la même chose avec la commande tail.
Je pense que vous avez deviné à quoi peuvent servir les commandes head et tail.
Entrer man head et man tail pour en avoir la confirmation.

62
5.4.3 La commande cut
Placez-vous dans le répertoire 06_commandes_txt contenant les fichiers pi_ligne1.txt,
path.txt et csv.txt. Prenez connaissance du contenu de ces fichiers.

Atelier cut :
Quel est le résultat affiché par les commandes suivantes ?
— cut -d ’/’ -f 1 path.txt
— Réessayer avec d’autres valeurs que 1 ;
— cut -d ’,’ -f 1 csv.txt
— Réessayer avec d’autres valeurs que 1 ;
— cut -d ’ ’ -f 1 pi_ligne1.txt
— Réessayer avec d’autres valeurs que 1 ;
Là aussi, je pense que vous avez deviné à quoi peut servir la commande cut. Entrer
man cut à titre de vérification.

5.4.4 La commande sort

Placez-vous dans le répertoire 06_commandes_txt contenant les fichiers pi_ligne1.txt,
path.txt et csv.txt. Prenez connaissance du contenu du fichier noms.txt.

Atelier sort :
Quel est le résultat affiché par la commande suivante ?
— sort noms.txt
Entrer man sort pour connaître l’utilité de cette commande.

5.4.5 La commande grep

La commande grep est extrêmement puissante. Elle a de nombreux usages, avec
de nombreuses options. Mais voici un usage très courant :

La commande grep :
La commande suivante :
grep chaine fichier(s)

cherche chaine dans le contenu du ou des fichiers donnés en argument. Si elle

trouve cette chaine, dans un ou plusieurs fichiers, alors elle affiche, sur le terminal,
la ligne (ou les lignes) où cette chaîne a été trouvée, précédée(s) des noms du ou
des fichiers où elles ont été trouvées.
Par exemple :

grep "maitre" laParure.txt

n’affiche rien à l’écran, ce qui signifie que le fichier laParure.txt ne contient pas le
mot maitre. Par contre, la commande suivante :

grep "maitre" Repliques.txt

affiche :

Repliques.txt: Dark Vador - Bien maitre

63
ce qui signifie que le fichier Repliques.txt contient bien le mot maitre et que la
ligne où se trouve le mot maitre est celle qui a été affichée. On peut même donner
plusieurs fichiers en argument :

grep "donne" Repliques.txt laParure.txt

Voici un extrait du résultat :

Repliques.txt: Dark Vador - Abandonne-toi au cote obscur ...

laParure.txt: ... on n’en donne pas beaucoup aux employes ...

ce qui signifie que les deux fichiers contiennent la chaîne donne (même si, dans le
fichier Repliques.txt il s’agit d’une sous-partie du mot Abandonne). On peut même
donner en argument un motif qui désigne tout un ensemble de fichiers :

grep "fausse" *.txt

ce qui a pour résultat :

laParure.txt:- Oh! ma pauvre Mathilde! Mais la mienne était fausse.

ce qui signifie que, parmi tous les fichiers dont le nom se termine par .txt, le seul qui
contiennent la chaîne fausse est le fichier laParure.txt.
La commande grep contient de très nombreuses options permettant différentes
variantes :
— afficher ou non les numéros de lignes et/ou le nom des fichiers où se trouvent
les correspondances ;
— afficher seulement le nombre de correspondances ;
— ignorer ou prendre en compte la casse (minuscule/majuscule) ;
— afficher seulement les lignes où il n’y a PAS de correspondances ;
— rechercher récursivement dans un répertoire et tous les sous-répertoires qu’il
contient ;
— et ainsi de suite.
Pour l’heure, nous nous contenterons d’utiliser cette commande sans option.

Atelier grep :
Placez-vous dans le répertoire 06_commandes_txt. En utilisant la commande
grep :
— déterminer dans quel(s) fichier(s) il est question de "Skywalker" ;
— déterminer quel(s) fichier(s) contiennent le mot "comprends" ;
— réaliser chacune des deux recherches précédentes avec une seule commande ;
Nous verrons, à la section 5.6, comment on peut chercher non pas seulement des
mots, mais toute une classe de mots vérifiant certaines propriétés, ou plutôt, conformes
à certains motifs.

5.5 Lire les données depuis le terminal ?

Jusqu’ici, nous avons vu des commandes qui agissent sur des fichiers donnés en
argument. Voici quelques commandes qui font des traitements sur du texte entré par
l’utilisateur. Pour l’heure, cela peut vous paraître comme un gadget mais, nous verrons

64
au chapitre suivant, comment cela peut s’avérer d’une extrême puissance, autrement
dit, que cela permet de réaliser une très grande variété de traitements.
Contrairement aux commandes précédentes, celles que nous allons voir, ne se ter-
minent pas immédiatement après l’envoi de la commande. Elles attendent que vous
entriez du texte (0, une ou plusieurs lignes de texte). À chaque ligne, vous pouvez voir
le texte que vous avez entré suivi du résultat de la commande. À la ligne suivante,
la commande attend de nouveau votre contribution et ainsi de suite, jusqu’à ce que
vous ayez entré la séquence :
Ctrl + D

5.5.1 La commande bc

Atelier bc :
— Entrer la commande bc
— Entrer le texte suivant : 3 * 5 ←-
— Entrer le texte suivant : 45 / 9 * 20 ←-
— Ctrl + D
Lancer man bc pour avoir la confirmation de l’utilité de la commande bc. Vous
aurez compris à quels endroits, il faut utiliser la touche Entrer. Donc je ne remettrai
plus les signes ←-.

5.5.2 La commande tr

Atelier tr :
1. Entrer la commande tr c t
— Entrer : Le cafe a crame a la cave
— Entrer : Ceci est beaucoup trop chaud
— Ctrl + D
2. Entrer la commande tr -s a
— Entrer : wah, waaaah, waaaaaaaaaaaaaaaaah
— Ctrl + D
3. Entrer la commande tr -d m
— Entrer : Maman met la main a la poche
— Ctrl + D
4. Entrer la commande tr -d aeiou
— Entrer : Il y a des escrocs partout non ?
— Ctrl + D
5. La commande tr peut même prendre en argument des motifs. Entrer la
commande tr -d [:upper:]
— Entrer : BOOGIE, Boogie, boogie
— Ctrl + D
6. Entrer la commande tr [:lower:] [:upper:] et entrer n’importe quel
texte avec des lettres minuscules.
Lancer man tr pour avoir la confirmation de l’utilité de la commande tr.

65
5.5.3 La commande sed
La commande tr permet de remplacer certains caractères par d’autres caractères.
Mais pour remplacer des mots, nous avons besoin d’une autre commande, là aussi
d’une extraordinaire puissance, mais dont nous n’allons entrevoir qu’un aspect : la
commande sed.
Atelier sed :
— Entrer la commande sed -e ’s/Bonjour/Au revoir/g’
— Entrer le texte suivant : Bonjour tout le monde.
— Ctrl + D

5.5.4 Les autres commandes

Dans ce chapitre, nous avons vu les commandes wc, head, tail, etc qui, tous,
prennent en argument un fichier. Mais, si vous regardez plus spécifiquement la page
man de ces commandes, vous verrez que l’argument fichier est facultatif.

Autres commandes :
Entrer les commandes suivantes sans ajouter d’argument, puis entrer quelques
lignes de texte et finir par Ctrl + D.
1. Entrer la commande cat sans argument ;
2. Entrer la commande wc -l sans argument ;
3. Entrer la commande : head -n 2 (entrer un texte qui fasse plus que 2
lignes) ;
4. Entrer la commande : tail -n 2 (entrer un texte qui fasse plus que 2
lignes) ;
5. Même chose pour les commandes :
— sort
— grep "controle" (entrer un texte qui contienne controle sur une des
lignes) ;
6. Est-ce que le même mécansime fonctionne pour les commandes suivantes ?
— ls
— tar -czvf toto.tgz
— compress
— gzip
— zip

5.6 Pour aller plus loin : les expressions régulières

... en construction ...

66
Chapitre 6

Les redirections
6.1 Compétences visées
1. Mettre le résultat d’une commande dans un fichier ;
2. Lire l’entrée d’une commande depuis un fichier ;
3. Afficher le résultat d’une commande dans un autre terminal ;
4. Distinguer et séparer la sortie standard et la sortie standard erreur ;
5. Rediriger une des sorties vers la poubelle ;
6. Rediriger la sortie d’une commande vers l’entrée d’une autre commande
(filtrage) ;
7. Enchaîner plusieurs filtrages ;
8. Étant donné une tâche à réaliser, l’exprimer sous la forme d’un enchaîne-
ment de filtrages.
Ce chapitre va vous permettre de combiner des commandes pour faire des com-
mandes plus complexes. Il va augmenter significativement vos possibilités.

6.2 Préalable : les fichiers

6.2.1 les Entrées/sorties
Tout processus est susceptible d’intéragir avec son environnement numérique. Plus
précisément, un processus est susceptible de recevoir de l’information et d’en produire.
Comme nous allons le voir à la section ??, une grande partie de ces échanges se fait
avec des fichiers :
Interaction avec les fichiers
Les processus intéragissent avec des fichiers :
— ils lisent des données contenus dans différents fichiers ;
— ils écrivent des données dans des fichiers.
Le fait de limiter les interactions aux seuls fichiers peut sembler une vision un
peu étroite de ce que peut être l’intéraction d’un processsus avec son environnement
numérique. Voici des exemples d’interaction :
— un programme de conversion d’euros en dollars vous invite à lui donner un
montant en euros (entrée) et convertit ce montant en dollars et l’affiche à l’écran
(sortie). L’entrée se fait au clavier et la sortie se fait à l’écran.

67
 — la commande ls fournit des informations affichées sur le terminal (sortie à
l’écran).

— la commande bc, vu au chapitre précédent, calcule la valeur d’expressions arith-

métiques. Entrée au clavier et sortie à l’écran.

— un éditeur de sons prend des entrées d’informations depuis un microphone, des

contrôles via la souris et fournit des informations sur l’écran et sur le haut-
parleur.

6.2.2 Sous Unix, tout est fichier

Les fichiers
Une des particularités des systèmes de type Unix est qu’un grand nombre de
périphériques (terminaux, tubes, sockets, haut-parleurs, usb) peuvent être utilisés
comme s’il s’agissait de fichiers réguliers. D’ailleurs, ce que nous avons appelé
fichier jusqu’ici, (c’est à dire des données stockées sur le disque) devrait, en toute
rigueur, s’appeler fichier régulier. Lorsqu’on parle de fichier tout court, en toute
rigueur, on désigne un fichier généralisé, c’est à dire l’un des éléments suivants
(fichier régulier, répertoire, terminal, tube, socket etc).

— Comme nous le verrons, on peut lire et écrire dans un terminal comme dans un
fichier régulier ;

— Les tubes 1 peuvent être établis entre deux processus et leur permettre de com-
muniquer des données et se synchroniser. On peut lire et écrire dans ces tubes
comme dans des fichiers ;

— De même, les sockets peuvent être établis entre des processus distants (tour-
nant sur différentes machines sur le réseau). Toutes les applications utilisant le
réseaux ont recours aux sockets.

Ces fichiers, au sens général, même s’ils peuvent être accédés en lecture et en écri-
ture, presque comme des fichiers réguliers, n’apparaissent pourtant pas nécessairement
dans l’arborescence des fichiers.

1. pipe en anglais

68
6.2.3 Entrée standard, sortie standard, sortie standard erreur
Pour utiliser un fichier (fichier régulier,
tubes, terminaux, sockets etc), un pro-
cessus ouvre ce fichier :
— en lecture si on souhaite qu’il soit
une source d’information ;
— en écriture si on souhaite l’utili-
ser pour fournir de l’information.
Lorsqu’il a fini de l’utiliser, le proces-
sus peut fermer ce fichier. Le système
associe à chaque processus une liste de
fichiers :
— À chaque fois que le processus
ouvre un fichier, cette liste s’al-
longe d’un élément.
— À chaque fois que le processus
ferme un fichier, cette liste se Figure 6.1 – Liste des fichiers
raccourcit d’un élément. associée à un processus. Les trois
premiers sont ouverts
Par exemple, dans le cas de la figure automatiquement. Certains processus
6.1 sept fichiers sont ouverts corres- en ouvrent d’autres.
pondant à des fichiers réguliers, des
terminaux, untube et un socket.
Pour désigner chaque fichier ouvert, le processus utilise l’indice de ce fichier dans
la liste ci-dessus. Cet indice (un entier donc) est appelé le descripteur de ce fichier.

Entrée et sorties standards :

Au départ d’un processus, la liste des fichiers contient trois éléments. Le processus
n’a pas besoin d’explicitement ouvrir ces fichiers. Ils sont ouverts d’office.
— Le premier élément (descripteur 0) est appelé l’entrée standard. Il est ouvert
en lecture.
— Le deuxième élément (descripteur 1) est appelé la sortie standard. Il est
ouvert en écriture.
— Le troisième élément (descripteur 2) est appelé la sortie standard erreur. Il
est aussi ouvert en écriture
Si ces processus ont été lancés par un shell, ces trois fichiers correspondent au
terminal correspondant au shell.
Par exemple :
— Lorsque vous lancez le processus ls depuis un shell, il affiche la liste des fichiers
et sous-répertoires sur la sortie standard de ls, en l’occurrence, le terminal.
Beaucoup d’autres processus affichent leur résultat sur la sortie standard, c’est
à dire le terminal où ils ont été lancés.
— Lorsqu’on entre la commande cat toto, alors qu’aucun fichier toto n’existe
dans le répertoire courant, alors la commande cat affiche un message d’erreur
dans la sortie standard erreur qui est encore le terminal. Il en va de même pour
la plupart des messages d’erreur : ils sont affichés sur le terminal.
— En lisant la page man de la commande wc, on lit qu’en l’absence de fichier donné
en argument, cette commande lit l’entrée standard. C’est ce que nous avons

69
 testé dans les ateliers du chapitre précédent (section 5.5.4) que wc peut prendre
en entrée des données tapées au clavier.

6.3 Atelier : Rediriger les entrée/sorties standards

6.3.1 Rediriger la sortie standard vers un fichier

Redirection de la sortie standard :

Soit commande une commande qui affiche ses résultats sur la sortie standard. Dans
ce cas :

commande > fichier

a pour effet de faire de fichier la sortie standard de commande. Ainsi, la com-

mande commande > fichier n’affichera plus ses données sur le terminal. Tout
ce que la commande commande aurait affiché sur le terminal est envoyé dans
fichier. Si, avant l’exécution de la commande, fichier n’existe pas, alors cette
commande le crée. S’il existe, son contenu est écrasé.

commande >> fichier

a le même effet, à ceci près que, si fichier n’est pas initialement vide, le texte
affiché par commande n’écrase pas le contenu de fichier mais s’ajoute à la fin de
celui-ci.

Atelier redirection de la sortie standard :

Toutes les tâches suivantes sont à réaliser avec une seule ligne de commande sans
jamais ouvrir un éditeur de textes.
— Créer un fichier toto contenant la liste des fichiers du répertoire courant ;
(vous l’avez compris, il faut utiliser la commande ls associée à autre chose) ;
— Créer un fichier titi contenant la page man de la commande echo.
— Que fait la commande date ?
— Ajouter à la fin du fichier toto la date courante ;
— Ajouter à la fin du fichier titi le message : "Fin de l’histoire". (Penser
à echo.)

6.4 Atelier : Rediriger la sortie standard erreur vers

un fichier
L’usage des programmeurs consiste à séparer :
— le flux d’informations correspondant aux résultats valides d’un programme (qu’on
affiche sur la sortie standard) ;
— le flux d’informations correspondant à des messages d’erreur (qu’on affiche sur
la sortie standard erreur) ;
Certes, rien n’empêche un programmeur d’écrire des messages d’erreur sur la sortie
standard. Certes, par défaut, ces flux de données apparaissent mélangés sur le terminal
qui a lancé le programme. Mais la redirection permet précisément de les séparer

70
pour voir, selon les besoins, seulement les résultats valides ou seulement les messages
d’erreur.

Redirection de la sortie standard erreur :

Soit commande une commande qui affiche ses messages d’erreur sur la sortie stan-
dard erreur. Dans ce cas :

commande 2> fichier

a pour effet de faire de fichier la sortie standard erreur de commande. Ainsi,

la commande commande 2> fichier n’affichera plus ses messages d’erreur sur le
terminal. Tous les messages d’erreur sont envoyés dans fichier. Si, avant l’exé-
cution de la commande, fichier n’existe pas, alors cette commande le crée. S’il
existe, son contenu est écrasé.

commande 2 >> fichier

a le même effet, à ceci près que, si fichier n’est pas initialement vide, le texte
affiché par commande n’écrase pas le contenu de fichier mais s’ajoute à la fin de
celui-ci.

Atelier redirection de la sortie standard erreur :

Toutes les tâches suivantes sont à réaliser avec une seule ligne de commande sans
jamais ouvrir un éditeur de textes.
— Placez-vous dans votre répertoire courant et entrer la commande ls *. Quel
est l’effet de cette commande ?
— Supprimer les droits de lecture du répertoire des téléchargements pour tous
les utilisateurs ;
— Assurez-vous que la commande ls * produit aussi bien des résultats valides
que des messages d’erreur.
— Refaire la commande ls * en l’association à autre chose, de façon à ce que
les messages d’erreur soient envoyés dans le fichier erreurs.txt ;
— Refaire la commande ls * en l’association à autre chose, de façon à ce que
les résultats valides soient envoyés dans le fichier lsTout.txt.

N’oubliez pas de remettre les droits de lecture sur le dossier des téléchargements
et de supprimer les fichiers erreurs.txt et lsTout.txt. De fait, même lorsqu’il ne
s’agit pas d’un exercice, comme ici, il arrive souvent qu’on soit intéressé seulement
par l’un de ces deux flux : résultats valides ou messages d’erreur. Dans chaque cas,
pour ne pas voir un des deux flux, on le redirige vers un fichier qu’on supprimera par
la suite. Voici la solution :

Le fichier /dev/null :
Le fichier /dev/null est un fichier spécial caractères. Il a une propriété particu-
lière : toutes les données écrites ou redirigées dans ce fichier sont supprimées de
façon immédiate et définitive.

71
La commande find et le fichier /dev/null :
La commande find peut être utilisée de nombreuses manières. Elle permet, en
particulier, de chercher un fichier dans une arborescence d’après son nom, sa date,
sa taille, son propriétaire, son groupe, son type etc. En particulier, la commande :

find . -name "toto"

cherche, dans le répertoire courant (premier argument : ".") et tous ses sousréper-
toires, tous les fichiers du nom de toto.

Atelier :

— Chercher le répertoire Documents, non pas dans votre dossier personnel,

mais dans le répertoire parent (celui qui contient votre dossier pesonnel et
ceux d’autres utilisateurs).
— Comme vous avez pu le voir, vous obtenez de nombreux messages d’erreur
correspondant à tous les répertores qui ne vous appartiennent pas et qui sont
interdits en lecture. Réécrire cette commande, mais de façon à supprimer
tous les messages d’erreur. Comme vous l’avez compris, l’idée n’est pas
de les rediriger vers un fichier qu’on supprimera par la suite, mais de les
supprimer immédiatement et en une seule commande.

6.5 Rediriger la sortie standard vers un autre ter-

minal
Comme nous l’avons dit plus tôt dans ce chapitre, les terminaux sont un type
particulier de fichiers. Pour vous en persuader, ouvrez deux terminaux et, dans chacun
d’eux, entrez la commande : tty.

La commande tty :
Cette commande fournit le chemin absolu du fichier correspondant au terminal
sur lequel cette commande a été entrée.

Atelier :

— Dans le premier terminal, entrez une commande permettant de lister les

fichiers du répertoire courant, mais faites de façon à ce que cette liste ap-
paraisse dans le second terminal.
— Depuis le deuxième terminal, faites apparaître un message quelconque dans
le premier terminal.

6.6 Atelier : Rediriger l’entrée standard

Comme nous l’avons vu au chapitre précédent et, plus précisément, à la section 5.5,
certaines commandes peuvent recevoir leurs données directement depuis le terminal
(au clavier). Prenons comme exemple les commandes bc et tr. Mais rappelons que
beaucoup d’autres commandes (wc, head, grep, sed etc ...) peuvent foncionner de
cette façon.

72
Redirection de l’entrée standard :
Soit commande une commande qui puisse prendre ces données depuis l’entrée
standard. Dans ce cas :

commande < fichier

a pour effet de faire de fichier l’entrée standard de commande. Ainsi, la commande

commande < fichier n’attendra pas que l’utilisateur entre les données au clavier.
Elle les prendra directement dans fichier.
À titre de rappel :
— Entrer la commande bc puis, une expression arithmétique comme 31 + 5 2̂ (ou
toute autre expression). Finir par Ctrl + D.
— Entrer la commande tr ’e’ ’a’ puis, un texte quelconque contenant des e.
Finir par Ctrl + D.

Atelier entrée standard :

— Créer un fichier dont le contenu est l’expression arithmétique que vous avez
fournie au clavier à la commande bc.
— En utilisant la redirection de l’entrée standard, lancer la commande bc en
lui donnant, comme entrée, le contenu du fichier crée ci-dessus.
— Créer un fichier dont le contenu est la phrase que vous avez fournie au
clavier à la commande tr ’e’ ’a’.
— En utilisant la redirection de l’entrée standard, lancer la commande tr ’e’
’a’ en lui donnant, comme entrée, le contenu du fichier crée ci-dessus.
La commande tr n’admet pas d’argument fichier. La redirection est la seule façon
d’utiliser cette commande sur un fichier. Les autres commandes mentionnées ci-dessus
admettent, pour la plupart, un fichier comme argument. Ils peuvent donc recevoir leur
données soit via un argument fichier soit via une redirection de l’entrée standard. En
général, lorsqu’on utilise ces commandes seules, on donne les fichiers en argument.
Mais, comme nous allons le voir dans la section suivante, lorsqu’on utilise ces com-
mandes en combinaison avec d’autres commandes, il peut être intéressant de fournir
les données via l’entrée standard.

6.7 Atelier : Rediriger la sortie d’un fichier vers

l’entrée d’un autre fichier
6.7.1 Redirection via un fichier intermédiaire
Cette section nous n’introduisons aucun opérateur nouveau ou de syntaxe nou-
velle. Vous utiliserez les notions que vous avez déjà apprises aux sections précédentes.
Certaines tâches ne peuvent pas être effectuées avec une seule commande. Elles né-
cessitent plusieurs commandes. Elles nécessitent aussi que les données produites par
une des commandes soient utilisées par la commande (ou les commandes) suivante(s).
Dans cette section, pour permettre ce transfert des données, nous allons utiliser un
fichier régulier.
Par exemple supposons qu’on cherche à afficher la n-ième ligne d’un fichier texte.
Vous ne connaissez aucune commande qui réalise cette tâche directement. Par contre

73
vous savez extraire les n premières lignes d’un fichier. Si vous aviez un fichier contenant
ces n premières lignes, il vous suffirait de prendre la dernière ligne, qui n’est autre
que la n-ième ligne du fichier de départ.

Atelier n-ième ligne :

— Créer un fichier qui contienne plusieurs lignes. Par exemple, télécharger le

fichier notes.csv sur la plateforme Moodle et regarder son contenu (avec
la commande cat ;
— Écrire une commande qui extrait les 5 premières lignes de notes.csv et qui
les redirige vers un fichier tmp ;
— Écrire une commande qui extrait la dernière ligne du fichier tmp.
— Est-ce que le résultat obtenu est bien la cinquième ligne de notes.csv ?

La deuxième commande ci-dessus aurait pu être écrite de deux façons différentes :

— tail -n 1 tmp

— tail -n 1 < tmp

Tant que nous utilisons des fichiers comme interméidiaires entre les commandes,
les deux options sont équivalentes. Mais, dans les sections suivantes, nous aurons
d’autres outils à notre disposition. Et nous ne pourrons utiliser ces outils qu’en ayant
recours à l’entrée standard (c’est à dire la deuxième option ci-dessus). La démarche
globale est déctrite à la figure 6.2.

Figure 6.2 – Le fichier est en même temps la sortie standard de cmd1 et l’entrée
standard de cmd2 et leur permet ainsi d’échanger des données

74
6.7.2 Redirection via un tube (ou pipe)

L’utilisation des tubes :

Certaines tâches nécessitent plusieurs commandes et un transfert de données
d’une commande vers l’autre. Comme nous l’avons vu, ce transfert peut être
réalisé via un fichier intermédiaire :

commande1 > fichier

commande2 < fichier
rm fichier

Cette suite de commandes peut être avantageusement remplacée par la com-

mande :

commande1 | commande2

L’opérateur | est appelé pipe.

Figure 6.3 – La sortie de la commande cmd1 est directement redirigée vers l’entrée
de la commande cmd2 via un tube (pipe).

Dans cette section, pour alléger la mise en page, nous n’avons pas mis tous les
ateliers dans des encadrés roses mais, de fait, la suite de cette section est consacrée à
des ateliers vous permettant d’explorer les possibilités de ce nouvel opérateur. Dans
un premier temps, la première commande sera toujours la commande ls -l (ou sim-
plement ls) :
Atelier redirection pipe :
Les tâches suivantes sont à réaliser en une seule commande bash.
La première commande est ls ou ls -l.

1. Compter le nombre de fichiers et de répertoires dans le répertoire courant ;

2. Lister tous les fichiers ou répertoires datant du mois de septembre ;
3. Lister tous les fichiers en remplaçant tous les minuscules par des majuscules ;
4. Lister tous les fichiers en remplaçant tous les .py par des .txt ;
5. La commande ls -t liste tous les fichiers en les ordonnant du plus récent au
plus ancien. Afficher les 10 fichiers les plus récents du répertoire courant.
6. Afficher les 5 fichiers les plus anciens du répertoire courant.
7. Afficher tous les fichiers et répertoires du répertoire courant en classant d’abord
les fichiers puis les répertoires (ou le contraire). (Utiliser la commande ls -l).
8. Afficher tous les modes des fichiers et répertoires du répertoire courant. Les
modes représentent la première colonne dans la sortie de la commande ls -l ;

75
 9. Est-ce que, vous pourriez, de la même façon, extraire la cinquième colonne, celle
des tailles de fichiers ?
10. Lister tous les fichiers au format long (utiliser ls -l) ; mais en remplaçant toutes
les répétitions d’espaces par un espace unique (cf commande tr -s) ;

Atelier redirection pipe :

Les tâches suivantes sont toujours à réaliser en une seule commande bash.
À présent, la première commande peut être n’importe quelle autre commande
que vous connaissez.

1. Essayer la commande date sans arguments. Écrire une commande qui extrait
l’heure courante au format hh:mm:ss (par exemple 20:31:48)
2. Calculer la valeur de l’expression : 31 + 5 ^ 2 ou toute autre expression, sans
l’avoir écrit dans un fichier
3. Afficher les 10 premières lignes de la page de man de la commande ls
4. Écrire une commande qui affiche le nombre de lignes d’un fichier toto. On
souhaite qu’elle affiche seulement un entier représentant le nombre de lignes.
On ne souhaite pas que soit aussi affiché le nom du fichier. Indication : il faut
envoyer le contenu du fichier vers l’entrée standard de wc -l.
5. Écrire une commande qui compte le nombre de fois où le mot import apparaît
dans le contenu des fichiers du répertoire courant.

4. Vous pouvez télécharger le fi-

chier notes.csv depuis la pla-
teforme Moodle. Mais il est
très facile d’en faire un vous-
même. Il suffit d’ouvrir n’im-
porte quel tableur de votre choix
(par exemple Libreoffice ou Ex-
cel), d’écrire les données à la
main et de sauvegarder sous le
format csv qui signifie "Comma
Separated Values (valeurs sépa-
rées par des virgules). De fait, il
peut s’agir de virgules, de points- Figure 6.4 – Le fichier notes.csv
virgules ou d’autres caractères. ouvert par libreoffice
Utiliser la commande cat pour voir par quel caractères sont séparés les données du
fichier notes.csv. Écrire une commande qui retourne la note de thomas (vous devriez
donc obtenir 15).

6.7.3 Plusieurs niveaux de traitements : le filtrage

Vous avez appris à faire des commandes composées de deux sous-commandes, la
sortie de l’une étant redirigée vers l’entrée de l’autre. Mais cette commande composée
produit elle-même une sortie qui peut être redirigée vers autre chose avec les mêmes
outils que ci-dessus. Rien ne s’oppose à écrire des commandes comme celles de la figure
6.5. Ainsi, chacun des étages est appelé un filtre et, cette organisation de traitements
à la chaîne dans une seule commande s’appelle le filtrage.

76
 Figure 6.5 – Une commande composée de plusieurs étages, la sortie de chaque
étage étant redirigée vers l’entrée de la suivante.

Atelier filtrage 1 :
Les tâches suivantes sont toujours à réaliser en une seule commande bash.
Elles nécessitent deux pipes.

1. On souhaite connaître la profondeur du répertoire courant dans l’arborescence.

On suppose que la racine se trouve à l’étage 0, les répertoires situés immédia-
tement sous la racine sont à l’étage 1 et ainsi de suite. Par exemple le réper-
toire dont le chemin absolu est /adhome/a/ah/ahabibi/Documents se trouve
à l’étage 5. Cette profondeur est donné par le nombre de mots dans le chemin
absolu. Écrire une commande qui, dans un premier temps, remplace les slashs
par des espaces et qui, dans la chaîne qui en résulte, compte le nombre de mots.
2. Écrire une commande qui affiche la troisième ligne d’un ficher texte toto. Le
principe est d’afficher le contenu de tout le fichier puis, de ne garder que les 3
premières lignes puis, de ces trois lignes, ne garder que la dernière ligne.
3. Dans l’atelier précédent, vous avez écrit une commande pour afficher le résultat
de la commande ls -l en supprimant les répétitions d’espaces. Une fois qu’entre
chaque colonne, il n’y a qu’un seul espace, ajouter un filtre pour ne conserver
de toutes ces données que la cinquième colonne représentant la taille des fichiers
et répertoires.
4. Soit un fichier toto contenant un texte dont une des phrases est : Monstres,
je vous maudis. Écrire une commande qui affiche le contenu du fichier toto
en remplaçant toutes les occurrences de Monstres par Hommes et toutes les
occurrences de maudis par salue, de façon à ce que la phrase ci-dessus de-
vienne : Hommes, je vous salue. Éventuellement, ajouter une troisième redi-
rection pour que ce résultat soit enregistré dans un autre fichier texte.

Atelier filtrage 2 :
Ajoutons d’autres niveaux.

1. Nous allons reprendre le travail sur le fichier notes.csv. Nous souhaitons or-
donner ce fichier pour que les noms soient dans l’ordre alphabétique. Écrire deux
commandes :
— Écrire une première commande qui extrait la première ligne de notes.csv
(qui contient les titres de colonne) et l’enregistre dans le fichier notesTriees.csv ;
— Écrire une seconde commande qui extrait les 7 dernières lignes de notes.csv,
qui trie ces lignes et les ajoute à la fin du fichier notesTriees.csv ;
2. La commande ls -lS est équivalente à la commande ls -l à ceci près que les
fichiers sont ordonnés dans le sens décroissant des tailles. Écrire une commande
qui affiche la taille du fichier le plus volumineux du répertoire courant. Pour
cela, vous ferez un premier filtre qui supprime les répétitions d’espace, un autre

77
filtre qui extrait la deuxième ligne (le fichier le plus volumineux) et un dernier
filtre qui, à partir de cette ligne extrait le nom du fichier.

78
Chapitre 7

Les variables
7.1 Compétences visées
1. Définir une variable ;
2. Utiliser la valeur d’une variable dans une commande ;
3. Utiliser la valeur d’une variable dans une chaîne de caractères ;
4. Mettre le résultat d’une commande dans une variable ;
5. Utiliser les variables pour mettre les valeurs intermédiaires dans un enchaî-
nement de traitements ;
6. Utiliser des variables numériques.
7. Utiliser la variable status.

Jusqu’ici, nous avons parlé de shell sans nécessairement spécifier s’il s’agit de
sh, csh, ksh ou bash. De fait, la très grande majorité de ce que nous avons appris
juqu’ici vaut pour tous les shells. À partir du présent chapitre, certaines syntaxes
seront spécifiques au bash.
D’autre part, jusqu’ici, nos objectifs se sont limités à des tâches qu’on peut réaliser
avec une seule commande. Le fait de créer des variables revient à enregistrer les
résultats d’une commande pour les utiliser dans d’autres commandes. Ainsi, nous
nous dirigeons pas à pas vers la programmation en shell que nous verrons plus en
détail au chapitre suivant.

7.2 Les variables shell

7.2.1 Syntaxe de la définition

Définition de variables shell :

La syntaxe pour la définition d’une variable shell est la suivante :

<identificateur>=<valeur>

— Un identificateur est composé de caractères alphanumériques et d’unders-

cores, le premier caractère ne doit pas être un nombre.
— Il ne doit pas y avoir d’espaces d’un côté ou de l’autre de =.

De fait, un shell s’attend toujours à ce que l’utilisateur lui donne une commande

79
à exécuter. Les espaces lui permettent de séparer les commandes des options et des
arguments. Lorsque le shell détecte un ’=’ dans une commande, il reconnaît une
définition de variable. Ainsi, lorsque vous entrez :

sytaxe_correcte=3

il interprète syntaxe_correcte=3 comme une commande et, grâce à ’=’, reconnaît

une définition de variable. Par contre, lorsque vous entrez :

syntaxe_incorrecte = 3

il interprète syntaxe_incorrecte comme une commande, et = et 3 comme des ar-

guments et, comme il ne reconnaît pas la commande syntaxe_incorrecte, il vous
répond :

-bash: syntaxe_incorrecte : command not found

7.2.2 Expansion de variables

Expansion de variables shell :

Lorsque l’interpréteur shell rencontre l’opérateur $ suivi d’un nom de variable,

entre accolades ou non, il remplace l’ensemble par la valeur de cette variable. Ce
faisant, il a réalisé une expansion de cette variable.

Atelier expansion :

Soit la variable film définie de la façon suivante :

heros="spider"

Après cette commande, entrer :

echo ${heros}
echo $heros

L’interpréteur réalise l’expansion de la variable heros et remplace $heros ou

${heros} par sa valeur qu’il affiche.

7.2.3 Utilisation des accolades

L’utilisation des accolades :

Les accolades ne sont pas obligatoires mais, dans certains cas, elles permettent
de lever des ambiguïtés.

80
Atelier expansion avec accolades :

Soit la variable heros :

heros=spider
echo $heros man

Jusqu’ici tout va bien. Et si on voulait coller les deux chaînes de caractères ? Quel
est le résultat de la commande suivante ?

echo $herosman

Ambiguïté : est-ce qu’il s’agit de l’expansion de la variable heros suivi de man ?

ou de l’expansion de la variable herosman (qui n’existe pas) ?

echo ${heros}man

Cette dernière commande a pour mérite de ne laisser aucune ambiguïté.

7.2.4 Le type des données et l’utilisation des guillemets

Le type par défaut : la chaîne de caractères

En shell, par défaut, toutes les données sont de type chaîne de caractères. Donc,
dans la grande majorité des cas, il est inutile d’utiliser les guillemets.
En particulier les deux commandes suivantes :
var=guerre
var="guerre"
sont strictement identiques et équivalentes. Il en va de même pour :
var=1+2
var="1+2"
var="1"+"2"
Par contre :
film=Avengers Infinity War
produit un message d’erreur car le shell interprète cette ligne comme la commande
film=Avengers suivi de deux autres commandes Infinity et War (commandes qu’il
ne connaît pas). Alors que :
film="Avengers Infinity War"
permet de faire des trois mots une seule chaîne de caractères.

Les guillemets (double quotes en anglais)

Les guillemets permettent de créer des chaînes de caractères contenant des es-
paces.

81
7.2.5 Les apostrophes et les guillemets

Il existe deux caractères ressemblant à une apostrophe. Il est indispensable de

savoir distinguer les deux :

’ls’ : C’est celui qu’on utilise le plus couramment dans les textes en français ou en
anglais. On l’appelle apostrophe ou single quote en anglais.

`ls` : ces caractères sont appelés backquote ou backtick en anglais ou accent grave en
français.

Dans cette section, nous nous intéressons seulement à la première forme. Nous nous
intéresserons à la deuxième forme à la section suivante. De plus, je vous recommande
d’être extrêmement prudent quand vous copiez-collez des commandes depuis un do-
cument pdf comme celui qui vous êtes en train de lire : il arrive que, pendant ces
copier-collers, les apostrophes soient convertis en d’autres caractères. Je vous invite
donc à écrire ces apostrophes à la main.

Atelier apostrophes et guillemets :

prix=5

Essayer les deux instructions suivantes :

echo "Le prix est de $prix euros"

echo ’Le prix est de $prix euros’

En déduire la différence des guillemets et des apostrophes dans le

contexte de l’expansion des variables.

7.2.6 Les substitutions de commandes

Substitution de commandes

La substitution de commandes permet d’obtenir une chaîne de caractères

représentant le résultat d’une commande. La syntaxe recommandée pour la
substitution d’une commande cmd est :

$(cmd)

Les parenthèses sont nécessaires.

En regardant des scripts sur internet, on voit encore la syntaxe utilisant les back-
quotes : `cmd`, mais il s’agit d’une ancienne syntaxe. Je vous recommande d’utiliser
celle de l’encadré ci-dessus.

82
Atelier substitution :

Essayer les commandes suivantes :

fichiers=$(ls)
echo $fichiers

ou encore :

temps=$(date)
echo $temps

ou enfin :

nblignes=$(cat notes.csv | wc -l)

echo $nblignes

La susbstitution de commandes permet d’enregistrer le résultat d’une commande

pour l’utiliser dans une autre commande.
Atelier composition de commandes :
Les tâches suivantes doivent être réalisées en plusieurs commandes.

1. En utilisant la commande grep -n, écrire une commande qui trouve, dans le
fichier notes.csv sur Moodle, la ligne où apparaît thomas et affiche ce nombre.
Puis, écrire une seconde commande qui utilise cette valeur pour mettre dans
le fichier notes3.csv la ligne concernant thomas ainsi que toutes les lignes
précédentes.
2. On imagine que le fichier notes.csv est fréquemment modifié. On souhaite en
faire des copies régulières avec, dans le nom de chaque copie, la date et l’heure
à laquelle la copie a été faite. Par exemple pour une copie réalisée le 4 novembre
2019 à 8 :15, le format doit être :

notes_2019_11_04_08_15.csv

La date et l’heure à ce format sont obtenues par la commande :

date "+ %Y_%m_%d_%H_%M"

Écrire la commande qui réalise la copie.

3. Au chapitre précédent, nous avions voulu trier les données de notes.csv autres
que la première ligne. Pour cela, nous avions pris les 7 dernières lignes du fichier.
Mais 7 n’est rien d’autre que le nombre de lignes du fichier. Écrire les mêmes
commandes que dans le chapitre précédent, mais en retrouvant cette valeur.

7.3 Variables de type numérique

Comme mentionné ci-dessus, par défaut, les variables shell sont des chaînes de
caractères. Par exemple quel est le résultat de la commande : echo 1+2 ?

83
La commande expr

La commande expr interprète ses arguments comme une expression arithmétique

à évaluer et affiche le résultat de cette expression.

Atelier expr :
Essayer les commandes suivantes :

1. expr 35+2
2. expr 35 + 2
3. expr 35 / 2
4. expr 35 * 2
5. expr 35 2

Atelier2 expr :
Soit une variable z dont la valeur est un nombre (Par exemple z=3). Écrire une
commande qui :
— augmente la valeur de cette variable de 1. Dans notre exemple, la variable
z devra valoir 4.
— double la valeur de cette variable. Dans notre exemple, la variable z devra
valoir 6.

L’expansion mathématique

Si vous utilisez bash ou ksh, alors toute expression placée entre (( et )) est
considérée comme une expression numérique.

Il peut s’agir d’opérations arithmétiques, comme ci-dessus : addition, substraction,

multiplication, division. Mais il peut s’agir aussi de comparaisons ou d’affectations.
Essayer les commandes suivantes :

— echo $(( 3 + 2 ))
— echo $(( 3 - 2 ))
— echo $(( 3 * 2 ))
— z=5
echo $(( z + 5 ))
echo $(( $z + 5 ))
— echo $(( $z < 5 ))
— (( z = z + 1 ))

Cependant, comme mentionné ci-dessus, cet opérateur ne fonctionne qu’avec bash

et ksh, alors que la commande expr est utilisable sur tous les systèmes Unix. Donc
lorsqu’on cherche à avoir des scripts utilisables sur tous les types de machines, on
donnera la préférence à expr.

84
7.4 La variable de status
La variable de status

Le shell comporte une variable appelée variable de status. La commande echo

$? permet de connaître la valeur de cette variable. Cette valeur est toujours une
valeur numérique. Chaque exécution de commande est susceptible de modifier
cette valeur.
— Généralement, après une commande exécutée avec succès, la valeur de cette
variable est nulle.
— Dans le cas contraire, la valeur de cette variable est non-nulle.

Atelier variable de status :

Vérifier la valeur de la variable de status après les commandes suivantes :

— cat toto (où toto est un fichier qui existe dans le répertoire courant) ;
— cat toto (où toto n’existe pas dans le répertoire courant) ;
— cat toto (où toto n’est pas accessible en lecture) ;
— man ls | grep "command" ;
— man ls | grep "Spiderman" ;
— man ls > manls.txt
grep "spiderman" manls.txt

— man ls > manls.txt

chmod u-r manls.txt
grep "command" manls.txt

À votre avis, qu’est-ce qui explique ces valeurs différentes pour la variable de status
dans les deux derniers exemples ?

85
86
Chapitre 8

Les scripts shell

8.1 Compétences visées

1. Mettre un enchaînement de commandes dans un fichier et l’exécuter ;

2. Utiliser les variables d’environnement
3. Savoir commenter son programme
4. Utiliser les variables de position
5. Définir et utiliser la valeur de retour d’un script ;
6. Utiliser la structure if, then, else pour faire des conditionnels ;
7. Utiliser la structure for et while pour faire des boucles ;
8. Automatiser un traitement par un script shell.

Dans ce chapitre, vous allez découvrir comment les différentes commandes que vous
avez apprises jusqu’ici pourront vous permettre d’écrire de véritables programmes
vous permettant d’automatiser les tâches répétitives.

8.2 Votre premier shell script

Atelier premier script

1. Ouvrir un éditeur de texte, comme gedit ou geany, et y écrire des commandes

shell. N’importe lesquelles. Par exemple :
echo "HELLO !!"
echo "bonjour" > toto
date
2. Assurez-vous que vous connaissez l’effet qu’auraient eu ces commandes si
vous les aviez entrées dans un terminal ;

87
 3. Sauvegarder ce fichier, par exemple sous le nom premier.sh ;
4. Ensuite, dans un shell, placez-vous dans le même répertoire que celui du
fichier permier.sh ;
5. Donner à ce fichier les droits d’exécution pour vous-mêmes ;
6. Puis entrer la commande : ./premier.sh
7. Que se passe-t-il ?

Un script shell

Un script shell est un fichier texte contenant une suite de commandes shell. Si un
utilisateur a des droits d’exécution sur ce fichier, alors il peut utiliser ce fichier
comme un programme simplement en entrant le chemin du fichier dans un shell.
Le résultat de l’exécution est le même que si on avait entré chaque commande
dans le terminal.
Comme nous le verrons dans la section 8.7 et les suivantes, il est possible que le
script shell ne soit pas une simple séquence de commandes, mais soit organisée par
des structures de contrôle.

8.3 Les variables d’environnement

8.3.1 Définition, suppression, liste
Vous avez appris, au chapitre précédent comment définir et utiliser des variables
dans le shell. Vous pouvez définir des variables interactivement dans un terminal ou
dans un script. Dans cette section, vous allez apprendre à définir et à utiliser des
variables dits d’environnement. Elles aussi, peuvent être définies dans un terminal ou
dans un script. Nous verrons l’utilité de ces variables.

Les variables d’environnement

export TOTO=5

est une commande qui définit TOTO comme une variable d’environnement et donne
à cette variable, la valeur 5.

Comme pour les variables shell vues au chapitre précédent, il est important qu’entre
le nom de la variable, le caractère = et la valeur de la variable, il n’y ait pas d’es-
pace. L’expansion des variables d’environnement suit le même principe que celle des
autres variables. Souvent, pour les variables d’environnement, on choisit des noms en
majuscule.

La liste des variables d’environnement

env
est une commande qui affiche toutes les variables d’environnement définies dans
votre shell.
Est-ce que celle que vous avez définie en fait partie ? Pour supprimer une variable
d’environnement que vous aurez créée, vous pouvez utiliser la commande unset.

88
Supprimer une variable d’environnement

Entrer la commande :
unset TOTO
et assurez-vous que cette variable a été supprimée. Quelle commande utiliserez-
vous pour vous en assurer ?

8.3.2 Les variables d’environnement prédéfinies

Vous pouvez définir autant de variables d’environnement que vous le souhaitez.
Mais, comme vous l’avez vu avec la commande env, certaines variables d’environne-
ment sont déjà définies dans votre shell.

Variables d’environnement prédéfinies

Interroger les valeurs des variables suivantes et, d’après le nom de la variable et
sa valeur, devinez le sens de chacune :
LANG
PWD
SHELL
USER
HOME
PATH (nous en parlerons plus loin)

8.3.3 Différence entre les variables shell et variables d’envi-

ronnement

Atelier différences

1. Dans un terminal, définir une variable shell et une variable d’environnement.

Par exemple :
toto=5
export TOTO=5
2. Toujours dans le terminal, écrire les commandes :
echo $toto
echo $TOTO
pour vous assurer de la valeur de ces variables ;
3. Créer un fichier shell script en y écrivant les deux commandes de la question
2 ci-dessus ;
4. Depuis le même terminal, lancer ce shell script. Qu’en déduisez-vous ?
5. Par ailleurs, dans un nouveau terminal, entrer de nouveau ces deux com-
mandes. Qu’en déduisez-vous ?

89
Portée des variables :

1. La portée d’une variable shell se limite au shell où elle a été définie (terminal
ou script) ;
2. La portée d’une variable d’environnement englobe le shell où elle a été
définie (terminal ou script) ainsi que tous les processus lancés par ce shell.

En particulier, si vous ouvrez deux terminaux, le fait de définir une variable d’envi-
ronnement dans l’un ne la rend pas utilisable dans l’autre. Par contre, tout processus
(en particulier tout script shell) lancé par un shell hérite de toutes les variables d’en-
vironnement déjà définies dans le shell de ce terminal.

8.3.4 La variable PATH

Vous avez vu, au chapitre 2, que les commandes que vous entrez dans le shell
correspondent à des programmes qu’on peut situer dans l’arborescence des fichiers.
Par exemple, sur la figure 2.1, vous pouvez voir que ls, cp, mv et mkdir sont dans le
répertoire /bin et que firefox et google-chrome sont dans /usr/bin. Il y a encore
d’autres programmes qui se trouvent dans /usr/local/bin, /sbin, /usr/sbin et
ailleurs encore.
Pour lancer ces programmes, on peut fournir le chemin complet du fichier. Essayez
par exemple les commandes suivantes :
/bin/ls
/bin/mkdir toto
/usr/bin/python3
/usr/bin/nautilus
Vous l’avez sans doute compris, à chaque fois que vous entrez une commande, le
système lance un de ces programmes disséminés dans l’arborescence. Vous pouvez
sans doute vous demander comment le système parvient-il à localiser le programme
qu’il doit lancer, en ayant seulement le nom de la commande.

La variable PATH

La valeur de la variable d’environnement PATH doit être constituée d’une suite

de chemins absolus de répertoires, séparés par des caractères ’:’. Ces chemins
sont ceux où le système cherche pour trouver le programme correspondant à une
commande entrée dans le terminal.
Sur turing, par défaut, la variable PATH a la valeur suivante :
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games
Par exemple, lorsque vous entrez la commande ls, le système cherche le programme
ls en commençant par les premiers répertoires sur la liste :
— Il ne trouve pas de /usr/local/sbin/ls.
— Il ne trouve pas de /usr/local/bin/ls.
— Il ne trouve pas de /usr/sbin/ls.
— Il ne trouve pas de /usr/bin/ls.
— Il ne trouve pas de /sbin/ls.
— C’est enfin dans /bin qu’il trouve /bin/ls et le lance.

90
Si le programme correspondant à la commande ne peut être trouvé dans aucun des
répertoires de PATH, alors le système rapporte : Command not found.

Atelier modification de la variable PATH

1. À votre avis, que se passerait-il si vous modifiez la valeur de PATH de façon

à ce que celle-ci soit une chaîne vide ? (Ne le faites pas encore).
2. Écrire une commande qui écrive la valeur de la variable PATH dans un fichier
mypath.txt ;
3. Définir une variable pth dont la valeur soit celle de la variable PATH ;
4. Donner à PATH la valeur /bin ;
5. Essayer les commandes : ls, date, chmod et aussi python3, geany,
firefox etc.. Est-ce que ce comportement est inattendu ? Dans les ques-
tions suivantes, nous allons tenter de revenir à un fonctionnement normal.
6. Supposons que vous n’ayez pas noté la valeur initiale de votre variable PATH.
En sachant ce que vous savez sur la portée des variables, que pouvez-vous
faire pour avoir accès, de nouveau, à vos applications ?
— Dans le même terminal, entrer bash pour ouvrir un autre shell ?
— Fermer le terminal courant et ouvrir un autre terminal (avec un nou-
veau shell) ?
7. Avec une seule commande, redéfinir la variable PATH en lui donnant la valeur
initiale que vous aviez enregistrée dans le fichier mypath.txt ou dans la
variable pth. (Pas de copier/coller à la souris SVP).

Vous avez sans doute remarqué que le répertoire courant ’.’ n’est pas, par dé-
faut, dans la variable PATH. C’est la raison pour laquelle, lorsque vous voulez lancer un
exécutable qui se trouve dans votre répertoire courant, vous ne pouvez pas tout sim-
plement entrer son nom (comme vous le fait pour d’autres commandes comme ls ou
python3. En effet, lorsque, dans votre répertoire courant, vous avez un programme
exécutable qui s’appelle permier.sh, vous devez entrer son chemin ./premier.sh
pour le lancer.

Répertoire courant dans PATH ?

— Modifier PATH en ajoutant le répertoire courant avant sa valeur

actuelle. Autrement dit si, par exemple, PATH vaut initialement
/usr/local/bin:/usr/bin:/bin, écrire une commande pour que sa valeur
soit : .:/usr/local/bin:/usr/bin:/bin ;
— Lancer votre premier script en entrant simplement premier.sh (sans ajou-
ter de ./) ; Est-ce que cela fonctionne ?
— Renommer votre script pour qu’il ne s’appelle plus premier.sh mais ls ;
— Est-ce que le renommage a fonctionné ?

Est-ce que vous comprenez pourquoi, par défaut, on ne met pas le répertoire
courant dans PATH ? Remettre votre variable PATH à sa valeur initiale, ou changer de
terminal.

91
8.4 Ce qui suit un caractère #

8.4.1 Les commentaires

À une exception (celle décrite au paragraphe 8.4.2), tout texte se trouvant entre
un caractère dièse # et une fin de ligne est ignorée par l’interpréteur shell. Comme
dans tout autre langage, je vous invite à ne pas vous priver de commenter vos scripts
pour qu’un autre programmeur, ou vous-mêmes dans quelques temps, puissiez mieux
lire ce script et comprendre les intentions et l’implémentation de votre programme.

8.4.2 Le Shebang

Comme vous l’avez vu au chapitre 1 de ce cours, bash n’est pas le seul langage de
shell. On avait évoqué d’autres shells comme sh (Bourne shell), csh (C-shell), tcsh
(Turbo C-shell) ou encore ksh (Korn shell).
Or il est important qu’un script écrit dans un langage donné puisse être lu par un
interpréteur du même langage, faute de quoi, certaines commandes ou structures de
contrôle seraient illisibles. Par défaut, le shell utilisé pour lire un script est celui défini
par la variable d’environnement SHELL. Sur les machines de l’UFR, il s’agit toujours
de bash. Donc tant que vous écrivez vos scripts en bash et que vous les exécutez sur
les machines de l’UFR, ces scripts seront lisibles. Par contre, si vous êtes satisfaits de
vos scripts et que vous les envoyez à des ami(e)s travaillant sur d’autres machines, où
le shell par défaut n’est pas le bash, ils pourront avoir des surprises.
C’est la raison pour laquelle il est utile de spécifier, dans le script même, le langage
shell qu’il faut utiliser pour interpréter ce script. C’est l’intérêt du Shebang. Il s’agit
de la chaîne "#!" placée en début de fichier et suivi du chemin du shell qui doit être
utilisé pour lire le script. Dans ce cours, nous avons choisi de travailler avec bash.
Donc je vous demande de commencer systématiquement tous vos scripts par la ligne :

#!/bin/bash

Ainsi, le script suivant donnera le même résultat que celui que vous avez écrit à
la section 8.2 et sera plus robuste et plus lisible.

#!/bin/bash

echo "HELLO!!"

# Cette commande ecrit "bonjour" dans le fichier toto

echo "bonjour" > toto

# affiche la date
date

92
8.5 Les paramètres de position

Les paramètres de position

— Chaque shell est caractérisé par un certain nombre de paramètres de posi-

tion ;
— L’expression $n est la valeur de la variable de position numéro n ;
— Par exemple $0 est la valeur de la variable de position numéro 0 (la pre-
mière) ;
— L’expression $# a pour valeur le numéro de la dernière variable de position,
autrement dit, 1 + le nombre de paramètres de position ;

Atelier paramètres de position

— Écrire un shell script avec un shebang, l’enregistrer sous un nom (par

exemple pos.sh) et y écrire les commandes suivantes :
echo $0
echo $1
echo $2
echo $3
echo $#
— Lancer le script ./pos.sh ;
— Lancer le script ./pos.sh 3 5 bonjour ;
— Avant la première instruction, juste après le shebang, ajouter la commande :
set 25 bonjour 3.14 ;
— Lancer le script ./pos.sh ou ./pos.sh 3 5 bonjour.

De façon générale, les variables de position peuvent être définies dans différentes
situations :

— À l’appel d’un script, les variables de position prennent la valeur des arguments
du script ;

— À l’appel d’une fonction (que nous ne verrons pas cette année), les variables de
position prennent la valeur des arguments de la fonction ;

— Après la commande set, les variables de position prennent la valeur des argu-
ments qui suivent set.

Atelier somme

Écrire un shell script appelée somme.sh qui fait la somme de ses arguments. Par
exemple somme.sh 3 5 devrait afficher 8.

93
8.6 La variable status ou diagnostique d’un script
8.6.1 La commande exit
Un script se termine lorsqu’une des commandes du script rencontre une erreur
ou lorsque la dernière commande a été exécutée. Elle peut aussi se terminer avec la
commande exit, placée à la fin du script ou ailleurs.

8.6.2 Le diagnostique
Vous avez vu au chapitre précédent que, l’expression $? a pour valeur le status du
shell. Chaque commande, dans ce shell, donne une nouvelle valeur à cette variable.
Souvent cette variable sert de diagnostique.
— Si la valeur de cette variable est 0 cela signifie que la commande a été effectuée
avec succès ;
— Les différentes valeurs non-nulles peuvent indiquer différents types de dysfonc-
tionnements.

Diagnostique d’un shell script

— Par défaut, le statut de sortie d’un shell script est celle de la dernière com-
mande du script ;
— Si la fin du shell script est due à la commande exit et que cette commande
est suivie d’un nombre, alors le statut de sortie du script sera égal à ce
nombre.

Atelier diagnostique du script

Ajouter une commande exit à la fin d’un de vos shell scripts de façon à ce que
le statut de sortie de ce script soit toujours de 5.

Dans les sections suivantes, nous allons voir les différentes structures de contrôle
du langage bash. Il en existe de très nombreuses sortes. Nous ne vous en montrerons
qu’un nombre limité. Nous privilégions les structures les plus répandues et insisterons
moins sur les structures propres à un seul langage.

8.7 La structure if, then, else

Dans cette section, nous apprendrons à faire ce que vous savez déjà faire depuis
longtemps en python : exécuter certaines commandes seulement dans certaines condi-
tions. Voici la syntaxe générale :
if [ <condition> ]
then
< commandes1 >
else
< commandes2 >
fi

Nous allons voir, plus loin, les formes que peuvent avoir les conditions.

94
Structures if-then-else
— Si <condition> est vérifiée, alors les commandes situées entre then et else
sont exécutées.
— Dans le cas contraire, les commandes situées entre else et fi sont exécutées.

Syntaxiquement, il est important qu’il y ait au moins un espace :

— entre le mot clef if et le crochet ouvrant ;
— entre le crochet ouvrant et le début de la condition ;
— entre la fin de la condition et le crochet fermant.
La syntaxe suivante est également possible.
if [ <condition> ]
then
< commandes >
fi

Structures if-then-else
— Si <condition> est vérifiée, alors les commandes situées entre then et else
sont exécutées.
— Dans le cas contraire, ces commandes ne sont pas exécutées.

Voici les formes que peut prendre la condition. Ces conditions peuvent porter sur
des chaînes de caractères :
chaine1 = chaine2 condition vérifiée si les deux chaines de caractères sont identiques
chaine1 != chaine2 condition vérifiée si les deux chaines de caractères sont différentes
Elles peuvent porter sur des entiers :
entier1 -eq entier2 condition vérifiée si les deux entiers sont égaux
entier1 -ne entier2 condition vérifiée si les deux entiers sont différents
entier1 -gt entier2 condition vérifiée si entier1 > entier2 (gt signifie greater than)
entier1 -lt entier2 condition vérifiée si entier1 < entier2 (lt signifie less than)
On peut utiliser les opérateurs -ge et -le (au lieu de -gt et -lt) pour les inégalités
au sens large. Enfin, elles peuvent porter sur des chaînes de caractères interprétées
comme des noms de fichier ou répertoire :
-e toto condition vérifiée si toto est un fichier ou répertoire présent dans le répertoire courant ;
-f toto condition vérifiée si toto est un fichier régulier présent dans le répertoire courant ;
-d toto condition vérifiée si toto est un répertoire présent dans le répertoire courant ;
-r toto condition vérifiée si toto est présent et accessible en lecture ;
-w toto condition vérifiée si toto est présent et accessible en écriture ;
-x toto condition vérifiée si toto est présent et accessible en exécution.

Atelier conditionnel :

Reprendre votre shell script somme.sh et ajouter une condition au début du script
de façon à ce que si le nombre d’arguments du script est égal à 2, le script affiche
la somme des deux arguments et que, dans le cas contraire (else) il émette un
message d’erreur indiquant qu’il faut deux arguments et quitte avec un status de
1.

95
 Le langage bash offre la possibilité d’utiliser les double crochets : [[ et ]] qui
offrent des possibilités très intéressantes mais qui n’existent que dans bash. C’est la
raison pour laquelle nous n’en parlerons pas. Vous verrez aussi, dans certains scripts,
les double parenthèses très intéressants pour les calculs numériques que nous n’utili-
serons pas non plus dans ce cours.

8.8 Les boucles for

Dans ce cours nous utiliserons une syntaxe de la structure for très proche de celle
de python :
for <var> in <sequence>
do
< commandes >
done

<sequence> est supposée être une suite de chaînes de caractères séparés par des
espaces, des tabulations ou des sauts de lignes. Dans ce cas, si <sequence> est com-
posée de n chaînes, alors la boucle for exécutera n fois <commandes>. À la i-ième
exécution, <var> sera égal à la i-ième chaîne de <sequence>.

Atelier for séquence prédéfinie :

Essayer le script suivant :

#!/bin/bash
for i in 5 2 9 45 12
do
echo $i
done
Pour les séquences d’entiers croissants, nous pouvons utiliser un outil très pratique.

Atelier séquences :

Essayer les scripts suivants :

echo {1..5}
echo {80..100}

Atelier for intervalle :

Écrire un shell script qui affiche un message contenant un nombre qui croît de 5
à 20. Par exemple :
Vous avez gagne 5 euros
Vous avez gagne 6 euros
Vous avez gagne 7 euros
...
Vous avez gagne 20 euros

96
 Comme séquence, vous pouvez également mettre toute liste issue d’une commande.

Atelier for :

Reprendre le script simple du premier atelier de la section for, mais remplacer la

séquence 5 2 9 45 12 par $(ls Documents) ou par $(cat toto) où toto serait
un fichier texte.
Enfin, pour parcourir des fichiers ou des répertoires, il est également possible de
remplacer la séquence par un wildcard (un motif contenant un * ou un ?)

Atelier for wildcard :

Reprendre le script simple du premier atelier de la section for, mais remplacer

la séquence 5 2 9 45 12 par * ou par rep/*.sh où rep serait un répertoire où
vous auriez des shell script avec l’extention .sh.

Atelier for ls :

Faire un shell script qui parcourt tous les fichiers réguliers du répertoire courant
qui ont une extension py et, pour chaque fichier, affiche le nom du fichier et son
nombre de lignes.

8.9 Les boucles while

Les boucles while ont une syntaxe semblable à celle du if par certains aspects et
à celle du for par d’autres aspects.
while [ <condition> ]
do
< commandes >
done

Comme vous pouviez peut-être vous y attendre, les commandes <commandes>

sont répétées tant que <condition> est vérifiée. Les formes que peuvent prendre
<condition> sont les mêmes que pour la structure if.

Atelier while :

Écrire un shell script qui exécute une commande 5 fois, mais en utilisant une
boucle while. Pour incrémenter un nombre, vous pouvez utiliser expr.

8.10 Projets divers

Voici plusieurs projets. À vous de choisir ou de les faire tous.

8.10.1 Chercher les fichiers erronés

1. Écrire un script du nom de fouille.sh ;

97
 2. Ce script devra chercher, dans toute l’arborescence du répertoire courant, des
fichiers dont l’extension est *.py. Pour cela, utiliser la commande find en re-
dirigeant les messages d’erreur vers la poubelle ;
3. Ce script devra parcourir tous les fichiers issus de cette recherche et, si ces
fichiers sont lisibles, extraire la première ligne ;
4. Si cette première ligne contient la chaine from math import *, alors afficher le
chemin de ce fichier.

8.10.2 Traiter un fichier csv

Soit le fichier Temps.csv que vous pouvez ouvrir avec Excel ou LibreOffice, mais
qui est simplement un fichier texte dont les différents champs ont été séparés par
des point-virgules. Vous pouvez l’afficher dans n’importe quel éditeur de texte comme
gedit. Il s’agit des résultats d’une course de trois équipes (1,2 et 3). Ce tableau contient
une ligne pour chaque joueur. Sur chaque ligne, on peut voir son prénom (colonne 1),
son nom (colonne 2), son groupe (colonne 3) et le temps effectué pour finir la course.
On cherche à établir la moyenne des temps du groupe 3.
1. Écrire un script du nom de Temps.sh ;
2. Ce script devra vérifier qu’il a été appelé avec un argument et un seul. Si ce
n’est pas le cas, il devra émettre un message d’erreur et sortir avec un status de
1;
3. S’il y a effectivement un argument, alors cet argument est interprété comme
un fichier. Définir une variable nblignes dont la valeur est le nombre de lignes
dans le fichier ;
4. Soit une variable best initialisée à 100000 et une variable champion3 initialisée
à la chaîne vide ;
5. Ce script devra parcourir toutes les lignes du fichier en commençant par la
seconde (la première contient les titres de colonne) et, pour chaque ligne, il
devra extraire le nom, le prénom, le groupe et le temps du joueur ;
6. Si le joueur appartient au groupe 3, le script devra comparer son temps à best ;
Si son temps est inférieur à best, alors il faudra remettre à jour la valeur de
best pour qu’elle soit égale à cette nouvelle valeur. D’autre part la valeur de
champion3 devra être le prénom et le nom de ce joueur.
7. À la fin du script, le shell devra nous donner le nom du champion du groupe 3.
8. Vérifier, sur LibreOffice que votre réponse est bien correcte.

98