Maîtriser pipes Bash et chaînage fiable de commandes

Difficulté

Facile

La ligne de commande devient vraiment utile quand on arrête de lancer des commandes une par une. Avec quelques opérateurs très simples, vous pouvez exécuter plusieurs actions d’affilée, ne poursuivre qu’en cas de succès, réagir à un échec ou transmettre la sortie d’une commande à la suivante.

Ce tutoriel se concentre sur quatre outils de base de Bash : |, ;, && et ||. L’objectif n’est pas de mémoriser des définitions abstraites, mais de construire des commandes courtes, lisibles et surtout fiables.

Prérequis

Ouvrez un terminal Bash sur Linux. Les exemples utilisent des commandes très courantes comme echo, pwd, cd, ls, grep, cat, wc et mkdir.

Créez si possible un dossier de test pour manipuler des fichiers sans risque, par exemple avec mkdir -p ~/demo-pipes puis cd ~/demo-pipes. Vous pourrez y recopier les exemples et supprimer le dossier ensuite.

Matériel nécessaire

• Un ordinateur sous Linux avec Bash
• Un terminal
• Quelques commandes usuelles disponibles
• Un dossier de test dans le répertoire personnel

Étapes

1. 1

   Ouvrir un dossier de test

   Commencez dans un emplacement sans enjeu. Entrez :

   mkdir -p ~/demo-pipes
   cd ~/demo-pipes
   pwd

   La commande pwd affiche le dossier courant. Vous travaillez ainsi dans un espace simple à nettoyer.

2. 2

   Enchaîner des commandes avec un point-virgule

   Exécutez plusieurs commandes l’une après l’autre avec ;. Essayez :

   pwd ; ls ; echo "fin"

   Chaque commande est lancée dans l’ordre, même si l’une d’elles échoue. C’est la forme la plus simple du chaînage.

3. 3

   Provoquer un échec pour observer le comportement

   Testez un cas où une commande échoue. Entrez :

   cd /dossier/qui/nexiste/pas ; pwd ; echo "suite exécutée"

   Le cd échoue, mais pwd et echo s’exécutent quand même. Vous voyez immédiatement pourquoi ; n’est pas adapté aux suites qui dépendent d’un succès préalable.

4. 4

   Conditionner une suite avec &&

   Utilisez && pour ne lancer la commande suivante que si la précédente réussit. Essayez :

   cd ~/demo-pipes && pwd && echo "dossier prêt"

   Ici, la suite continue seulement si chaque étape réussit. C’est très utile quand la commande suivante dépend directement de la précédente.

5. 5

   Bloquer une suite après un échec

   Refaites le test précédent avec un chemin invalide. Entrez :

   cd /dossier/qui/nexiste/pas && pwd && echo "vous ne verrez pas ce message"

   Comme le cd échoue, le reste ne s’exécute pas. C’est l’un des usages les plus utiles de && dans la pratique.

6. 6

   Déclencher une action de secours avec ||

   Utilisez || pour lancer une commande seulement si la précédente échoue. Essayez :

   cd /dossier/qui/nexiste/pas || echo "changement de dossier impossible"

   Le message apparaît parce que le cd n’a pas réussi. C’est pratique pour afficher un diagnostic ou proposer une action de repli simple.

7. 7

   Combiner && et || avec prudence

   Testez un motif courant : une action en cas de succès, une autre en cas d’échec. Entrez :

   cd ~/demo-pipes && echo "ok" || echo "ko"

   Puis testez avec un chemin invalide :

   cd /dossier/qui/nexiste/pas && echo "ok" || echo "ko"

   Dans ces exemples simples, vous obtenez un retour lisible. Cette forme est pratique pour vérifier rapidement un comportement ou afficher un état clair.

8. 8

   Faire circuler une sortie avec un pipe

   

   Passez maintenant à |, le pipe. Essayez :

   echo "pomme" | wc -c

   La sortie produite par echo devient l’entrée de wc -c. Vous créez ainsi une petite chaîne de traitement entre deux commandes.

9. 9

   Filtrer une liste avec grep

   Créez quelques fichiers de test puis filtrez l’affichage. Entrez :

   touch notes.txt todo.txt image.png archive.tar
   ls | grep ".txt"

   La commande ls liste les fichiers, puis grep ne garde que les lignes contenant .txt. Vous utilisez ici le pipe pour transmettre une liste à un filtre.

10. 10

    Compter des résultats dans un pipeline

    Ajoutez une commande à la suite pour résumer le résultat. Essayez :

    ls | grep ".txt" | wc -l

    Vous obtenez le nombre de lignes retenues par grep. Un pipeline peut donc enchaîner plusieurs transformations courtes et lisibles.

11. 11

    Lire un fichier puis filtrer son contenu

    

    Créez un petit fichier texte puis recherchez des lignes utiles. Entrez :

    printf "alice\nbob\nalice martin\n" > noms.txt
    cat noms.txt | grep "alice"

    Vous affichez le contenu du fichier, puis vous gardez uniquement les lignes contenant alice. Le principe reste identique : une commande produit, la suivante consomme.

12. 12

    Mélanger un pipeline et un chaînage conditionnel

    Combinez maintenant les deux idées. Essayez :

    cat noms.txt | grep "alice" && echo "au moins une ligne trouvée"

    Si grep trouve au moins une ligne, le message s’affiche après le pipeline. Vous utilisez ici la sortie du pipeline pour produire un résultat, puis l’état final pour décider de la suite.

13. 13

    Écrire des commandes fiables pour changer de dossier

    

    Appliquez les opérateurs à une situation très fréquente. Au lieu d’écrire :

    cd ~/demo-pipes ; ls

    préférez :

    cd ~/demo-pipes && ls

    La seconde forme évite d’exécuter ls dans un dossier inattendu si le cd échoue. C’est un petit réflexe qui améliore immédiatement la fiabilité de vos lignes de commande.

14. 14

    Construire une suite de préparation sûre

    Essayez une séquence de préparation simple dans votre dossier de test. Entrez :

    mkdir -p projet-demo && cd projet-demo && touch README.txt && ls

    Vous créez un dossier, vous y entrez, vous créez un fichier, puis vous affichez le résultat. Si une étape échoue, les suivantes sont bloquées.

15. 15

    Ajouter un message d’erreur utile

    Complétez une suite avec un retour explicite en cas d’échec. Essayez :

    cd /dossier/qui/nexiste/pas && ls || echo "impossible d'afficher ce dossier"

    Vous obtenez soit le contenu du dossier, soit un message clair. Cette forme aide à rendre une commande plus lisible quand vous la partagez ou la relancez plus tard.

16. 16

    Relire la logique avant d’exécuter

    Prenez l’habitude de reformuler la ligne avec des mots simples avant d’appuyer sur Entrée. Par exemple, lisez cd ~/demo-pipes && ls | grep ".txt" comme : “entrer dans ce dossier, puis lister et filtrer les fichiers texte si le changement de dossier réussit”.

    Cette relecture évite les confusions entre “transmettre une sortie” et “continuer seulement en cas de succès”. C’est souvent la différence entre une commande pratique et une commande trompeuse.

Erreurs fréquentes & dépannage

L’erreur la plus courante consiste à utiliser ; alors que la seconde commande dépend de la première. Dans ce cas, remplacez souvent ; par &&, surtout après un cd.

Une autre confusion fréquente est de prendre | pour un simple séparateur de commandes. Le pipe transmet des données entre commandes, alors que && et || décident de la suite selon un succès ou un échec.

Faites aussi attention aux constructions du type commande1 && commande2 || commande3. Elles sont pratiques pour des cas simples, mais deviennent vite ambiguës si commande2 peut échouer de manière indépendante.

Astuces & pour aller plus loin

Travaillez d’abord avec des commandes sans risque comme echo, pwd, ls et grep. Vous pourrez observer le comportement des opérateurs sans toucher à des fichiers importants.

Quand un enchaînement vous semble confus, testez chaque morceau séparément. Vérifiez d’abord la commande de gauche, puis ajoutez le pipe ou l’opérateur conditionnel, puis relancez.

Enfin, privilégiez des lignes qui se lisent naturellement de gauche à droite. Un bon pipeline raconte souvent une suite d’actions simple : produire, filtrer, compter ou afficher.

Questions fréquentes

Quelle différence entre | et ; ?

; lance une commande puis la suivante, sans transmettre la sortie de la première à la seconde. | relie la sortie standard d’une commande à l’entrée standard de la suivante.

Quand utiliser && au lieu de ; ?

Utilisez && quand la commande suivante ne doit se lancer que si la précédente a réussi. C’est particulièrement utile après cd ou après une étape de préparation dont dépend la suite.

À quoi sert || ?

|| permet d’exécuter une commande de secours si la précédente échoue. On l’utilise souvent pour afficher un message clair ou déclencher une action de repli simple.

Pourquoi un pipeline peut-il être suivi de && ?

Parce qu’un pipeline reste une commande du point de vue du shell. Vous pouvez donc décider de lancer la suite avec && selon l’état renvoyé à la fin du pipeline dans les exemples de ce tutoriel.

Comment éviter les commandes trompeuses ?

Relisez la ligne en séparant mentalement deux questions : “est-ce que je transmets une sortie ?” et “est-ce que je conditionne l’exécution ?”. Cette habitude aide à choisir entre |, ;, && et ||.

Conclusion

Avec ;, &&, || et |, vous possédez déjà les briques essentielles pour écrire des lignes Bash bien plus utiles. L’idée clé est simple : choisissez ; pour juxtaposer, && pour sécuriser une suite, || pour réagir à un échec et | pour faire circuler des données.

En pratique, la fiabilité vient surtout de la relecture. Si vous savez dire clairement ce que chaque opérateur fait dans votre ligne, vous êtes déjà en train d’écrire de meilleures commandes.