Tubes et redirection sous Linux : traiter du texte

Les fichiers courts sont faciles à afficher. Les fichiers longs sont plus faciles à lire lorsque l’affichage attend ton intervention. Ni cat ni la vue de lecture normale de less ne modifient le fichier.

Afficher ou réunir du texte avec cat

cat notes.txt envoie le fichier entier vers la sortie standard, normalement ton terminal. Son nom vient de concatenate : avec plusieurs noms de fichiers, il affiche leur contenu dans l’ordre indiqué. Il n’insère pas d’en-tête entre les fichiers.

Supposons que a.txt contient les lignes « a » et « b », et que b.txt contient « c d ». Exécute :

cat -n a.txt b.txt

Tu vois trois lignes numérotées. La numérotation se poursuit d’un fichier à l’autre ; -n numérote la sortie, pas les fichiers enregistrés. Pour enregistrer le texte réuni, utilise cat a.txt b.txt > ab.txt. Le nouveau fichier contient les trois lignes d’origine sans numérotation. Ajouter -n enregistrerait aussi les numéros.

L’affichage d’un grand fichier peut pousser son début hors de la partie visible de l’écran. Un pageur te laisse contrôler l’affichage. less /etc/services ouvre un long fichier texte et en affiche un écran. Il peut afficher le premier écran avant d’avoir lu tout le fichier, ce qui est utile pour les fichiers volumineux.

Se déplacer dans less

L’invite de commande est masquée pendant l’exécution de less. Le programme attend une touche de navigation :

La casse compte : g et G vont aux extrémités opposées. Pour terminer la lecture, appuie sur q ; attendre une nouvelle invite sans quitter peut donner l’impression que le pageur est bloqué.

Rechercher dans le texte affiché

Saisis /, entre un mot et appuie sur Entrée pour chercher vers l’avant. Par exemple, /ssh trouve le texte correspondant suivant. Saisis ?ssh puis Entrée pour chercher vers l’arrière. Ensuite, n répète la recherche dans son sens actuel, tandis que N cherche dans le sens opposé. Après une recherche vers l’arrière, n continue donc vers l’arrière.

La recherche utilise une expression régulière. /^# trouve une ligne commençant par « # », car ^ marque le début d’une ligne. Tu peux apprendre séparément les règles des motifs tout en utilisant dès maintenant des mots simples.

less -N notes.txt ajoute les numéros de ligne à l’affichage. Pour les enregistrements larges, less -S notes.txt garde une ligne longue sur une seule ligne d’écran en coupant sa partie droite visible ; les flèches gauche et droite permettent de se déplacer horizontalement. Le texte reste dans le fichier. Sans -S, les lignes longues se poursuivent sur d’autres lignes d’écran. more est un pageur plus ancien qui offre moins de possibilités de navigation.

Parcourir la sortie d’une autre commande

ls -l /usr/bin | less te permet de parcourir la longue liste. Le tube transmet la liste au pageur. Pour un fichier existant, less notes.txt l’ouvre directement ; cat notes.txt | less ajoute une commande pour obtenir le même affichage.

Utilise ces commandes sur du texte. L’affichage d’un programme binaire comme /bin/ls peut montrer des caractères de contrôle et brouiller le terminal. Si cela se produit, saisis reset et appuie sur Entrée pour rétablir l’affichage.

Lorsque tu n’as besoin que des premières ou des dernières entrées d’un fichier, tout afficher masque la partie utile. head sélectionne le début et tail la fin. Tous deux affichent 10 lignes par défaut.

Choisir un nombre de lignes

Si numbers.txt contient les nombres de 1 à 100, un par ligne, head numbers.txt affiche de 1 à 10, tandis que tail numbers.txt affiche de 91 à 100. Utilise -n pour changer le nombre :

head -n 3 numbers.txt
tail -n 3 numbers.txt

La première commande affiche 1, 2, 3. La seconde affiche 98, 99, 100. Si un fichier contient moins de lignes que demandé, la commande affiche celles qui sont disponibles.

head -c 5 sélectionne cinq octets au lieu de cinq lignes. Pour un texte qui commence par « banana », il affiche « banan ». Les octets sont des unités de stockage ; en UTF-8, un caractère peut occuper plus d’un octet, donc un nombre d’octets ne correspond pas toujours à un nombre de caractères.

Lire correctement une position de départ

Un signe plus change le sens de tail -n. Compare :

tail -n +2 scores.csv retire la première ligne, ce qui est utile lorsqu’elle contient des en-têtes de colonnes. Il ne sélectionne pas seulement la deuxième ligne. Sur le fichier numéroté, tail -n +98 numbers.txt affiche de 98 à 100.

La version GNU de head accepte aussi un nombre négatif : head -n -97 numbers.txt omet les 97 dernières lignes et laisse de 1 à 3. Le signe fait partie du nombre et de l’instruction.

Sélectionner une plage au milieu

Pour afficher les lignes 11 à 20, conserve d’abord tout jusqu’à la ligne 20. Puis conserve les 10 dernières lignes de cette sélection :

head -n 20 numbers.txt | tail -n 10

Après head, les données vont de 1 à 20. Les dix dernières lignes vont de 11 à 20. Une plage qui inclut ses deux extrémités contient un nombre de lignes égal au numéro de fin moins le numéro de début plus un ; ce dernier un tient compte de l’inclusion des deux extrémités. Utiliser tail -n 11 inclurait aussi la ligne 10.

Les deux commandes peuvent lire un tube lorsqu’aucun fichier d’entrée n’est indiqué. ls /etc | head -n 5 limite une liste à ses cinq premiers noms. Avec ls -lt | head -n 4, rappelle-toi que la première ligne de sortie est la ligne « total » : seules trois entrées la suivent.

Observer un fichier qui s’allonge

tail -f /var/log/app.log affiche d’abord les dernières lignes, puis attend et affiche le texte ajouté au fichier. Utilise cette commande pendant qu’un programme écrit de nouvelles entrées. Appuie sur Ctrl+C pour arrêter le suivi et revenir au shell. Cette attente est voulue ; elle diffère de la sortie unique et achevée de tail utilisé seul.

tail -F réessaie aussi et continue à suivre le nom du fichier lorsqu’un journal est supprimé puis recréé lors d’une rotation. Avec plusieurs fichiers d’entrée, head et tail indiquent la sortie de chaque fichier par un en-tête tel que « ==> fruit.txt <== ». Ajoute -q lorsque tu as besoin du texte sélectionné sans ces en-têtes.

Une commande communique par des flux standard. Considérer l’entrée et la sortie comme des voies distinctes permet de comprendre comment un même programme peut lire le clavier, lire un fichier ou recevoir la sortie d’une autre commande.

Identifier les trois flux

Un descripteur de fichier est le numéro utilisé pour identifier un flux ouvert. Une commande ordinaire du shell hérite de ces trois flux :

Bien que stdout et stderr partagent normalement l’écran, ce sont des connexions distinctes. Un programme peut fournir un résultat sur stdout et expliquer un problème sur stderr au cours d’une même exécution.

Par exemple, ls /etc/hostname /nonexistent > out.txt liste un chemin existant et rencontre un chemin absent. La liste va dans out.txt. Le message « No such file or directory » reste dans le terminal, car > redirige stdout, pas stderr. Voir une erreur à l’écran ne signifie pas que la redirection de sortie a échoué.

Fournir l’entrée d’une commande depuis un fichier

Des commandes comme cat, sort, wc, grep, head et tail peuvent lire stdin lorsqu’aucun fichier d’entrée n’est indiqué. Exécute sort seul, saisis quelques lignes et appuie sur Ctrl+D au début d’une ligne vide. Cela signale la fin de l’entrée et permet à sort d’afficher les lignes triées. Ctrl+C arrête la commande au lieu de terminer l’entrée.

L’opérateur d’entrée < relie un fichier à stdin :

wc -l < fruit.txt

Si fruit.txt contient six lignes terminées par un saut de ligne, la sortie est « 6 ». Compare avec wc -l fruit.txt, qui affiche « 6 fruit.txt ». Dans la forme avec redirection, le shell ouvre le fichier et wc reçoit un flux sans le nom du fichier d’origine. Dans la forme avec argument, wc ouvre lui-même le fichier indiqué.

Le shell prépare les redirections avant de démarrer le programme. sort < fruit.txt et < fruit.txt sort relient donc le même fichier au même flux d’entrée. Le placement habituel après la commande est plus facile à lire.

Fournir directement quelques lignes

Un document en ligne place l’entrée sous la commande. Le mot après << marque la fin de cette entrée :

cat <<EOF > greeting.txt
Hello
See you soon
EOF

cat reçoit les deux lignes de salutation sur stdin et les écrit dans le fichier de sortie. La dernière ligne contient seulement EOF ; c’est un délimiteur, pas une partie du texte enregistré. Un autre mot peut servir de délimiteur si la ligne de fermeture lui correspond exactement.

Dans Bash, une chaîne en ligne fournit une chaîne suivie d’un saut de ligne. wc -w <<< "a b c" indique trois mots. Ces deux formes fournissent directement une entrée sans créer d’abord un fichier d’entrée.

Lire la flèche avant d’exécuter la commande

sort < fruit.txt lit le fichier. sort > fruit.txt l’ouvre comme destination de sortie, vide son contenu existant et attend une entrée au clavier. Le shell effectue cette ouverture destructive avant l’exécution de sort. Garde les fichiers d’entrée distincts des destinations de sortie, sauf si la commande dispose d’une méthode documentée pour mettre à jour son entrée en toute sécurité.

La redirection change la destination d’un flux. C’est une opération du shell : les mêmes opérateurs fonctionnent donc avec de nombreux programmes. Commence par déterminer quel flux envoyer et s’il faut remplacer ou compléter un fichier existant.

Enregistrer les résultats normaux ou les ajouter en fin de fichier

echo one > log.txt crée le fichier ou le vide avant d’y écrire la ligne « one ». Un echo two >> log.txt exécuté ensuite ajoute « two » à la fin, ce qui donne deux lignes. >> crée aussi le fichier s’il n’existe pas.

ls /etc/hostname /nonexistent > out.txt 2> err.txt sépare la liste obtenue du message d’erreur concernant le chemin absent. Le descripteur doit toucher l’opérateur. ls 2> err.txt redirige les erreurs ; ls 2 > err.txt demande à ls de lister un fichier nommé « 2 » et redirige sa sortie normale.

Regrouper les flux dans le bon ordre

2>&1 dirige stderr vers la destination actuelle de stdout. Lis les redirections de gauche à droite :

ls /etc/hostname /nonexistent > all.txt 2>&1

D’abord, stdout est dirigé vers all.txt. Ensuite, stderr copie cette connexion. Les deux flux arrivent maintenant dans le fichier. &> all.txt est une forme plus courte proposée par Bash, et &>> all.txt ajoute les deux flux en fin de fichier.

Inverser l’ordre change le résultat :

ls /etc/hostname /nonexistent 2>&1 > out.txt

D’abord, stderr est dirigé là où va actuellement stdout : le terminal. Ensuite, stdout est dirigé vers le fichier. Stderr conserve la connexion précédente, donc l’erreur reste visible. 2>&1 établit une connexion à cet instant ; il ne fait pas suivre à stderr tous les changements ultérieurs de stdout.

Éliminer volontairement un flux

/dev/null élimine les données qui y sont écrites. find / -name passwd 2>/dev/null laisse les chemins correspondants sur stdout tout en masquant les messages de diagnostic tels que « Permission denied ». Ces messages peuvent indiquer des répertoires non explorés : les éliminer supprime donc aussi des informations sur les parties non couvertes par la recherche.

Protéger un fichier d’entrée

N’écris pas sort fruit.txt > fruit.txt. Le shell vide la destination avant que sort ne la lise. Utilise un autre chemin de sortie, vérifie le résultat, puis renomme le fichier. Pour sort en particulier, sort -o fruit.txt fruit.txt utilise l’option prévue pour le fichier de sortie afin de mettre à jour ce fichier en toute sécurité.

Bash peut aussi refuser l’écrasement accidentel :

set -o noclobber

Avec ce réglage, > ordinaire échoue pour un fichier ordinaire existant. >> ajoute toujours en fin de fichier. Utilise >| pour un écrasement volontaire, ou set +o noclobber pour désactiver le réglage. Cette protection est utile pour enregistrer des rapports répétés, mais elle ne modifie pas les options d’écriture de fichiers propres à une commande.

Un tube, noté |, relie la sortie normale d’une commande à l’entrée de la suivante. Tu peux relier plusieurs petites opérations sans enregistrer de fichier temporaire entre elles.

Suivre le flux du texte

Dans ls /etc | wc -l, ls écrit les noms et wc -l compte les caractères de saut de ligne reçus. Une commande qui lit stdin, sélectionne ou modifie du texte et écrit sur stdout s’appelle un filtre. sort, uniq, wc, cut, grep, head et tail peuvent tous servir de filtres.

La forme générale est command1 | command2 | command3. Chaque étape reçoit la sortie de l’étape précédente, qui peut avoir une forme différente de celle du fichier d’origine. Une étape ultérieure ne peut pas récupérer les lignes ou les colonnes supprimées par une étape précédente.

Construire un comptage par étapes

Supposons que fruit.txt contient six lignes : « banana », « apple », « cherry », « apple », « banana », « apple ». Pour compter les noms différents, exécute d’abord :

sort fruit.txt

La sortie contient trois lignes « apple », deux lignes « banana » et une ligne « cherry ». Les noms identiques sont maintenant côte à côte. Ajoute une étape :

sort fruit.txt | uniq

uniq supprime les répétitions adjacentes et laisse « apple », « banana » et « cherry ». Enfin, sort fruit.txt | uniq | wc -l indique 3. Compter directement le fichier d’origine donnerait six lignes, ce qui répond à une autre question.

Exécute le pipeline à chaque ajout et examine son résultat avant d’ajouter la commande suivante. Pour une sortie très longue, ajoute temporairement | head afin de voir les dix premières lignes. Il est ainsi plus facile de repérer un en-tête qui n’a pas été retiré ou un champ mal sélectionné.

Garder les erreurs séparées

Un tube ordinaire transporte stdout, pas stderr. Avec un chemin existant et un chemin absent, ls /etc/hostname /nonexistent | wc -l compte l’unique ligne de liste normale. L’erreur apparaît toujours dans le terminal.

Pour inclure les messages de diagnostic dans les données, utilise ls /etc/hostname /nonexistent 2>&1 | wc -l, qui compte deux lignes dans cet exemple. |& dans Bash combine aussi stdout et stderr dans le tube. L’intérêt d’inclure les erreurs dépend du sens que tu veux donner au décompte final.

Les étapes s’exécutent simultanément. tail -f /var/log/app.log | grep ERROR affiche dans le terminal les nouvelles lignes ajoutées qui correspondent au motif. C’est un affichage en direct, pas un processus qui attend la fin du fichier. Les programmes peuvent toutefois mettre leur sortie en mémoire tampon ; l’affichage immédiat n’est donc pas garanti pour tous les pipelines.

Enregistrer une copie en cours de route

tee écrit son entrée à la fois dans un fichier et sur stdout :

sort fruit.txt | uniq | tee unique.txt | wc -l

Le terminal affiche 3, tandis que unique.txt stocke les trois noms. tee -a ajoute à la fin du fichier enregistré au lieu de le remplacer. Placer tee plus tôt enregistrerait une forme antérieure des données.

Un tube se connecte à une commande, tandis que > désigne un fichier. ls > less crée un fichier nommé « less » ; il ne lance pas le pageur. La commande réceptrice doit aussi lire stdin : transmettre du texte à echo ou à ls par un tube ne transforme pas ce texte en arguments.

Compter et trier sont des opérations distinctes. Avant d’utiliser un décompte, détermine si tu as besoin du nombre d’enregistrements, de mots, d’octets ou de valeurs distinctes. Avant de supprimer les doublons, vérifie si les lignes identiques sont déjà côte à côte.

Compter ce qu’il faut avec wc

wc file utilisé seul indique le nombre de lignes, de mots et d’octets, dans cet ordre, puis le nom du fichier. La liste de six lignes contenant « banana », « apple », « cherry », « apple », « banana », « apple » donne « 6 6 39 fruit.txt ». Chaque ligne contribue au total avec ses lettres et un octet de saut de ligne.

Un dernier fragment de texte sans saut de ligne n’est pas compté par wc -l. Un texte contenant « one », un saut de ligne puis « two » donne donc un décompte de 1. En UTF-8, « café » suivi d’un saut de ligne occupe six octets mais compte cinq caractères, car « é » occupe deux octets. Avec plusieurs fichiers d’entrée, wc affiche leurs décomptes et un total supplémentaire.

Choisir un tri textuel ou numérique

sort écrit les lignes triées sans modifier le fichier d’entrée. Son ordre par défaut suit les paramètres régionaux actifs. sort -f compare sans distinguer les majuscules des minuscules.

Le tri textuel compare les caractères : « 100 », « 25 », « 9 » apparaissent dans cet ordre, car leurs premiers chiffres sont « 1 », « 2 », « 9 ». sort -n compare les valeurs numériques et donne 9, 25, 100. Ajoute -r pour inverser l’ordre, comme dans sort -rn. sort -h comprend les suffixes de taille tels que « 2K », « 300M » et « 1G ».

Trier selon un champ

Pour des enregistrements séparés par des virgules, -t, définit le séparateur. -k3,3nr sélectionne seulement le champ 3, compare les valeurs numériquement et inverse l’ordre :

tail -n +2 scores.csv | sort -t, -k3,3nr | head -n 3

Avec « name,city,score » suivi de « Ana,Lisbon,82 », « Ben,Oslo,75 », « Chen,Lisbon,91 », « Dara,Oslo,68 » et « Eli,Lisbon,88 », le résultat donne Chen, Eli, puis Ana avec leurs enregistrements complets. La première étape retire l’en-tête. Sans cela, sa clé de score non numérique compte pour zéro lors du tri numérique.

Sans -t, des espaces ou des tabulations séparent les champs. -k2 étend la clé du champ 2 jusqu’à la fin de la ligne ; -k2,2 la limite au champ 2.

Regrouper les doublons avant de les compter

uniq compare chaque ligne aux lignes identiques adjacentes. Sur la liste de fruits non triée, il laisse les six lignes, car aucun nom identique n’est adjacent à un autre. sort fruit.txt | uniq affiche les trois noms différents ; sort -u fruit.txt peut aussi produire une liste triée sans doublons.

Après le tri, uniq -c indique le nombre de chaque suite : « 3 apple », « 2 banana », « 1 cherry », avec des espaces devant les nombres. uniq -d affiche un exemplaire de chaque valeur répétée, et uniq -u affiche seulement les valeurs présentes une fois. uniq -i ignore la casse dans ses comparaisons.

Pour obtenir d’abord les valeurs les plus fréquentes, utilise sort fruit.txt | uniq -c | sort -rn. Le premier tri regroupe les lignes identiques ; le dernier classe leurs décomptes. Omettre le premier tri compte séparément les suites dispersées.

Un enregistrement contient souvent plus d’informations qu’il n’en faut pour répondre à une question. cut sélectionne des champs ou des positions fixes dans chaque ligne et écrit la sélection sur stdout. Il ne réorganise ni ne modifie le fichier d’origine.

Sélectionner des champs selon leur séparateur

Un délimiteur sépare les champs. Dans /etc/passwd, des deux-points séparent le nom d’utilisateur, le caractère de remplacement du mot de passe, l’identifiant utilisateur, l’identifiant de groupe, le nom complet, le répertoire personnel et le shell de connexion. Pour cet exemple d’enregistrement :

alice:x:1001:1001:Alice Smith:/home/alice:/bin/bash

cut -d: -f1,6 affiche « alice:/home/alice ». Les numéros de champ commencent à 1 et le délimiteur reste entre les champs sélectionnés. cut -d: -f5 affiche « Alice Smith » ; l’espace intérieur fait partie de ce champ, car le délimiteur est un deux-points.

La liste sélectionne des champs sans définir un nouvel ordre. cut -d, -f3,1 affiche toujours le champ 1 suivi du champ 3. Par défaut, le séparateur est une tabulation : cut -f2 file sélectionne donc le deuxième champ séparé par des tabulations.

Une ligne sans délimiteur est affichée en entier. Par exemple, cut -f2 affiche « no tabs here » sans modification, car cette ligne ne contient pas de tabulation. Ajoute -s pour exclure les lignes sans délimiteur. Une ligne contenant des délimiteurs mais dépourvue d’un champ demandé est un cas différent ; -s ne vérifie pas de façon générale si les enregistrements sont complets.

Sélectionner des positions fixes

cut -c1-5 sélectionne les positions 1 à 5. Sur l’enregistrement de compte ci-dessus, il affiche « alice ». La sélection par position convient au texte à champs de largeur fixe, où les colonnes recherchées commencent aux mêmes endroits sur chaque ligne. La sélection par champ convient aux enregistrements dont les longueurs de champs varient mais dont les séparateurs restent constants.

Vérifier le comportement des séparateurs

Avec cut -d' ' -f2, chaque espace est un séparateur. Le texte « a b » a un deuxième champ vide entre ses deux espaces : le résultat est donc une ligne vide. Si les espaces répétés servent seulement à espacer les colonnes, tr -s ' ' | cut -d' ' -f2 réduit d’abord chaque suite d’espaces à un seul.

cut traite aussi les virgules à l’intérieur de valeurs entre guillemets comme des séparateurs. Une valeur CSV entre guillemets telle que « Smith, Ann » n’est pas automatiquement gardée ensemble. Utilise des exemples simples à champs délimités seulement lorsque les limites des champs correspondent réellement à la règle du délimiteur.

Compter les valeurs d’une colonne sélectionnée

Pour compter les villes dans scores.csv, commence par cut -d, -f2 scores.csv. Avec les enregistrements d’Ana, Ben, Chen, Dara et Eli, cette commande affiche « city », « Lisbon », « Oslo », « Lisbon », « Oslo », « Lisbon ». Puis :

cut -d, -f2 scores.csv | tail -n +2 | sort | uniq -c | sort -rn

Retirer la première ligne supprime « city ». Le tri regroupe les trois entrées Lisbon et les deux entrées Oslo ; uniq -c les compte et le dernier tri place « 3 Lisbon » avant « 2 Oslo ». Oublier l’étape qui retire l’en-tête crée une valeur supplémentaire, « 1 city », car ces commandes traitent aussi un en-tête comme du texte.

grep recherche du texte et affiche normalement chaque ligne contenant une correspondance. Pour obtenir une recherche utile, commence par choisir le motif et le type de résultat dont tu as besoin : lignes, nombres, numéros de ligne ou noms de fichiers.

Commencer avec un motif entre guillemets

La forme habituelle est grep 'pattern' file. Sans argument désignant un fichier, grep lit stdin. Les recherches sont sensibles à la casse, sauf si tu ajoutes -i.

Supposons que server.log contient cinq entrées : une ligne INFO de démarrage, une ligne ERROR indiquant un disque plein, une ligne WARN de nouvelle tentative, une ligne contenant « error timeout » en minuscules et une ligne INFO de sauvegarde. grep 'ERROR' server.log affiche seulement la ligne ERROR en majuscules. grep -i 'error' server.log affiche les deux lignes d’erreur.

Place les motifs entre guillemets même lorsqu’ils semblent simples. grep 'disk full' server.log recherche les deux mots ensemble. Sans guillemets, grep disk full server.log utilise « disk » comme motif et traite « full » comme un autre nom de fichier. Les guillemets empêchent aussi le shell de développer les astérisques et d’autres caractères spéciaux avant que grep les reçoive.

Choisir la sortie nécessaire

Les options se combinent : grep -ic 'error' server.log indique 2, tandis que grep -n 'WARN' server.log indique la ligne 3. -c compte les lignes correspondantes, pas le nombre d’occurrences qu’elles contiennent. Une ligne contenant « error error » compte pour un.

Considère les lignes « error », « terror », « errors » et « Error found ». grep 'error' seul trouve les trois premières. grep -w 'error' ne trouve que la première, car « error » n’est pas un mot entier dans « terror » ou « errors ». Ajouter -i permet aussi de trouver « Error found ». -x exige une ligne entièrement correspondante : « Error found » ne correspond donc toujours pas à une recherche de « error » sur la ligne entière.

Effectuer une recherche dans plusieurs fichiers

Lorsqu’une recherche porte sur plusieurs fichiers, grep fait normalement précéder les correspondances des noms de fichiers. grep -r 'TODO' notes effectue une recherche dans les fichiers de toute l’arborescence du répertoire. Ajoute -l pour afficher seulement les noms des fichiers contenant des correspondances : grep -rl 'TODO' notes. -L en majuscule liste les fichiers sans correspondance. Ces résultats sélectionnent des fichiers ; ils ne comptent pas les lignes correspondantes.

Déterminer si le motif est littéral

Par défaut, grep interprète une expression régulière. Un point correspond à n’importe quel caractère unique : '10.0.0.7' peut donc aussi correspondre à « 10a0b0c7 ». grep -F '10.0.0.7' file recherche le texte exact. Échapper chaque point, comme dans '10\.0\.0\.7', rend aussi les points littéraux.

grep -q supprime la sortie normale et communique par son code de retour : 0 en cas de correspondance, 1 en l’absence de correspondance et normalement 2 en cas d’erreur dans GNU grep. Un fichier d’entrée manquant est une erreur, pas une preuve que le motif était absent.

Dans un pipeline, grep -i 'error' server.log | wc -l compte les lignes correspondantes comme le fait grep -ic. La première forme permet d’ajouter d’autres filtres entre la sélection des lignes et leur comptage.

Une expression régulière décrit le texte susceptible de correspondre. grep cherche normalement une partie correspondante n’importe où dans une ligne, puis affiche la ligne entière. La plupart des lettres correspondent à elles-mêmes ; les caractères spéciaux décrivent des positions, des choix ou des répétitions.

Trouver un caractère ou une position

Le point . correspond à un caractère dans une ligne. Avec les lignes « cat », « cart », « coat », « cut », « act », « scat » et « color », le motif 'c.t' correspond à « cat », « cut » et « scat ». Cette dernière ligne contient « cat », qui est une partie correspondante. « coat » contient deux caractères entre « c » et « t », donc un seul point ne peut pas couvrir les deux.

Utilise des ancres pour imposer des positions. ^ marque le début d’une ligne et $ sa fin :

grep '^c.t$' words.txt affiche seulement « cat » et « cut ». Ancrer les deux extrémités exclut une ligne plus longue telle que « scat ».

Choisir un caractère dans un ensemble

Une expression entre crochets correspond à un caractère. [ao] signifie « a » ou « o » : 'c[ao]t' correspond donc à la partie « cat » de « cat » et de « scat ». [0-9] désigne un chiffre. Un accent circonflexe placé juste après le crochet ouvrant inverse l’ensemble : 'c[^a]t' correspond à « cut », mais pas à « cat ». À cet endroit, l’accent circonflexe exclut un caractère ; il ne marque pas le début d’une ligne.

Les classes nommées décrivent des catégories selon les paramètres régionaux actifs. [[:digit:]] sélectionne un chiffre, [[:alpha:]] une lettre, [[:alnum:]] une lettre ou un chiffre, et [[:upper:]] ou [[:lower:]] une lettre dans la casse indiquée. [[:space:]] comprend les espaces, les tabulations et d’autres caractères d’espacement. Garde les deux paires de crochets : le nom de la classe se trouve à l’intérieur de l’expression d’ensemble extérieure.

Répéter l’élément précédent

* signifie zéro ou plusieurs occurrences de l’élément situé juste avant. 'ca*t' peut correspondre à « ct », « cat » ou « caat ». Il correspond aussi à « act », car cette ligne contient « ct », avec zéro occurrence de « a ». Pour trouver une suite quelconque de caractères, combine le point et l’astérisque sous la forme .*.

'^c.*t$' correspond à « cat », « cart », « coat » et « cut » dans la liste de mots. Un caractère générique de nom de fichier et une expression régulière utilisent des règles différentes pour l’astérisque : le motif du shell *.txt décrit les noms se terminant par « .txt », mais l’expression régulière pour cette fin est '\.txt$'.

Rendre un caractère spécial littéral

Une barre oblique inverse peut supprimer un sens particulier. \. correspond à un véritable point, \* à un astérisque et \[ à un crochet ouvrant. [.] sélectionne aussi un point littéral. grep '\.conf$' file sélectionne les lignes se terminant par « .conf ».

Une recherche dans une configuration peut retirer les commentaires simples et les lignes vides avec grep -v '^#' app.conf | grep -v '^$'. Le premier test ne reconnaît les commentaires que lorsque « # » est le premier caractère. La syntaxe de base utilisée par défaut traite ?, +, les accolades, | et les parenthèses sans échappement comme des caractères ordinaires. GNU grep prend en charge les formes d’opérateurs précédées d’une barre oblique inverse ; grep -E fournit la syntaxe étendue sans ces barres obliques inverses.

Les expressions régulières étendues ajoutent des moyens utiles d’exprimer des parties facultatives, des groupes répétés et des alternatives. Utilise grep -E pour que le motif soit lu selon cette syntaxe. Le point, les ancres, les ensembles et l’astérisque conservent leur sens précédent.

Compter les répétitions

Un opérateur suit l’élément qu’il modifie. Cet élément peut être un caractère, une expression entre crochets ou un groupe :

'logs?' correspond à « log » et à « logs » : seul le « s » est facultatif. 'ca+t' exige au moins un « a » ; il correspond donc à « cat » et à la partie correspondante de « scat », mais pas à « ct » dans « act ». Omettre -E transforme un point d’interrogation ou un signe plus non échappé en texte littéral dans la syntaxe de base.

Pour un code entier composé de deux lettres majuscules et de quatre chiffres, utilise :

grep -E '^[A-Z]{2}[0-9]{4}$' codes.txt

« AB1234 » et « QZ0042 » correspondent. « A12345 » n’a qu’une lettre initiale, « ab1234 » utilise des minuscules et « XY98765 » a un chiffre de trop. Les deux ancres empêchent qu’une partie d’un code plus long, qui semble valide, soit acceptée. Ajouter -i autoriserait aussi le code en minuscules.

Regrouper des alternatives

| indique une alternative dans un motif étendu. 'cat|cut' recherche l’un ou l’autre mot n’importe où dans une ligne. Les parenthèses définissent les limites d’un groupe : 'c(a|o)t' choisit « a » ou « o » entre « c » et « t ». Un quantificateur placé ensuite s’applique au groupe entier : '(ab)+' correspond donc à une ou plusieurs occurrences de « ab ».

Garde le motif entre guillemets. Dans grep -E cat|cut words.txt, le shell interprète la barre verticale non protégée comme un tube entre des commandes. Dans grep -E 'cat|cut' words.txt, il transmet ce caractère à grep comme partie d’un seul motif.

Afficher les correspondances plutôt que les lignes complètes

-o affiche seulement les parties correspondantes, une par ligne de sortie. La commande ci-dessous extrait d’une ligne plus longue une suite de nombres séparés par des points :

grep -Eo '([0-9]{1,3}\.){3}[0-9]{1,3}' server.log

La partie entre parenthèses représente un à trois chiffres suivis d’un point littéral ; {3} la répète trois fois. La dernière partie ajoute un à trois chiffres. Elle extrait « 10.0.0.7 » d’une ligne qui le contient, mais accepte aussi « 999.999.999.999 ». Une correspondance sur la forme ne vérifie pas si chaque nombre se trouve dans la plage valide d’une adresse.

Supprimer ensemble les lignes vides et les commentaires

grep -Ev '^[[:space:]]*(#|$)' app.conf sélectionne les paramètres actifs. Lis le motif dans l’ordre : commencer au début, autoriser des caractères d’espacement, puis trouver soit « # », soit la fin de la ligne. Il reconnaît donc les commentaires indentés et les lignes composées uniquement d’espaces, ainsi que les lignes vides. -v conserve les lignes qui ne correspondent pas à cette description, telles que « port=8080 ». L’ancien nom de commande egrep est obsolescent dans GNU grep ; utilise grep -E.

find parcourt une arborescence et teste les éléments qu’il rencontre. Choisis d’abord le répertoire de départ : find project affiche project lui-même et les entrées situées en dessous. L’ajout de tests restreint la sélection.

Faire correspondre noms, chemins et types

find project -name '*.txt' sélectionne les noms se terminant par « .txt » partout sous le répertoire de départ. Place le caractère générique entre guillemets pour que le shell le transmette sans modification. -name est sensible à la casse : pour trouver « Guide.TXT » sans tenir compte de la casse, il faut utiliser -iname '*.txt'.

Le motif doit correspondre au nom entier de l’élément, sans ses répertoires parents. -name 'guide' ne correspond pas à « guide.txt » ; -name 'guide*' y correspond. Utilise -path '*/src/*' lorsque la partie du chemin correspondant au répertoire compte. find affiche les chemins dans l’ordre du parcours : ajoute | sort si tu veux les trier.

-type f sélectionne les fichiers ordinaires, -type d les répertoires et -type l les liens symboliques. find project -type f -name '*.txt' exige que les tests sur le type et sur le nom soient tous deux satisfaits. Un répertoire nommé « notes.txt » échoue au test sur le type même si son nom convient.

Comprendre les comparaisons de taille

-size compare une taille après l’avoir arrondie à l’unité supérieure dans l’unité choisie. c signifie octets, k désigne des kibioctets de 1 024 octets, M des mébioctets de 1 048 576 octets et G des gibioctets. Un signe plus initial signifie supérieur à, un signe moins inférieur à, et l’absence de signe égal au nombre d’unités indiqué.

Pour -size +100M, la taille arrondie doit dépasser 100 MiB. Un fichier qui dépasse 100 MiB d’un octet est arrondi à 101 unités et satisfait le test. Un fichier non vide de moins de 1 MiB est arrondi à une unité : -size -1M ne trouve donc que les fichiers vides. Utilise un test en octets pour un seuil exact en octets, ou une unité plus petite pour obtenir une plage utile de petits fichiers.

Tester l’ancienneté et limiter la profondeur

-mtime utilise les périodes complètes de 24 heures écoulées depuis la modification. -mtime -7 sélectionne les éléments modifiés il y a moins de sept jours. -mtime +30 sélectionne les éléments dont l’ancienneté dépasse 30 périodes complètes : au moins 31 jours. -mmin -30 utilise les minutes pour les modifications récentes. -user alice sélectionne un propriétaire et -empty sélectionne les fichiers ou répertoires vides.

Pour examiner le répertoire de départ et ses entrées immédiates sans entrer dans les sous-répertoires, utilise find project -maxdepth 1 -type f. Place -maxdepth avant les tests.

Combiner les tests et protéger les motifs

Des tests écrits côte à côte signifient ET. -o signifie OU, comme dans find project -name '*.txt' -o -name '*.md'. ! -name '*.c' inverse un test sur le nom. Pour une sélection simple, clarifie la relation entre les tests avant d’ajouter des actions.

Un caractère générique non protégé est développé par le shell dans ton répertoire courant. Si seul notes.txt y correspond, find . -name *.txt devient une recherche de ce seul nom et manque les autres fichiers texte. Si plusieurs noms locaux correspondent, la commande peut échouer parce que des noms supplémentaires apparaissent dans l’expression de test.

Une recherche dans des répertoires protégés peut signaler « Permission denied ». 2>/dev/null masque ces erreurs, mais ne permet pas de rechercher dans les répertoires illisibles. find examine l’arborescence pendant son exécution ; un système de fichiers en activité peut encore changer avant qu’une commande ultérieure utilise les chemins renvoyés.

Après avoir sélectionné des fichiers, tu peux transmettre leurs chemins à une autre commande. Garder la sélection et l’action dans la même expression find évite de traiter les espaces à l’intérieur des noms de fichiers comme des séparateurs entre les noms.

Exécuter une commande sur chaque élément correspondant

L’action -exec command {} \; exécute la commande une fois par élément correspondant. find remplace {} par le chemin de cet élément. Par exemple :

find project -name 'main.c' -exec wc -l {} \;

Si l’élément correspondant est project/src/main.c, cela exécute wc -l project/src/main.c. Le point-virgule échappé termine l’action. La barre oblique inverse empêche le shell d’utiliser d’abord le point-virgule pour terminer toute la commande shell.

Utilise {} + pour transmettre des lots de chemins à un nombre réduit d’exécutions de la commande :

find notes -type f -name '*.txt' -exec grep -l 'TODO' {} +

grep reçoit les chemins des fichiers sélectionnés comme arguments et liste ceux qui contiennent « TODO ». Les deux formes conservent un chemin tel que « notes/team plan.txt » comme un seul argument. La forme avec + réduit le travail de lancement lorsque de nombreux fichiers correspondent.

Combiner sélection de fichiers et sélection de texte

find teste les propriétés des fichiers ; grep examine leur contenu. Ajoute -mtime -7 avant l’action pour rechercher seulement dans les fichiers texte modifiés récemment :

find notes -type f -name '*.txt' -mtime -7 -exec grep -l 'TODO' {} +

Les tests sur le nom, le type et l’ancienneté sélectionnent d’abord les fichiers. Ensuite, grep recherche dans leur texte. grep -r seul peut rechercher dans le contenu d’une arborescence, mais ne remplace pas ces tests sur les propriétés des fichiers.

Ne supprimer qu’après avoir vérifié la sélection

-delete supprime les éléments correspondants sans confirmation ni possibilité d’annulation. Exécute d’abord la sélection sans action de suppression et lis les chemins. Ensuite seulement, ajoute -delete à la fin, comme dans find /tmp/build -type f -name '*.tmp' -delete. Pour obtenir une demande de confirmation par élément, -ok rm {} \; pose la question avant d’exécuter la commande de suppression.

Les actions s’exécutent au fur et à mesure de l’évaluation de l’expression. Placer -delete avant -name '*.tmp' permet à la suppression d’avoir lieu avant que ce test sur le nom puisse la restreindre. Un test ultérieur ne peut pas protéger un élément d’une action déjà effectuée.

Choisir une recherche plus rapide lorsqu’elle convient

locate guide.txt recherche dans un index de chemins enregistrés contenant « guide.txt ». Il peut répondre rapidement sans parcourir le disque. Comme la base est actualisée périodiquement, un nouveau fichier peut être absent ou un chemin supprimé peut subsister. updatedb reconstruit l’index ; une mise à jour à l’échelle du système nécessite généralement des droits d’administration. Certaines distributions nécessitent un paquet facultatif tel que plocate.

which grep cherche un fichier programme exécutable dans les répertoires de PATH et indique souvent /usr/bin/grep. Il ne décrit pas toutes les façons dont Bash résout une commande. type echo, par exemple, peut identifier une commande interne même lorsqu’un programme externe nommé « echo » existe aussi. Utilise type commandname pour connaître l’interprétation de Bash, find pour une recherche à jour dans l’arborescence et locate pour une recherche rapide de nom dans l’index.

nano notes.txt ouvre du texte dans un éditeur de terminal. Tu peux te déplacer avec les touches fléchées et saisir directement du texte. Si le fichier n’existe pas, nano ouvre un tampon vide, c’est-à-dire le texte de travail conservé en mémoire ; l’enregistrement crée le fichier sur le disque.

Lire les indications de raccourcis

Les lignes du bas affichent des combinaisons de touches. ^ signifie Ctrl : ^X signifie donc Ctrl+X. M- signifie Méta, généralement Alt : M-U signifie donc Alt+U. Ctrl+G ouvre l’aide. Ces indications désignent des touches à presser ensemble, pas des caractères à saisir dans le fichier.

Faire et enregistrer une petite modification

Pour remplacer « port=8080 » par « port=9090 » dans app.conf :

1. Exécute nano app.conf.
2. Appuie sur Ctrl+W, saisis « 8080 » et appuie sur Entrée.
3. À la correspondance, supprime les quatre chiffres et saisis « 9090 ».
4. Appuie sur Ctrl+O, puis sur Entrée pour confirmer le nom du fichier et enregistrer.
5. Appuie sur Ctrl+X pour quitter.

De retour dans le shell, grep 'port' app.conf devrait afficher « port=9090 ». Cela vérifie le fichier enregistré, et pas seulement ce qui était visible dans l’éditeur.

Ctrl+O correspond à Write Out, la commande d’enregistrement ; ce n’est pas une commande d’ouverture de fichier. Ctrl+R lit le contenu d’un autre fichier dans le tampon courant à l’emplacement du curseur. Confondre ces actions peut insérer du texte indésirable dans le fichier que tu modifies.

Rechercher, remplacer et se déplacer

Ctrl+W recherche du texte. Alt+G va au numéro de ligne demandé, ce qui est utile lorsqu’un message d’erreur indique une ligne précise. Ctrl+C affiche la ligne et la colonne courantes.

Alt+R, également accessible par Ctrl+, lance le remplacement. Saisis le texte à trouver, puis son remplacement. Pour chaque correspondance, réponds Y pour remplacer ou N pour passer ; A remplace tout. Choisir les remplacements individuellement est utile lorsque les mêmes chiffres apparaissent dans plusieurs paramètres et qu’un seul doit changer.

Déplacer du texte et annuler des modifications

Appuyer plusieurs fois sur Ctrl+K recueille des lignes consécutives. Avec une sélection marquée, Ctrl+K coupe le texte marqué au lieu de toute la ligne. Ctrl+U insère ensuite ce texte à l’emplacement du curseur. L’annulation est utile juste après une coupe ou un remplacement accidentel.

Quitter volontairement

Ctrl+X quitte. Si le tampon contient des modifications non enregistrées, nano demande s’il faut les enregistrer. Y enregistre, puis Entrée confirme le nom ; N quitte sans enregistrer ces modifications ; Ctrl+C annule la sortie et revient à la modification. Répondre N revient à décider d’abandonner le travail, pas à continuer la modification.

nano -l app.conf affiche les numéros de ligne et nano +12 app.conf commence à la ligne 12. Si l’enregistrement échoue faute de droits, le tampon modifié n’a pas été enregistré à ce chemin. Les fichiers système nécessitent les droits appropriés, par exemple sudo nano /etc/hosts lorsqu’une modification autorisée du système nécessite un accès administrateur. Pour t’exercer, utilise un fichier dans ton propre répertoire.

vi notes.txt ouvre un éditeur de terminal en mode normal. Dans ce mode, une touche telle que x est une commande. Pour saisir du texte, passe d’abord en mode insertion. Sur de nombreux systèmes Linux, vi lance Vim ou un autre éditeur compatible avec vi.

Garder à l’esprit le mode actif

Vim affiche « -- INSERT -- » pendant l’insertion. Échap revient au mode normal. Depuis le mode normal, i insère avant le curseur et a après. I commence avant le premier caractère non blanc de la ligne, en conservant l’indentation ; A ajoute à la fin. o ouvre une ligne en dessous et O une ligne au-dessus.

Se déplacer sans saisir de texte

En mode normal, h, j, k et l déplacent respectivement vers la gauche, le bas, le haut et la droite. Les touches fléchées fonctionnent aussi. w va au mot suivant, 0 au début de la ligne et $ à sa fin. G va à la dernière ligne. 1G va à la première ; Vim propose aussi gg. Un nombre avant G sélectionne une ligne : 12G va donc à la ligne 12. :12 puis Entrée font la même chose. Les nombres répètent aussi les déplacements : 5j descend de cinq lignes.

Modifier depuis le mode normal

x supprime le caractère sous le curseur. dd coupe une ligne ; 3dd coupe trois lignes. yy copie une ligne. Pour du texte composé de lignes entières, p colle sous la ligne courante et P au-dessus. Pour du texte composé de caractères, p colle après le curseur et P avant.

cw remplace le reste du mot courant et passe en mode insertion. r suivi d’un caractère remplace un seul caractère. u annule une modification ; Ctrl+R dans Vim la rétablit. Un point . répète la dernière modification.

Trouver et modifier un paramètre

Pour remplacer « 8080 » par « 9090 » dans app.conf, exécute vi app.conf, puis saisis /8080 et appuie sur Entrée. Au premier « 8 », saisis cw, saisis « 9090 », puis appuie sur Échap. Saisis :wq et appuie sur Entrée pour enregistrer et quitter.

Cherche vers l’arrière avec ?text puis Entrée. n répète la recherche dans le sens actuel et N l’inverse. Les recherches acceptent les expressions régulières. Pour remplacer chaque occurrence dans tout un fichier, :%s/8080/9090/g utilise % pour toutes les lignes et g pour toutes les occurrences sur chaque ligne. :set number affiche les numéros de ligne pendant la modification.

Enregistrer ou quitter volontairement

Depuis le mode normal, :w puis Entrée enregistrent ; :w newname.txt enregistre sous un nouveau nom. :q ne quitte que si aucune modification non enregistrée ne l’en empêche. :wq, :x ou ZZ enregistrent et quittent. :q! abandonne les modifications non enregistrées et quitte.

Si la saisie déplace le curseur ou supprime du texte de façon inattendue, appuie sur Échap pour revenir au mode normal, puis utilise u pour annuler les modifications indésirables avant de continuer. Passe en mode insertion avant de saisir le texte de remplacement. Lorsque tu quittes une tentative de modification, choisis d’enregistrer ou d’abandonner ; le point d’exclamation dans :q! autorise l’abandon du travail non enregistré.