glossaire-linux

Contenu et recherche

Afficher, parcourir, rechercher et traiter le contenu textuel des fichiers. cat, less, grep, find, awk, sed, sort/uniq, diff... — le cœur du toolkit Unix pour la donnée texte.

Afficher le contenu

Quatre commandes selon la taille et l'usage : cat tout, less page par page, head/tail les extrémités.

cat

Afficher (ou concaténer) le contenu de fichiers

cat (concatenate) déverse le contenu d'un ou plusieurs fichiers sur la sortie standard. Idéal pour les fichiers courts. Pour les longs, préférez less.

Options utiles

-nNumérote toutes les lignes.
-bNumérote uniquement les lignes non vides.
-AAffiche tous les caractères, y compris invisibles (tabulations, fins de ligne).
-sCompresse les lignes vides successives en une seule.
$ cat /etc/hostname
Affiche le nom de la machine.
$ cat tete.txt corps.txt pied.txt > complet.txt
Concatène trois fichiers dans un nouveau (l'usage d'origine de la commande).
$ cat -n script.sh | head -20
Affiche les 20 premières lignes numérotées d'un script — utile pour pointer un numéro de ligne.

Voir aussi : less head tail

less

Lire un fichier page par page (pager)

Pour les fichiers volumineux, less ouvre un mode lecture où vous pouvez naviguer sans charger tout en mémoire. C'est aussi le pager utilisé par man.

Raccourcis dans less

Espace / bPage suivante / précédente.
↓ ↑Ligne par ligne.
g / GAller au début / à la fin du fichier.
/motifRecherche en avant. n = suivant, N = précédent.
?motifRecherche en arrière.
FSuit le fichier en temps réel (comme tail -f).
qQuitter.
$ less /var/log/syslog
Ouvre le syslog en mode pager. Tapez /error pour aller à la première occurrence.
$ dmesg | less
less accepte aussi un flux d'entrée standard.

head

Afficher le début d'un fichier

Par défaut, head affiche les 10 premières lignes.

Options

-n NAffiche les N premières lignes (ex. -n 25).
-c NAffiche les N premiers octets.
-qNe montre pas l'en-tête de fichier (utile avec plusieurs fichiers).
$ head -n 5 /etc/passwd
Les 5 premiers comptes système.
$ head -c 500 binaire.dat | xxd
Inspecter les 500 premiers octets d'un fichier binaire en hexadécimal.

tail

Afficher la fin d'un fichier (et la suivre en temps réel)

Symétrique de head. Mais avec -f (follow), elle continue d'afficher les nouvelles lignes au fur et à mesure qu'elles sont écrites — l'outil indispensable pour surveiller des logs.

Options

-n NAffiche les N dernières lignes.
-fSuit le fichier (rafraîchissement temps réel).
-FComme -f, mais reprend automatiquement si le fichier est tourné/recréé (logrotate).
$ tail -n 50 /var/log/nginx/access.log
Les 50 dernières requêtes du serveur web.
$ tail -F /var/log/syslog
Surveille le syslog en continu, même après une rotation des logs. Quitter avec Ctrl+C.
$ tail -f app.log | grep --line-buffered ERROR
Suit le fichier et n'affiche que les lignes contenant ERROR.

Traiter le texte

Compter, trier, dédupliquer.

wc

Compter lignes, mots et octets

Options

-lCompte les sauts de ligne ; une dernière ligne sans saut final n’ajoute pas un au compteur.
-wCompte les mots.
-cCompte les octets.
-mCompte les caractères (utile pour l'UTF-8).
$ wc -l *.py
Nombre de lignes dans chaque fichier Python du dossier.
$ grep ERROR app.log | wc -l
Combien d'erreurs dans le log.

sort

Trier les lignes d'un flux

Options

-nTri numérique (sinon alphabétique).
-rInverse l'ordre.
-hTri humain (1K, 2M, 3G…).
-k NCommence la clé au champ N et la poursuit jusqu’à la fin de la ligne. Utiliser -k N,N pour limiter la clé au seul champ N.
-uÉlimine les doublons.
-t SEPDéfinit le séparateur de colonnes.
$ sort noms.txt
Tri alphabétique simple.
$ du -h * | sort -hr | head
Top des plus gros éléments du dossier courant.
$ sort -t: -k3 -n /etc/passwd
Trie /etc/passwd par UID (3ᵉ champ, séparateur :).

uniq

Filtrer les doublons consécutifs

uniq ne détecte que les doublons adjacents. En pratique on l'enchaîne presque toujours après un sort.

Options

-cPréfixe chaque ligne par son nombre d'occurrences.
-dN'affiche que les doublons.
-iIgnore la casse.
$ sort access.log | awk '{print $1}' | sort | uniq -c | sort -rn | head
Idiome classique : top 10 des IP les plus présentes dans un log d'accès web.
$ awk '{print $9}' access.log | sort | uniq -c | sort -rn
82451 200
 3128 304
  412 404
   27 500
    8 503
Distribution des codes de réponse HTTP. Pattern type pour repérer une dérive : voir d'un coup d'œil que les 5xx augmentent avant qu'un utilisateur ne signale.
$ sort -u liste1.txt liste2.txt > fusion.txt
Pour de la déduplication simple, sort -u fait le même travail que sort | uniq mais en un seul processus — un peu plus rapide et plus concis.
$ grep ERROR app.log | awk '{print $4}' | sort | uniq -c | sort -rn
Top des messages d'erreur par fréquence. $4 à adapter selon la position de la classe d'erreur dans le format de log. Pour un audit, on commence presque toujours par regarder ce qui domine cette liste.

awk

Langage compact pour traiter des fichiers structurés en colonnes

awk est un mini-langage orienté « motif → action ». Il découpe automatiquement chaque ligne en champs (par défaut sur les espaces) et exécute le bloc d'action sur les lignes qui correspondent au motif. Idéal pour extraire, filtrer ou agréger des colonnes sans écrire de boucle Bash.

Syntaxe

awk 'motif { action }' fichier
awk -F: '{print $1}' /etc/passwd
# CSV simple sans virgules dans les champs ; ignorer la ligne d’en-tête
awk -F, 'NR>1 {sum+=$2; n++} END {if (n) print "moyenne:", sum/n; else print "aucune donnee"}' data.csv

Variables intégrées

$0Ligne entière.
$1 … $NChamps (1-indexés).
NFNombre de champs sur la ligne courante. $NF = dernier champ.
NRNuméro de la ligne courante (à partir de 1).
FS / OFSSéparateur d'entrée / de sortie. Par défaut espace/espace.
BEGIN / ENDBlocs exécutés une fois avant et après le parcours.
$ awk -F: '$3 >= 1000 {print $1, $6}' /etc/passwd
Liste les comptes d'UID supérieur ou égal à 1000 avec leur répertoire personnel ; cela peut inclure nobody et des comptes techniques. -F: dit à awk de découper sur :, le filtre $3 >= 1000 applique un seuil courant, dépendant de la distribution, sans garantir des comptes humains, et l'action affiche colonnes 1 (login) et 6 (home).
$ awk '{sum+=$1} END {if (NR) print "total:", sum, "moy:", sum/NR; else print "aucune donnee"}' nombres.txt
Somme et moyenne d’une colonne numérique. Le test NR protège la division lorsque le fichier est vide ; les lignes doivent contenir les nombres attendus.
$ ps aux | awk 'NR==1 || /nginx/'
Garde l'en-tête (NR==1) puis les lignes contenant « nginx ». Plus propre que grep nginx qui jetterait l'en-tête.
Astuce : dès qu'un pipe combine grep | cut ou grep | sed | sort, un seul awk bien écrit fait souvent le même travail plus lisiblement et plus vite (un seul processus au lieu de trois).

Voir aussi : sed cut grep

sed

Éditeur de flux : transformer du texte ligne par ligne

sed applique une suite de commandes (substitution, suppression, insertion, impression sélective) à un flux de texte. Travaille ligne par ligne, gère les regex POSIX (-E pour les regex étendues). Couteau suisse pour les retouches rapides et le find-and-replace.

Syntaxe

sed 'expression' fichier            # affiche le résultat sur stdout
sed -i 'expression' fichier         # modifie le fichier en place
sed -E 'expression' fichier         # regex étendues (+, ?, |, ()...)
sed -n '10,20p' fichier             # n'affiche QUE les lignes 10 à 20

Commandes courantes

s/avant/apres/Substitution. Ajouter g pour toutes les occurrences sur la ligne.
Nd / N,MdSupprimer la ligne N (ou la plage N à M).
Np / N,MpImprimer (utile avec -n pour ne garder que celles-ci).
/motif/dSupprimer toutes les lignes qui matchent le motif.
$ sed -i.bak 's/localhost/example.test/g' config.ini
Remplace toutes les occurrences (flag g) de localhost par example.test dans le fichier, en sauvegardant l'original sous config.ini.bak. Le suffixe après -i donne la sécurité d'un rollback.
$ sed -n '/^ERROR/,/^---/p' app.log
Affiche tous les blocs entre une ligne commençant par ERROR et la prochaine ligne de séparateurs ---. Pratique pour extraire des sections d'un log.
$ sed '/^#/d; /^$/d' config.conf
Filtre commentaires (^#) et lignes vides (^$). Le ; sépare deux commandes sed. Idéal pour voir la « vraie » config sans le bruit.
Choisir un autre délimiteur que / quand le motif contient des slashes : sed 's|/var/log|/srv/log|g' évite d'échapper chaque /. N'importe quel caractère après s fait l'affaire.

Voir aussi : awk grep tr

cut

Extraire des colonnes ou des octets de chaque ligne

Outil minimaliste pour découper. Trois modes : par champ (-f) avec un séparateur, par caractère (-c), ou par octet (-b). Plus simple qu'awk quand il s'agit juste d'extraire une colonne.

Options

-d XDélimiteur de champ (un caractère, défaut TAB).
-f LISTEListe de champs : 1, 1,3, 2-5, 3- (du 3e à la fin).
-c LISTESélection par caractères avec les versions qui prennent en charge le multioctet dans la locale utilisée. D’anciennes versions de GNU cut traitent -c comme une sélection d’octets, alors que les versions récentes et certaines versions corrigées par les distributions gèrent UTF-8. Un caractère Unicode n’est pas forcément un graphème visible complet : tester les accents combinés et la version installée.
--complementInverse la sélection (garde tout sauf).
$ cut -d: -f1 /etc/passwd
Liste tous les noms d'utilisateurs (premier champ délimité par :). Une ligne d'awk ferait pareil mais cut est plus rapide à taper pour ce genre de tâche.
$ cut -d, -f2,5 ventes.csv
Extrait les colonnes 2 et 5 d'un CSV. Limite : cut ne gère pas les virgules échappées dans les champs entre guillemets. Pour du « vrai » CSV, préférer un outil dédié comme csvkit.
$ who | cut -c1-12
N'affiche que les 12 premiers caractères de chaque ligne — utile quand on connaît la largeur fixe d'une colonne (ici les noms d'utilisateurs).
Limite : cut ne sait pas gérer les séparateurs multiples (par exemple plusieurs espaces consécutifs comptent comme plusieurs séparateurs). Pour ls -l ou toute sortie alignée par espaces, préférer awk qui condense les espaces.

Voir aussi : awk paste tr

tr

Substituer, supprimer ou compresser des caractères

tr traduit, supprime ou comprime des éléments de son entrée standard. Les exemples ASCII sont prévisibles ; GNU tr ne gère pas complètement les caractères multioctets, donc ne pas l’utiliser comme transformateur Unicode général. Passer le contenu par stdin, avec une redirection ou un pipe.

Syntaxe

tr SRC DST                  # substitution caractere par caractere
tr -d CHARS                 # supprime tous les CHARS
tr -s CHARS                 # compresse les repetitions de CHARS
tr -c SRC DST               # complement : agit sur tout SAUF SRC
$ echo "Hello World" | tr 'A-Za-z' 'N-ZA-Mn-za-m'
Uryyb Jbeyq
ROT13. tr mappe chaque caractère du premier ensemble vers le caractère correspondant du second. Les classes A-Z et a-z sont étendues comme on s'y attend.
$ tr -d '\r' < windows.txt > unix.txt
Convertit un fichier avec fins de ligne CRLF (Windows) en LF (Unix) en supprimant les \r. Alternative à dos2unix qui n'est pas toujours installé.
$ echo "trop    d   espaces" | tr -s ' '
trop d espaces
-s (squeeze) compresse toute série d'espaces en un seul. Très utile pour normaliser une sortie avant cut.

Voir aussi : sed cut

paste

Coller plusieurs fichiers côte à côte, ligne par ligne

Inverse de cut : paste prend N fichiers et concatène leurs lignes correspondantes, séparées par un caractère (TAB par défaut). Avec -s, joint toutes les lignes d'un même fichier en une seule.

Options

-d XDélimiteur entre les colonnes (défaut TAB). Plusieurs caractères = utilisés cycliquement.
-sMode serial : joint toutes les lignes d'un même fichier sur une ligne.
$ paste -d, noms.txt emails.txt
Fusionne deux fichiers en CSV : la première ligne de noms.txt est jointe à la première ligne de emails.txt par une virgule, et ainsi de suite.
$ paste -s -d, items.txt
pomme,poire,banane,kiwi
Avec -s, on aplatit un fichier multi-lignes en une seule ligne séparée par des virgules. Utile pour construire des listes pour SQL IN (...) ou des arguments de commande.

Voir aussi : cut sort tee

diff · patch

Comparer deux fichiers (ou arborescences) et appliquer la différence

diff compare deux fichiers. Avec -u, il produit un diff unifié enregistrable puis applicable avec patch. Sans -u, le format de sortie par défaut est différent. Un code de sortie 1 signifie que des différences ont été trouvées, pas une erreur d’exécution ; 0 indique des fichiers identiques et une valeur supérieure à 1 un problème.

Options principales

-uFormat unifié (3 lignes de contexte). Le format standard.
-rRécursif sur deux répertoires.
-NConsidère les fichiers absents comme vides (utile avec -r).
-w / -BIgnore les espaces / lignes vides.
--color=autoCouleurs si stdout est un terminal.
(patch) -p NStrip N premiers composants des chemins du diff (typiquement -p1 pour les patchs git).
(patch) -RReverse : applique le patch à l'envers.
$ diff -u config.old config.new
--- config.old
+++ config.new
@@ -3,3 +3,3 @@
 listen_address = 0.0.0.0
-max_connections = 100
+max_connections = 500
 timeout = 30s
Format unifié classique : - avant la ligne d'origine, + avant la nouvelle. C'est ce qu'on retrouve dans git diff.
$ diff -ruN ancien/ nouveau/ > mon-correctif.patch
Génère un patch entre deux arborescences. -N traite un fichier absent comme vide et permet d’inclure son ajout ou sa suppression ; sans -N, diff signale sa présence dans un seul répertoire sans produire son contenu comme patch.
$ cd projet/ && patch -p1 < ../mon-correctif.patch
Applique le patch. -p1 retire le premier composant des chemins du diff (ancien/foo devient foo) — c'est la valeur typique pour les patchs git formatés à la racine d'un repo.
$ patch -p1 -R < ../mon-correctif.patch
Depuis projet/, annule le patch de l’exemple précédent avec -R ; le fichier patch reste dans le répertoire parent. Vérifier d’abord avec --dry-run, notamment si les fichiers ont été modifiés depuis son application.

Voir aussi : grep <(cmd)

xxd · strings · hexdump

Inspecter le contenu binaire d'un fichier

xxd affiche un dump hexadécimal et sait le reconvertir en binaire ; strings extrait les suites imprimables ; hexdump propose d’autres formats, dont hexdump -C. Leur présence dépend des paquets installés ; od est une alternative courante.

$ xxd /usr/bin/ls | head -3
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000  .ELF............
00000010: 0300 3e00 0100 0000 1064 0000 0000 0000  ..>......d......
00000020: 4000 0000 0000 0000 4845 0200 0000 0000  @.......HE......
Les 4 premiers octets 7f 45 4c 46 = .ELF, signature des binaires Linux. xxd est l'outil pour vérifier rapidement le type d'un fichier ou inspecter un protocole binaire.
$ strings /usr/bin/ls | grep -i 'usage'
strings extrait toutes les séquences ASCII imprimables d'au moins 4 caractères. Pratique pour deviner les options ou messages d'un binaire dont on n'a pas le source — souvent utilisé en analyse de malware.
$ echo "Hello" | xxd
00000000: 4865 6c6c 6f0a                           Hello.
Voir littéralement les octets envoyés. Le 0a en fin = saut de ligne (LF). Indispensable pour déboguer un fichier qui contient un BOM, des CRLF Windows ou des caractères invisibles.
$ xxd -r dump.hex > restored.bin
-r (reverse) reconstitue le binaire depuis le dump hex. Permet d'éditer un binaire à la main : xxd file > dump, modifier dump avec un éditeur texte, xxd -r dump > file_modifié.
Cousins utiles : od -c (octal dump) montre les caractères avec échappements ASCII — complémentaire de xxd. file (page Fichiers) reconnaît le type sans descendre au niveau octet.

Voir aussi : file grep