Maîtriser Bash : stdin, stdout, stderr et redirections

Difficulté

Facile

Les redirections Bash font partie des gestes les plus utiles en ligne de commande. Elles permettent de contrôler d’où une commande lit ses données, où elle écrit ses résultats et où vont ses messages d’erreur.

Dans ce tutoriel, vous allez manipuler les trois descripteurs standard : stdin, stdout et stderr. Vous verrez aussi comment utiliser 2>&1 et /dev/null sur des cas concrets, sans supposer de connaissances avancées.

Prérequis

Vous avez accès à un shell Bash sur Linux et vous savez lancer des commandes simples. Ouvrez un terminal, placez-vous dans un dossier de test et évitez d’exécuter les exemples dans un répertoire contenant des fichiers importants.

Les exemples utilisent seulement des commandes courantes comme echo, cat, ls, wc et grep. Si une commande renvoie un message différent selon votre distribution, concentrez-vous sur le principe de redirection montré.

Matériel nécessaire

• Un terminal Bash sur Linux
• Un dossier de test vide ou sans enjeu
• Des commandes de base : echo, cat, ls, wc, grep

Étapes

1. 1

   Créer un dossier de test et entrer dedans

   Commencez par créer un espace de travail dédié, puis placez-vous dedans. Cela évite de mélanger vos fichiers de démonstration avec d’autres documents.

   mkdir -p ~/redir-demo
   cd ~/redir-demo

2. 2

   Afficher une sortie standard simple

   Lancez une commande qui écrit un résultat normal à l’écran. Par exemple, utilisez echo.

   echo "bonjour"

   Le texte affiché passe par la sortie standard, appelée stdout. Par défaut, elle est reliée au terminal.

3. 3

   Provoquer un message d’erreur visible

   Lancez maintenant une commande qui échoue pour observer un autre flux. Demandez par exemple un fichier absent.

   ls fichier-inexistant

   Le message d’échec apparaît aussi dans le terminal, mais il ne passe pas par stdout. Il passe par la sortie d’erreur, appelée stderr.

4. 4

   Lire une entrée standard avec une redirection

   Créez d’abord un petit fichier texte. Faites ensuite lire ce fichier à une commande via l’entrée standard.

   printf "ligne 1\nligne 2\n" > notes.txt
   wc -l < notes.txt

   La commande wc -l compte les lignes reçues sur stdin. Le symbole < relie donc le contenu du fichier à l’entrée de la commande.

5. 5

   Rediriger la sortie standard vers un fichier

   

   Écrivez maintenant la sortie normale d’une commande dans un fichier au lieu de l’afficher. Utilisez l’opérateur >.

   echo "première ligne" > journal.txt
   cat journal.txt

   La première commande crée le fichier s’il n’existe pas et écrit dedans. La seconde vérifie son contenu en l’affichant.

6. 6

   Ajouter une sortie à la fin d’un fichier

   Pour conserver le contenu existant, utilisez cette fois >>. Cette redirection ajoute au lieu d’écraser.

   echo "deuxième ligne" >> journal.txt
   cat journal.txt

   Vous devez voir les deux lignes dans l’ordre. C’est un geste courant pour constituer un journal simple.

7. 7

   Séparer la sortie normale et les erreurs

   

   Demandez à ls de traiter à la fois un fichier existant et un fichier absent. Redirigez ensuite chaque flux dans un fichier différent.

   touch present.txt
   ls present.txt absent.txt > sortie.txt 2> erreurs.txt

   Affichez ensuite les deux fichiers pour voir la différence entre le résultat normal et le message d’erreur.

   cat sortie.txt
   cat erreurs.txt

8. 8

   Fusionner stderr dans stdout avec 2>&1

   Relancez la même idée, mais cette fois en réunissant les deux flux. Utilisez pour cela 2>&1.

   ls present.txt absent.txt > tout.txt 2>&1
   cat tout.txt

   Le fichier tout.txt contient alors la sortie normale et le message d’erreur. Vous obtenez un seul flux final enregistré au même endroit.

9. 9

   Comparer l’ordre des redirections

   Testez maintenant deux écritures proches, mais non équivalentes. Exécutez-les l’une après l’autre.

   ls present.txt absent.txt > ordre-a.txt 2>&1
   ls present.txt absent.txt 2>&1 > ordre-b.txt

   Consultez ensuite ordre-a.txt et ordre-b.txt, puis observez aussi ce qui est resté affiché dans le terminal. Vous verrez que la destination finale de stderr dépend du moment où Bash évalue la redirection.

10. 10

    Ignorer proprement une sortie avec /dev/null

    Utilisez maintenant /dev/null pour jeter une sortie sans laisser de fichier. Commencez par masquer la sortie normale.

    echo "ce texte disparaît" > /dev/null

    Puis masquez seulement les erreurs d’une commande qui échoue. Le terminal reste alors plus propre.

    ls fichier-inexistant 2> /dev/null

11. 11

    Neutraliser une entrée standard avec /dev/null

    Vous pouvez aussi relier l’entrée standard à /dev/null. La commande ne reçoit alors aucune donnée en entrée.

    wc -l < /dev/null

    Cette forme est utile quand vous voulez empêcher une commande de lire depuis le terminal. Ici, wc -l compte simplement zéro ligne.

12. 12

    Chaîner une sortie standard vers une autre commande

    

    Faites maintenant circuler stdout d’une commande vers stdin d’une autre avec un tube. Le symbole utilisé est |.

    printf "pomme\npoire\npomme\n" | wc -l

    La première commande produit du texte, et la seconde le lit immédiatement sans fichier intermédiaire. Vous obtenez ici le nombre de lignes transmises.

13. 13

    Filtrer une sortie normale sans mélanger les erreurs

    Combinez maintenant une commande qui produit à la fois un résultat et une erreur avec un tube. Observez ce qui passe dans le filtre.

    ls present.txt absent.txt | grep present

    Le nom du fichier présent peut être filtré par grep, mais le message d’erreur s’affiche encore dans le terminal. C’est normal : le tube transporte stdout, pas stderr.

14. 14

    Faire passer aussi les erreurs dans un tube

    Si vous voulez filtrer ou enregistrer les erreurs avec le reste, fusionnez d’abord les flux. Reprenez l’exemple précédent avec 2>&1.

    ls present.txt absent.txt 2>&1 | grep -E "present|absent"

    Cette fois, la commande de droite peut voir à la fois le résultat normal et le message d’erreur. Le flux unique est plus simple à traiter quand vous voulez tout capturer ensemble.

15. 15

    Enregistrer un rapport propre et un journal d’erreurs

    Mettez en pratique la séparation des flux sur un cas réaliste. Lancez une commande qui parcourt plusieurs cibles, puis gardez les résultats exploitables et les erreurs à part.

    mkdir -p docs
    printf "alpha\nbeta\n" > docs/liste.txt
    grep alpha docs/liste.txt docs/manquant.txt > rapport.txt 2> journal-erreurs.txt

    Le fichier rapport.txt contient les lignes trouvées. Le fichier journal-erreurs.txt conserve le diagnostic sur le fichier absent.

16. 16

    Tester vos redirections avec une mini check-list

    Terminez en vérifiant systématiquement ce que lit et écrit une commande. Posez-vous trois questions : lit-elle depuis le clavier ou un fichier, écrit-elle un résultat normal, et peut-elle produire un message d’erreur ?

    echo "test" > resultat.txt
    ls absent.txt 2> erreur.txt
    wc -l < resultat.txt

    Avec cette routine, vous identifiez rapidement le bon opérateur : <, >, >>, 2> ou 2>&1. C’est la base pour lire, filtrer et journaliser proprement dans Bash.

Erreurs fréquentes & dépannage

L’erreur la plus fréquente consiste à croire que tout ce qui s’affiche à l’écran appartient au même flux. En réalité, le résultat normal et les erreurs peuvent suivre des chemins différents, même s’ils finissent tous deux dans le terminal.

Une autre confusion courante concerne l’ordre des redirections. > fichier 2>&1 et 2>&1 > fichier ne produisent pas le même effet, car Bash applique les redirections dans l’ordre où elles sont écrites.

Faites aussi attention à >, qui écrase le contenu existant. Si vous voulez conserver l’historique, utilisez >> pour ajouter à la fin du fichier.

Enfin, n’utilisez pas /dev/null pour masquer des erreurs importantes par habitude. C’est utile pour ignorer un bruit connu, mais cela peut cacher un vrai problème si vous l’appliquez sans vérifier.

Astuces & pour aller plus loin

Créez toujours un petit dossier de démonstration pour tester les redirections. Vous pourrez y provoquer des réussites et des échecs sans risque, puis supprimer tous les fichiers d’un coup.

Quand vous apprenez une nouvelle forme, observez séparément le terminal et le contenu des fichiers créés. Cette comparaison rend très concret le rôle de stdin, stdout et stderr.

Pour diagnostiquer une commande complexe, commencez par enregistrer stdout et stderr dans deux fichiers distincts. Une fois le comportement compris, vous pourrez décider de les conserver séparés ou de les réunir avec 2>&1.

Questions fréquentes

À quoi correspondent stdin, stdout et stderr dans Bash ?

Ce sont les trois flux standards utilisés par les commandes. stdin sert à lire des données, stdout à écrire le résultat normal et stderr à écrire les messages d’erreur.

Quelle différence entre > et >> ?

> écrit dans un fichier en remplaçant son contenu existant. >> ajoute la nouvelle sortie à la fin du fichier.

Que fait exactement 2>&1 ?

Cette écriture demande à Bash d’envoyer stderr vers la même destination que stdout. Elle sert à fusionner les deux flux pour les afficher, les enregistrer ou les transmettre ensemble.

Pourquoi un tube | ne transmet-il pas les erreurs par défaut ?

Parce qu’un tube relie la sortie standard de la commande de gauche à l’entrée standard de la commande de droite. Les messages d’erreur restent sur stderr tant que vous ne les redirigez pas explicitement.

À quoi sert /dev/null ?

/dev/null sert de destination ou de source vide. On peut y envoyer une sortie à ignorer, ou s’en servir comme entrée vide pour qu’une commande ne lise rien.

Quand faut-il séparer stdout et stderr ?

Séparez-les quand vous voulez exploiter un résultat propre sans y mélanger des diagnostics. C’est particulièrement utile pour générer un rapport d’un côté et conserver les erreurs dans un journal séparé.

Conclusion

Vous avez maintenant les gestes essentiels pour maîtriser les descripteurs de fichiers et les redirections Bash. En pratique, tout revient à identifier ce qu’une commande lit, ce qu’elle écrit normalement et ce qu’elle signale comme erreur.

Avec <, >, >>, 2>, 2>&1 et /dev/null, vous pouvez déjà construire des commandes bien plus propres et prévisibles. Répétez les cas pratiques de ce tutoriel dans un dossier de test : c’est le moyen le plus rapide d’ancrer ces réflexes.