Lire et explorer des fichiers

Objectifs

À la fin de cette leçon, vous saurez :

• afficher un fichier en entier ou par morceaux avec cat, head, tail et less ;
• sélectionner des lignes avec grep, la commande que vous utiliserez toute votre vie ;
• retrouver de l'aide sans Internet : man, --help, which ;
• retrouver vos propres commandes passées grâce à l'historique.

🔗 Pour vous rafraîchir la mémoire : manipulation de fichiers (cp, mv, rm)

Préparer un terrain de jeu

Créons un petit fichier pour avoir quelque chose à lire :

$ cd ~
$ nano demo.txt

Écrivez ces six lignes, puis enregistrez (Ctrl+O, Entrée) et quittez (Ctrl+X) :

Le terminal est un dialogue.
cat affiche tout le fichier.
grep filtre les lignes.
less permet de naviguer.
tail montre la fin.
Une erreur se lit jusqu'au bout.

Vérifions immédiatement que le fichier contient bien ce qu'on croit :

$ cat demo.txt
Le terminal est un dialogue.
cat affiche tout le fichier.
grep filtre les lignes.
less permet de naviguer.
tail montre la fin.
Une erreur se lit jusqu'au bout.

cat : tout, d'un bloc

cat (concatenate) recrache le fichier entier sur la sortie standard. Pour un fichier court, c'est l'outil parfait. Son nom révèle son usage historique : concaténer — coller plusieurs fichiers bout à bout. cat a.txt b.txt affiche les deux fichiers à la suite.

Limite du geste : sur un journal de 10 000 lignes, cat défile trop vite pour être lu. Il ne faut alors pas tout afficher, mais sélectionner — c'est le rôle des commandes suivantes.

head et tail : lire par les deux bouts

$ head -n 2 demo.txt
Le terminal est un dialogue.
cat affiche tout le fichier.

$ tail -n 2 demo.txt
tail montre la fin.
Une erreur se lit jusqu'au bout.

head -n N donne les N premières lignes ; tail -n N les N dernières. Sans -n, les deux donnent 10 lignes par défaut.

Cas d'usage concret : un journal système s'allonge en permanence — les lignes nouvelles s'ajoutent à la fin. C'est donc par la fin qu'on regarde :

tail -n 20 /var/log/syslog

Et il existe mieux : tail -f (follow) ne se termine pas. Il affiche la fin puis reste en attente, en affichant chaque nouvelle ligne au fur et à mesure de son apparition — comme une fenêtre de chat qui se met à jour toute seule :

$ tail -f /var/log/syslog
Jan 12 09:30:01 cours CRON[1234]: ...
Jan 12 09:31:17 cours systemd[1]: Started Daily apt download activities...
^C

On interrompt avec Ctrl+C. Retenez ce raccourci dès maintenant : il interrompt n'importe quelle commande en cours. Vous l'utiliserez encore plus souvent que vous ne le pensez.

less : feuilleter confortablement

less /etc/services

less ouvre le fichier dans une visionneuse plein écran : rien ne défile sauvagement, vous contrôlez. Les gestes essentiels :

Touche	Effet
Espace ou Page suivante	avancer d'un écran
Flèches haut/bas	ligne par ligne
/mot	chercher « mot » vers le bas
n	occurrence suivante de la recherche
g / G	début / fin du fichier
q	quitter

Pourquoi ce nom étrange ? Historique : l'ancêtre more affichait page par page ; less fait pareil « mais mieux » (il permet notamment de remonter). Le nom est resté, la blague aussi.

Règle d'usage : cat pour court, less pour long, head/tail quand on sait où regarder.

grep : le sélecteur de lignes

grep motif fichier parcourt le fichier ligne par ligne et n'affiche que celles qui contiennent le motif :

$ grep affiche demo.txt
cat affiche tout le fichier.

C'est déjà puissant, mais les options multiplient son intérêt :

$ grep -n less demo.txt        # -n : numéro de ligne
4:less permet de naviguer.

$ grep -i TOUT demo.txt        # -i : ignore majuscules/minuscules
cat affiche tout le fichier.

$ grep -v e demo.txt           # -v : inverser (lignes SANS le motif)
Le terminal est un dialogue.

Deux réflexes professionnels :

• -n presque toujours : le numéro de ligne permet de rouvrir le fichier directement au bon endroit (dans less : tapez le numéro puis G ; dans nano : Ctrl+_).
• compter avant de plonger : grep -c compte les lignes correspondantes sans les afficher. Savoir qu'un journal contient « 412 erreurs » avant de les lire change la stratégie.

grep accepte plusieurs fichiers (grep erreur *.log) et ne modifie jamais ce qu'il lit : il est pur lecteur. Ce sera demain la pièce centrale des pipes (leçon 1-05) : filtrer la sortie d'une autre commande.

Enfin, une précision honnête : pour l'instant, le motif est un simple texte. grep sait aussi chercher des motifs complexes (expressions régulières) ; nous y reviendrons quand vous aurez accumulé assez de pratique pour en avoir besoin.

Se passer d'Internet pour obtenir de l'aide

man : le manuel intégré

man grep

Chaque commande sérieuse installe sa page de manuel. C'est une référence complète, hors connexion, organisée en sections. Les deux premières suffisent au quotidien :

• NAME : ce que fait la commande, en une phrase ;
• SYNOPSIS : la grammaire d'appel, avec conventions d'écriture : grep [OPTION]... MOTIF [FICHIER]... se lit « options facultatives, puis un motif obligatoire, puis des fichiers facultatifs » ; les crochets [...] marquent le facultatif, les points de suspension « répétable ».

La navigation est celle de less (même technologie) : espace pour avancer, /mot pour chercher dans la page, q pour sortir. Cherchez par exemple /recursive dans man cp.

--help : le résumé express

$ grep --help
Utilisation : grep [OPTION]... MOTIF [FICHIER]...
Recherche MOTIF dans chaque FICHIER...
...

Plus court que le manuel, souvent traduit, idéal pour vérifier une option dont on a oublié le sens exact. Réflexe conseillé : --help d'abord, man si besoin de profondeur.

which : où est installé ce programme ?

$ which grep
/usr/bin/grep

$ which nodejs-inexistant
$

which répond par le chemin complet de l'exécutable trouvé — ou ne dit rien (et rend une erreur) si le programme n'existe pas ou n'est pas accessible. Utile pour diagnostiquer « commande introuvable » : si which node ne répond rien, le problème n'est pas votre frappe, c'est l'installation.

Retrouver ses commandes passées

Le shell mémorise vos commandes. Trois façons d'en profiter :

Flèches haut/bas : remonter et redescendre dans l'historique récent. Le réflexe le plus utilisé de tous.

La commande history :

$ history
  501  cd ~
  502  nano demo.txt
  503  cat demo.txt
  504  grep -n less demo.txt

Chaque ligne porte un numéro. Relancer la commande 502 sans la retaper : !502. Relancer la dernière : !!.

La recherche incrémentale Ctrl+R : appuyez sur Ctrl+R puis tapez un fragment (« grep ») : le shell rappelle immédiatement la dernière commande contenant ce fragment. Répétez Ctrl+R pour remonter aux occurrences précédentes, Entrée pour relancer, flèche droite pour éditer avant de lancer.

Ce mécanisme explique pourquoi les développeurs ne retapent jamais leurs longues commandes du matin : elles sont là, à trois touches. Et il annonce la suite du cursus : ce que vous tapez aujourd'hui à la main, vous le mettrez bientôt dans des scripts pour l'automatiser.

Exercice

1. Recherchez toutes les mentions de « erreurs » dans demo.txt.
2. Affichez les 3 premières lignes de /etc/hosts.
3. Comptez combien de lignes de /etc/services contiennent « http », sans afficher ces lignes.
4. Ouvrez /etc/services dans less, cherchez-y « domain », quittez.
5. Trouvez le chemin de curl avec which, puis affichez le début de son aide avec --help (les premières lignes suffisent — quelle commande pour limiter l'affichage ?).
6. Avec l'historique, relancez la commande de la question 2 sans la retaper.

Résumé

• cat pour court, less pour long (espace, /recherche, q), head/tail pour cibler les bouts, tail -f pour suivre un journal vivant (Ctrl+C pour couper).
• grep motif sélectionne des lignes ; -n ajoute les numéros, -i ignore la casse, -c compte, -v inverse.
• man documente en profondeur (SYNOPSIS = grammaire), --help résume, which localise.
• L'historique (flèches, history, Ctrl+R) fait gagner du temps tous les jours.

grep erreurs demo.txt

$ head -n 3 /etc/hosts
127.0.0.1       localhost
127.0.1.1       cours
::1     localhost ip6-localhost ip6-loopback

$ grep -c http /etc/services
62

less /etc/services
/domain      # cherche la première occurrence
n            # occurrence suivante, autant de fois que voulu
q            # sortie

$ which curl
/usr/bin/curl
$ curl --help | head -n 10
Usage: curl [options...] <url>
...