Comment créer une chaîne multiligne dans Bash

Bash peut écrire du texte sur plusieurs lignes dans un fichier à l’aide d’un here-document, d’une variable, de printf ou de echo. Ces cinq exemples montrent le fonctionnement de chaque méthode et comment choisir celle qui convient à votre texte. Pour un court bloc fixe, un here-document rend le texte lisible dans le script. Une variable est utile si vous devez réutiliser ou préparer le texte au préalable. printf permet de contrôler précisément les fins de ligne, tandis que les deux exemples avec echo conviennent au texte simple ou aux séquences d’échappement.

Utiliser un here-document pour créer une chaîne multiligne dans Bash

Un here-document transmet à l’entrée standard d’une commande les lignes comprises entre <<'EOF' et le délimiteur correspondant EOF. Ici, cat lit ces lignes et > redirige sa sortie vers output.txt, en remplaçant le fichier s’il existe déjà. Le fait de placer le délimiteur entre guillemets conserve le corps du texte tel quel : le shell n’y développe donc ni variables ni autres expressions. Placez le délimiteur seul sur une ligne, sans aucun caractère après lui, afin que Bash puisse reconnaître la fin du corps.

Le fichier contient :

tmp_dir=$(mktemp -d)
trap 'rm -rf "$tmp_dir"' EXIT
output_file="$tmp_dir/output.txt"
cat > "$output_file" <<'EOF'
Hello
World
!
EOF
cat "$output_file"

Hello
World
!

La commande écrit directement dans le fichier ; elle est donc pratique lorsque le texte est connu à l’avance et doit remplacer le contenu précédent. Pour ajouter des lignes à la suite du contenu existant, utilisez plutôt la redirection en ajout (>>). Dans un script, choisissez un chemin de fichier accessible en écriture et utilisez le même délimiteur aux deux extrémités du here-document. Les espaces ordinaires au début des lignes du corps sont conservés. Pour du code source indenté, Bash prend aussi en charge <<-, qui supprime les tabulations initiales, mais pas les espaces ordinaires.

Utiliser une variable de shell pour créer une chaîne multiligne dans Bash

Une affectation entre guillemets peut contenir des retours à la ligne littéraux. Lors de l’écriture, développez la variable entre guillemets doubles afin que ces retours restent dans une seule chaîne au lieu d’être soumis au découpage en mots. Cette approche est utile lorsque vous assemblez une valeur une seule fois avant de la transmettre à plusieurs commandes ou fichiers ; conservez l’expansion entre guillemets à chaque utilisation.

tmp_dir=$(mktemp -d)
trap 'rm -rf "$tmp_dir"' EXIT
output_file="$tmp_dir/multiline.txt"
greet="Hello,
World
!"
printf '%s\n' "$greet" > "$output_file"
cat "$output_file"

Hello,
World
!

L’expansion entre guillemets "$greet" préserve les retours à la ligne de la variable. Cette méthode est utile si le texte est assemblé ou réutilisé avant d’être écrit. Le printf final ajoute un retour à la ligne après la valeur ; si le texte stocké se termine déjà par un retour à la ligne, ce format en ajoute un autre.

Utiliser printf pour créer une chaîne multiligne dans Bash

Utilisez printf lorsque vous souhaitez contrôler explicitement la mise en forme. Le format %s\n écrit chaque argument sous forme de texte, suivi d’un retour à la ligne, et > envoie cette sortie dans le fichier. Chaque argument devient une ligne distincte, ce qui rend facile à comprendre le lien entre les valeurs et le résultat.

tmp_dir=$(mktemp -d)
trap 'rm -rf "$tmp_dir"' EXIT
output_file="$tmp_dir/multiline.txt"
printf '%s\n' 'Hello' ',' 'World' '!' > "$output_file"
cat "$output_file"

Hello
,
World
!

Cette méthode donne un résultat prévisible avec du texte quelconque, car printf traite les mots fournis comme des données au lieu de les interpréter comme des directives de format. Séparez la chaîne de format des valeurs susceptibles de contenir des caractères %. Si l’entrée est déjà une variable multiligne, transmettez-la comme un seul argument avec printf '%s\n' "$greet" au lieu de placer sa valeur dans la chaîne de format.

Utiliser echo avec l’option -e pour créer une chaîne multiligne dans Bash

L’option -e demande à echo d’interpréter les séquences d’échappement telles que \n. Cette forme peut être concise pour du texte fixe, mais le comportement de echo -e varie selon les shells ; préférez printf si vous avez besoin d’une mise en forme cohérente d’un shell à l’autre. L’exemple suivant conserve les séquences d’échappement dans un argument entre guillemets et redirige le texte obtenu vers le fichier.

tmp_dir=$(mktemp -d)
trap 'rm -rf "$tmp_dir"' EXIT
output_file="$tmp_dir/multiline.txt"
echo -e 'Hello\n,\nWorld\n!' > "$output_file"
cat "$output_file"

Hello
,
World
!

Les guillemets simples préservent les séquences avec barre oblique inverse jusqu’à ce que echo les interprète. La redirection écrit les lignes obtenues dans le fichier. Comme le comportement de l’option dépend du shell, évitez cette forme lorsqu’un script doit produire une mise en forme identique dans différents environnements de shell.

Utiliser echo pour créer une chaîne multiligne dans Bash

Si une variable contient déjà des retours à la ligne littéraux, echo "$greet" les écrit comme des sauts de ligne, sans interprétation des séquences d’échappement. Cette méthode se distingue de l’utilisation de -e avec des séquences contenant des barres obliques inverses. Elle est pratique pour une valeur simple, mais printf convient mieux si vous devez contrôler le retour à la ligne final ou mettre explicitement les valeurs en forme.

tmp_dir=$(mktemp -d)
trap 'rm -rf "$tmp_dir"' EXIT
output_file="$tmp_dir/multiline.txt"
greet="Hello
,
World
!"
echo "$greet" > "$output_file"
cat "$output_file"

Hello
,
World
!

Les guillemets doubles préservent les retours à la ligne intégrés à la variable et empêchent le découpage en mots. echo ajoute également un retour à la ligne final, ce qui convient aux fichiers texte ordinaires. Choisissez > si le fichier doit contenir uniquement ce texte ; utilisez >> si le nouveau texte doit être ajouté à la suite du contenu existant.