Maîtriser les here-documents et here-strings Bash

Difficulté

Facile

Les here-documents et here-strings font partie des outils Bash les plus utiles pour écrire des scripts lisibles. Ils permettent d’envoyer du texte à une commande directement dans le script, sans créer de fichier temporaire ni enchaîner des lignes difficiles à relire.

Dans ce tutoriel, vous allez manipuler les trois formes les plus courantes : <<, <<- et <<<. L’objectif est pratique : produire du texte proprement, comprendre ce qui est développé par le shell et éviter les pièges classiques.

Prérequis

• Un shell Bash disponible sur votre machine.
• Un terminal.
• Un éditeur de texte pour enregistrer un petit script, par exemple nano ou vim.
• Les commandes de base cat, wc, sed ou grep sont utiles pour les exemples.

Matériel nécessaire

• Terminal Bash
• Éditeur de texte
• Commandes de base Unix

Étapes

1. 1

   Créer un premier here-document avec cat

   Commencez par ouvrir un terminal, puis lancez cette commande :

   cat <<EOF
   Bonjour
   Ceci est un here-document.
   Il envoie plusieurs lignes à cat.
   EOF

   Le texte situé entre EOF et la ligne finale EOF est envoyé sur l’entrée standard de cat. Vous obtenez donc l’affichage exact de ces lignes dans le terminal.

2. 2

   Écrire un fichier de test avec un here-document

   Utilisez maintenant la même technique pour créer un fichier sans ouvrir d’éditeur :

   cat > exemple.txt <<EOF
   ligne 1
   ligne 2
   ligne 3
   EOF

   Affichez ensuite le résultat avec cat exemple.txt. Cette forme est très pratique pour générer rapidement un fichier de configuration, un brouillon de script ou un jeu de données de test.

3. 3

   Développer des variables dans un bloc non quoté

   Définissez une variable, puis insérez-la dans un here-document non quoté :

   nom="Ada"
   cat <<EOF
   Bonjour $nom
   Nous testons un bloc avec développement.
   EOF

   Bash remplace ici $nom par sa valeur avant d’envoyer le texte à cat. Cette forme est utile quand vous voulez fabriquer une sortie dynamique dans un script.

4. 4

   Bloquer les développements avec un délimiteur quoté

   Testez maintenant un here-document dont le délimiteur est quoté :

   nom="Ada"
   cat <<'EOF'
   Bonjour $nom
   Cette ligne garde le dollar tel quel.
   EOF

   Cette fois, la sortie affiche $nom littéralement. C’est la bonne méthode pour écrire un bloc de texte qui doit rester intact, par exemple quand vous préparez un contenu contenant des caractères de shell.

5. 5

   Comparer rapidement les deux comportements

   Créez un petit script pour visualiser la différence côte à côte :

   nom="Ada"
   
   echo "--- non quoté ---"
   cat <<EOF
   Salut $nom
   EOF
   
   echo "--- quoté ---"
   cat <<'EOF'
   Salut $nom
   EOF

   Exécutez-le et observez la sortie. Dans le premier bloc, la variable est remplacée ; dans le second, elle reste visible comme texte brut.

6. 6

   Envoyer plusieurs lignes à une commande de filtrage

   Les here-documents sont utiles au-delà de cat. Essayez par exemple avec grep :

   grep "erreur" <<EOF
   info: démarrage
   erreur: fichier absent
   info: arrêt
   EOF

   La commande ne retient que la ligne contenant erreur. Vous pouvez ainsi tester un filtre rapidement, sans créer de fichier source sur le disque.

7. 7

   Compter et transformer du texte sans fichier temporaire

   Essayez maintenant une commande de comptage :

   wc -l <<EOF
   alpha
   beta
   gamma
   EOF

   Puis testez une transformation simple :

   sed 's/a/A/g' <<EOF
   banana
   ananas
   EOF

   Ces exemples montrent qu’un here-document sert très bien à alimenter ponctuellement une commande dans une démonstration, un test ou un script d’automatisation.

8. 8

   Indenter proprement avec <<-

   

   Quand un here-document se trouve dans une structure comme une fonction, une boucle ou un if, son indentation peut vite devenir gênante. Testez la variante <<- :

   cat <<-EOF
   	ligne indentée dans le script
   	deuxième ligne
   EOF

   La sortie ne conserve pas les tabulations de début de ligne utilisées dans le bloc. Cela permet d’indenter le script tout en produisant un texte final propre.

9. 9

   Tester la différence entre << et <<-

   Faites un essai comparatif dans un petit script :

   echo "--- avec << ---"
   cat <<EOF
   	texte avec tabulation initiale
   EOF
   
   echo "--- avec <<- ---"
   cat <<-EOF
   	texte avec tabulation initiale
   EOF

   Selon votre affichage, la première forme garde la tabulation initiale alors que la seconde la retire. C’est la distinction essentielle à retenir entre ces deux syntaxes.

10. 10

    Passer une courte chaîne avec une here-string

    

    Utilisez maintenant la forme <<< pour envoyer une seule chaîne à une commande :

    wc -w <<< "un deux trois"

    La chaîne est fournie directement à l’entrée standard de wc. Pour une donnée courte sur une seule ligne, cette écriture est souvent plus compacte qu’un here-document complet.

11. 11

    Nettoyer une valeur avant traitement avec <<<

    La here-string est utile pour envoyer le contenu d’une variable à une commande de transformation :

    ligne="  Bonjour Linux  "
    sed 's/^ *//; s/ *$//' <<< "$ligne"

    Dans cet exemple, sed reçoit la valeur de la variable et retire les espaces en début et en fin de ligne. Vous pouvez appliquer le même principe avec d’autres commandes qui lisent sur l’entrée standard.

12. 12

    Choisir la bonne forme selon la taille du texte

    Faites un mini-réflexe de sélection dans vos scripts. Prenez << pour un bloc multiligne, <<- pour ce même bloc quand vous voulez l’indenter avec des tabulations, et <<< pour une chaîne courte.

    # bloc multiligne
    cat <<EOF
    ligne A
    ligne B
    EOF
    
    # bloc multiligne indenté avec tabulations
    cat <<-EOF
    	ligne A
    	ligne B
    EOF
    
    # chaîne courte
    grep "Linux" <<< "Bonjour Linux"

    Ce simple tri rend vos scripts plus homogènes. Il aide aussi les autres lecteurs à comprendre immédiatement la forme choisie.

13. 13

    Intégrer un here-document dans un script Bash

    

    Créez maintenant un vrai script de démonstration dans un fichier demo.sh :

    #!/usr/bin/env bash
    nom="Ada"
    
    cat <<EOF
    Rapport simple
    Utilisateur: $nom
    Statut: test
    EOF
    
    grep "test" <<< "statut: test OK"

    Rendez-le exécutable avec chmod +x demo.sh, puis lancez-le avec ./demo.sh. Vous combinez ici un bloc lisible sur plusieurs lignes et une chaîne courte passée à une commande de filtrage.

14. 14

    Éviter les délimiteurs ambigus dans les gros blocs

    Quand le contenu devient long, choisissez un délimiteur explicite pour limiter les confusions :

    cat <<FIN_MESSAGE
    Ceci est un message plus long.
    Le délimiteur est plus parlant que EOF.
    FIN_MESSAGE

    Vous réduisez ainsi le risque de perdre la ligne de fermeture dans un grand script. Un nom de fin cohérent avec le contenu améliore aussi la relecture.

15. 15

    Vérifier la sortie avant d’automatiser

    Avant d’intégrer ces techniques dans un script plus long, testez toujours le rendu avec des commandes simples comme cat, wc ou grep. Cela permet de voir immédiatement si le texte, l’indentation ou les variables se comportent comme prévu.

    valeur="Linux"
    cat <<EOF
    Test: $valeur
    EOF
    
    grep "Linux" <<< "$valeur"

    Une fois le comportement validé, réutilisez le même motif dans votre script principal. Vous évitez ainsi des erreurs discrètes plus loin dans l’automatisation.

Erreurs fréquentes & dépannage

• Confondre délimiteur quoté et non quoté : avec un délimiteur non quoté, les variables comme $nom sont développées ; avec un délimiteur quoté, elles restent littérales.
• Mal fermer le bloc : la ligne de fin doit reprendre exactement le délimiteur attendu, seule sur sa ligne.
• Utiliser des espaces avec <<- : cette variante retire les tabulations de début de ligne, pas les espaces.
• Choisir <<< pour un long texte : une here-string est plus adaptée à une chaîne courte qu’à un bloc multiligne lisible.
• Oublier de tester la sortie : un petit essai avec cat ou grep aide à repérer rapidement un comportement inattendu.

Astuces & pour aller plus loin

• Choisissez un délimiteur parlant comme FIN_SQL, CONFIG ou MESSAGE quand le bloc a un rôle précis.
• Placez les données de test directement dans un here-document pour documenter en même temps le comportement attendu d’une commande.
• Préférez un délimiteur quoté quand vous devez afficher du texte contenant des variables Bash sans qu’elles soient remplacées.
• Réservez <<< aux cas courts et immédiats, pour garder une lecture claire du script.

Questions fréquentes

Quelle différence retenir entre << et <<< ?

<< ouvre un here-document, donc un bloc de texte sur plusieurs lignes jusqu’à un délimiteur de fin. <<< envoie une chaîne courte directement à l’entrée standard d’une commande.

Quand utiliser <<- plutôt que << ?

Utilisez <<- quand vous voulez indenter le bloc dans votre script avec des tabulations tout en évitant de retrouver ces tabulations dans la sortie. Si cette suppression n’est pas utile, << suffit.

Pourquoi ma variable n’est-elle pas remplacée dans le bloc ?

Le cas le plus courant est l’emploi d’un délimiteur quoté, par exemple <<'EOF'. Dans cette forme, le contenu est conservé littéralement.

Puis-je choisir un autre mot que EOF ?

Oui. Le délimiteur peut être un autre mot, tant que vous utilisez exactement le même à l’ouverture et à la fermeture du here-document.

Les here-documents remplacent-ils toujours un fichier temporaire ?

Ils sont très pratiques pour de nombreux tests et scripts courts, car ils évitent souvent de créer un fichier intermédiaire. Dans ce tutoriel, ils servent surtout à fournir du texte directement à une commande de façon lisible.

Conclusion

Vous savez maintenant utiliser les trois formes essentielles : << pour un bloc multiligne, <<- pour un bloc indenté avec tabulations, et <<< pour une chaîne courte. En pratique, le bon choix dépend surtout de la lisibilité recherchée et du comportement attendu sur le texte injecté.

Le point décisif à maîtriser est le suivant : un délimiteur non quoté permet le développement des variables, alors qu’un délimiteur quoté garde le contenu littéral. Avec ce réflexe et quelques tests simples, vos scripts Bash deviennent plus propres, plus clairs et plus faciles à maintenir.