Le Terminal

Introduction

Le terminal est une interface texte qui permet de communiquer directement avec le système d'exploitation. Contrairement à une interface graphique où tu cliques sur des icônes et des menus, dans le terminal tu tapes des instructions sous forme de texte et le système te répond en texte.

Pourquoi utiliser le terminal alors qu'on a des interfaces graphiques ? Plusieurs raisons :

• La puissance : certaines opérations sont impossibles ou très lentes avec une souris. Renommer 500 fichiers, chercher un mot dans 200 fichiers, automatiser une tâche répétitive — le terminal fait ça en une ligne.
• La précision : une commande fait exactement ce que tu lui dis, rien de plus, rien de moins. Pas d'ambiguïté, pas de "est-ce que tu voulais dire...".
• L'universalité : les serveurs n'ont pas d'interface graphique. À 42, sur un poste de travail ou un serveur distant, le terminal est toujours là.
• La composabilité : les commandes Unix sont des briques. Tu peux les combiner entre elles pour créer des opérations complexes. C'est le sujet de la vidéo A03 sur les pipes.
• La reproductibilité : une commande tapée une fois peut être rejouée à l'identique. Une suite de commandes peut devenir un script. Avec une interface graphique, tu ne peux pas "rejouer" une séquence de clics.

À 42, le terminal c'est ton outil principal. Tu l'utiliseras tous les jours pendant la Piscine et tout le cursus. Les évaluations se font au terminal. La compilation se fait au terminal. Git se fait au terminal. L'éditeur que la plupart des étudiants utilisent (vim) est dans le terminal.

Le prompt

Quand tu ouvres un terminal, tu vois quelque chose comme :

isoulima@c1r1s1:~$

C'est le prompt. Il se décompose ainsi :

• isoulima — ton nom d'utilisateur (login)
• c1r1s1 — le nom de la machine (hostname)
• ~ — le dossier où tu es (~ = ton home)
• $ — indique que tu es un utilisateur normal (un # indiquerait root, le super-utilisateur)

Le prompt te dit que le terminal attend une commande. Tu tapes ta commande, tu appuies sur Entrée, le système exécute et affiche le résultat en dessous. Puis un nouveau prompt apparaît, prêt pour la commande suivante.

Shell

Le programme qui interprète tes commandes s'appelle le shell. C'est lui qui lit ce que tu tapes, comprend quelle commande tu veux exécuter, la lance, et t'affiche le résultat.

Il existe plusieurs shells :

• bash (Bourne Again Shell) — le plus courant sur Linux
• zsh (Z Shell) — le shell par défaut sur macOS et souvent utilisé à 42
• sh — le shell POSIX minimal

Les différences entre bash et zsh sont mineures pour un débutant. Les commandes qu'on va voir fonctionnent dans tous les shells.

Pour savoir quel shell tu utilises :

Le système de fichiers Unix

L'arborescence

Sur Unix (Linux, macOS), tous les fichiers sont organisés dans une arborescence unique. Au sommet il y a la racine, notée / (un simple slash). Tout part de là.

/
├── bin/          ← les programmes système (ls, cp, cat...)
├── etc/          ← les fichiers de configuration
├── home/         ← les dossiers personnels des utilisateurs
│   ├── isoulima/
│   ├── jdupont/
│   └── mmartin/
├── tmp/          ← fichiers temporaires
├── usr/          ← programmes installés
└── var/          ← données variables (logs, bases de données)

Chaque utilisateur a son home directory dans /home/. C'est ton espace personnel — tu peux y créer, modifier et supprimer tout ce que tu veux. Tu ne peux pas toucher aux fichiers des autres utilisateurs ni aux fichiers système (sauf si tu es root).

Chemins

Un chemin (path) c'est l'adresse d'un fichier ou dossier dans l'arborescence. Il existe deux types :

/home/isoulima/Documents/mon_projet/main.c

Ce chemin est valide peu importe où tu es dans le système.

Documents/mon_projet/main.c

Ce chemin n'est valide que si tu es dans /home/isoulima/.

• . (point) — le dossier courant
• .. (point point) — le dossier parent (un niveau au-dessus)
• ~ (tilde) — ton home directory
• / seul — la racine du système

Fichiers et dossiers

Tout est fichier sur Unix. Un dossier est un fichier spécial qui contient une liste d'autres fichiers. Un fichier texte contient du texte. Un programme contient du code machine. Mais pour le système, ce sont tous des "fichiers".

Se repérer

pwd — Où suis-je ?

Le "working directory" c'est le dossier dans lequel le terminal travaille en ce moment. Toutes les commandes s'exécutent par rapport à ce dossier. Si tu fais ls, il liste le contenu du working directory. Si tu crées un fichier, il est créé dans le working directory.

C'est toujours la première commande à taper quand tu es perdu.

La variable $HOME contient le chemin de ton home directory :

ls — Lister le contenu

Les dossiers et fichiers sont affichés par ordre alphabétique. Sans option, tu ne vois que les noms.

Chaque colonne a un sens :

Le premier caractère indique le type :

• d = dossier (directory)
• - = fichier normal
• l = lien symbolique (raccourci)

• . = le dossier courant (lui-même)
• .. = le dossier parent
• .bashrc, .zshrc = fichiers de configuration du shell

La combinaison de -l et -a montre tout en détail. C'est la commande que tu utiliseras le plus souvent.

• ls -R — affiche récursivement le contenu des sous-dossiers
• ls -t — trie par date de modification (le plus récent en premier)
• ls -S — trie par taille (le plus gros en premier)
• ls -h — tailles lisibles (Ko, Mo au lieu d'octets)
• ls -lh — combo détaillé + tailles lisibles

Les patterns , ?, [...] s'appellent des globs. C'est le shell qui les interprète, pas la commande ls. Toutes les commandes peuvent les utiliser : rm .o, cat *.c, etc.

La taille 4096 d'un dossier ne représente PAS la taille de son contenu. C'est la taille de la "table des matières" du dossier (la liste des fichiers qu'il contient). Pour connaître la taille réelle d'un dossier et son contenu :

cd — Se déplacer

Tu es maintenant "dans" le dossier Documents. Toutes les commandes s'exécutent maintenant par rapport à ce dossier.

Ça marche peu importe où tu es.

Ça remonte d'un niveau puis entre dans Downloads.

C'est un raccourci très pratique. cd - te ramène au dossier où tu étais avant le dernier cd.

Le dossier n'existe pas, ou tu as fait une faute de frappe. Unix est sensible à la casse : Documents et documents sont deux dossiers différents.

Créer

mkdir — Créer un dossier

Sans -p, la commande échoue si ex00 ou srcs n'existent pas. Avec -p, tous les dossiers intermédiaires sont créés automatiquement.

Le dossier existe déjà. Ce n'est pas grave, mais la commande te prévient.

touch — Créer un fichier

La taille est 0 — le fichier est vide. C'est normal. Tu utiliseras un éditeur de texte (vim, nano, VS Code) pour écrire dedans.

Copier, déplacer, supprimer

cp — Copier

Sans -r, la commande refuse de copier un dossier.

Le dernier argument doit être un dossier existant.

Tu as oublié -r.

mv — Déplacer et renommer

Déplacer un fichier dans le même dossier avec un nom différent = renommer.

Pas besoin de -r contrairement à cp. mv ne copie pas, il déplace — c'est juste un changement d'adresse.

rm — Supprimer

Pas de confirmation, pas de corbeille. Le fichier est détruit immédiatement.

Supprime le dossier et tout ce qu'il contient, y compris les sous-dossiers.

Ne demande aucune confirmation, même si les fichiers sont protégés en écriture.

Pourquoi ? Quand tu supprimes un fichier avec rm, le système ne "efface" pas les données du disque. Il supprime le lien entre le nom du fichier et l'inode (les données). Les données sont toujours sur le disque, mais le système considère cet espace comme "libre" et peut l'écraser à tout moment. Sans outils spécialisés de récupération (et encore, sans garantie), c'est perdu.

• Toujours vérifier deux fois avant de taper rm -rf
• Ne JAMAIS faire rm -rf / ou rm -rf ~ — ça détruit tout
• Utiliser git pour versionner ton code (c'est le sujet de la prochaine vidéo)
• En cas de doute, ls d'abord pour vérifier ce que tu vas supprimer
• Utiliser rm -i si tu veux une confirmation pour chaque fichier :

Il faut -r pour un dossier.

Le fichier est en lecture seule. Tape y pour confirmer ou utilise -f.

Lire des fichiers

cat — Afficher tout

Affiche le contenu des deux fichiers à la suite.

Pour un gros fichier, cat défile trop vite. Dans ce cas, utilise less :

• Flèches haut/bas pour naviguer
• Space pour avancer d'une page
• /mot pour chercher
• q pour quitter

head — Les premières lignes

tail — Les dernières lignes

less — Naviguer dans un fichier

wc — Compter

C'est un aperçu des pipes qu'on verra dans A03 — on prend la sortie de ls et on la passe à wc.

diff — Comparer deux fichiers

echo — Afficher du texte

Avec les redirections (aperçu, détaillé dans A03) :

Les permissions

Pourquoi les permissions existent

Unix est un système multi-utilisateurs. Sur un poste 42, des dizaines d'étudiants utilisent la même machine. Sans permissions, n'importe qui pourrait lire tes projets, modifier ton code, ou supprimer ton travail. Les permissions sont le mécanisme qui empêche ça.

Mais les permissions ne servent pas qu'à protéger des autres humains. Elles empêchent aussi les programmes de faire n'importe quoi. Un script buggé ne pourra pas écraser tes fichiers système si les permissions l'en empêchent. C'est une couche de sécurité fondamentale.

Lire les permissions

Quand tu fais ls -l, la première colonne affiche les permissions :

La chaîne de 10 caractères se décompose en 4 parties :

d   rwx   r-x   r-x
│   │     │     │
│   │     │     └── Others : les permissions pour tout le monde
│   │     └──────── Group  : les permissions pour le groupe
│   └────────────── User   : les permissions pour le propriétaire
└────────────────── Type   : le type de fichier

• - = fichier normal
• d = dossier (directory)
• l = lien symbolique (un raccourci vers un autre fichier)
• c, b = fichiers spéciaux (périphériques, tu n'y toucheras pas)

Les trois droits : r, w, x

Chaque droit a un sens différent selon qu'il s'applique à un fichier ou à un dossier :

C'est un piège classique : tu peux supprimer un fichier en lecture seule si tu as le droit w sur le dossier qui le contient. La permission w d'un fichier ne protège que son contenu, pas son existence.

Exemple concret :

Le programme est compilé mais x n'est pas activé. Le système refuse de l'exécuter. Il faut d'abord :

Les trois groupes : user, group, others

Chaque fichier appartient à un propriétaire (user) et à un groupe. Les permissions sont définies séparément pour trois catégories de personnes :

Quand tu accèdes à un fichier, le système vérifie dans cet ordre :

1. Tu es le propriétaire ? → applique les permissions User
2. Tu es dans le groupe ? → applique les permissions Group
3. Sinon → applique les permissions Others

Exemple :

-rw-r-----  1 isoulima 42staff  61 Apr  5 10:30 main.c

• isoulima peut lire et écrire (rw-)
• Les membres de 42staff peuvent lire (r--)
• Les autres ne peuvent rien faire (---)

Le système octal

L'octal c'est un système de numération en base 8 (chiffres de 0 à 7). On l'utilise pour les permissions parce que 3 bits (r, w, x) = exactement un chiffre octal.

Chaque droit est un bit (activé ou pas) avec une valeur :

r = 4   (bit 2, binaire 100)
w = 2   (bit 1, binaire 010)
x = 1   (bit 0, binaire 001)

Tu additionnes les valeurs des droits que tu veux activer :

rwx = 4 + 2 + 1 = 7
rw- = 4 + 2 + 0 = 6
r-x = 4 + 0 + 1 = 5
r-- = 4 + 0 + 0 = 4
-wx = 0 + 2 + 1 = 3
-w- = 0 + 2 + 0 = 2
--x = 0 + 0 + 1 = 1
--- = 0 + 0 + 0 = 0

Trois chiffres = user, group, others :

chmod 754 fichier
        │││
        ││└── Others : r-- (4 = lire)
        │└─── Group  : r-x (5 = lire + exécuter)
        └──── User   : rwx (7 = tout)

rw-r--r--  → 644
rwxr-xr-x  → 755
rwx------  → 700
rw-------  → 600
rwxr-x---  → 750

Dans l'autre sens :

chmod 664 → rw-rw-r--
chmod 777 → rwxrwxrwx
chmod 000 → ---------
chmod 751 → rwxr-x--x

chmod — Modifier les permissions

Tu remplaces toutes les permissions d'un coup. C'est rapide et sans ambiguïté.

• + ajoute un droit
• - retire un droit
• = fixe les droits exactement (remplace tout)
• u, g, o = user, group, others
• a = all (les trois)

Change les permissions de tout le contenu du dossier (sous-dossiers inclus). Attention : donner x à tous les fichiers (pas juste les dossiers) est rarement ce que tu veux. Préfère :

Permissions courantes à 42

Cas concrets à 42

Les autres étudiants ne peuvent ni lire ni entrer dans le dossier.

Le script doit être exécutable. La Moulinette vérifie ça.

La clé privée doit être en 600 (toi seul peut la lire) :

Propriétaire et groupe

Chaque fichier a un propriétaire et un groupe, affichés par ls -l :

-rw-r--r--  1 isoulima 42staff  61 main.c
                │        │
                │        └── Groupe : 42staff
                └─────────── Propriétaire : isoulima

Les deux en même temps :

À 42, tu n'auras presque jamais besoin de chown/chgrp car tu travailles dans ton home et tu es déjà le propriétaire de tout. Mais comprendre le concept est essentiel.

umask — Les permissions par défaut

Quand tu crées un fichier, il n'a pas les permissions 777. Le système applique un masque qui retire certains droits. Ce masque s'appelle umask.

• Un fichier est créé en 644 (666 - 022)
• Un dossier est créé en 755 (777 - 022)

Les fichiers partent de 666 (pas 777) parce que le système ne donne jamais x par défaut à un fichier — tu dois explicitement le rendre exécutable.

Tu n'as pas besoin de modifier le umask à 42. Mais si tu vois des permissions bizarres sur des fichiers nouvellement créés, c'est probablement le umask.

Chercher

find — Chercher des fichiers par nom

• . = depuis le dossier courant
• -name "*.c" = les fichiers dont le nom finit par .c
• * = joker (n'importe quels caractères)

grep — Chercher du texte dans les fichiers

Le manuel — man

Comment ça marche

Ça ouvre une page interactive :

• Flèches haut/bas pour naviguer
• Space pour avancer d'une page
• b pour reculer d'une page
• /mot pour chercher "mot" dans la page
• n pour aller à l'occurrence suivante
• q pour quitter

Structure d'une page man

Chaque page man suit la même structure :

• NAME — le nom et une description en une ligne
• SYNOPSIS — la syntaxe de la commande (les options, les arguments)
• DESCRIPTION — l'explication détaillée
• OPTIONS — chaque option avec son explication
• EXAMPLES — des exemples d'utilisation (pas toujours présent)
• SEE ALSO — les commandes liées

Les sections du man

Le man est divisé en sections numérotées :

À 42, tu utiliseras surtout les sections 1 (commandes), 2 (appels système) et 3 (fonctions C) :

Si tu ne précises pas la section, man prend la première qu'il trouve. C'est pour ça que man printf montre la commande shell printf (section 1) et pas la fonction C printf (section 3). Pour la fonction C : man 3 printf.

Astuce

À 42, "lis le man" c'est la réponse à 90% des questions. Avant de demander à quelqu'un comment marche une commande ou une fonction, lis le man. C'est la compétence numéro un qu'on attend de toi.

Les variables d'environnement

Le shell a des variables qui stockent des informations sur ta session. On les reconnaît au $ devant leur nom.

Le PATH

Quand tu tapes ls, comment le système sait-il quel programme exécuter ? Il cherche dans les dossiers listés dans $PATH, séparés par :.

C'est pour ça que quand tu compiles un programme (gcc main.c -o a.out), tu dois l'exécuter avec ./a.out et pas juste a.out — le dossier courant (.) n'est pas dans le PATH par défaut (c'est une mesure de sécurité).

Créer et utiliser des variables

Ces variables sont locales à la session. Pour les rendre disponibles aux programmes lancés depuis le terminal :

Pour des variables permanentes, tu les mets dans ~/.zshrc (ou ~/.bashrc). Ce fichier est lu à chaque ouverture de terminal.

Raccourcis clavier essentiels

Ces raccourcis fonctionnent dans tous les shells Unix :

L'historique

Le shell garde un historique de toutes tes commandes. Tu peux :

• Appuyer sur ↑ pour remonter dans l'historique
• Taper history pour voir tout l'historique
• Taper Ctrl+R puis un mot pour chercher une commande passée
• Taper !42 pour réexécuter la commande numéro 42 de l'historique

Questionnaire