HOWTO · Bash
Cómo crear una cadena de varias líneas en Bash
Aprende cinco formas de crear texto de varias líneas en Bash y escribirlo en un archivo con un here-document, una variable, printf y dos enfoques con echo.
En esta página
Bash puede escribir texto de varias líneas en un archivo mediante un here-document, una variable, printf o echo. Estos cinco ejemplos muestran cómo funciona cada método y cómo elegir uno según el texto. Para un bloque breve y fijo, un here-document mantiene el texto legible en el script. Una variable resulta útil si necesitas reutilizar o preparar el texto primero. printf ofrece control explícito sobre los finales de línea, mientras que los dos ejemplos con echo sirven para texto sencillo o secuencias de escape.
Usar here-document para crear una cadena de varias líneas en Bash
Un here-document pasa a la entrada estándar de un comando las líneas que se encuentran entre <<'EOF' y el delimitador coincidente EOF. En este caso, cat lee esas líneas y > redirige su salida a output.txt, reemplazando el archivo si ya existe. Al poner el delimitador entre comillas, el cuerpo se mantiene literal: el shell no expande las variables ni otras expresiones que contiene. Escribe el delimitador en una línea por sí solo, sin caracteres adicionales después, para que Bash pueda reconocer dónde termina el cuerpo.
El archivo contiene:
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
!
El comando escribe directamente en el archivo, por lo que resulta práctico cuando el texto se conoce de antemano y debe reemplazar el contenido anterior. Para añadir líneas después del contenido existente, usa la redirección de anexado (>>). En un script, elige una ruta de archivo en la que el script tenga permiso para escribir y usa el mismo delimitador al principio y al final del here-document. Se conservan los espacios iniciales normales del cuerpo. Para código fuente indentado, Bash también admite <<-, que elimina los caracteres de tabulación iniciales, pero no los espacios normales.
Usar una variable del shell para crear una cadena de varias líneas en Bash
Una asignación entre comillas puede contener saltos de línea literales. Al escribir la variable, expándela entre comillas dobles para que esos saltos sigan formando parte de una sola cadena y no se aplique la división de palabras. Este patrón resulta útil cuando preparas un valor una vez y luego lo envías a varios comandos o archivos; mantén entre comillas la expansión cada vez que lo uses.
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
!
La expansión entre comillas "$greet" conserva los saltos de línea de la variable. Esto resulta útil cuando preparas o reutilizas el texto antes de escribirlo. El printf final añade un salto de línea después del valor; si el texto almacenado ya termina con uno, ese formato añade otro más.
Usar printf para crear una cadena de varias líneas en Bash
Usa printf cuando quieras controlar el formato de manera explícita. El formato %s\n escribe cada argumento como texto seguido de un salto de línea, y > envía esa salida al archivo. Cada argumento queda en una línea distinta, lo que permite ver con claridad la relación entre los valores y la salida.
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
!
Este método ofrece resultados previsibles con texto arbitrario porque printf trata las palabras proporcionadas como datos, en vez de interpretarlas como directivas de formato. Mantén la cadena de formato separada de los valores que puedan contener caracteres %. Si la entrada ya está en una variable con varias líneas, pásala como un solo argumento con printf '%s\n' "$greet" en lugar de insertar su valor en la cadena de formato.
Usar echo con la opción -e para crear una cadena de varias líneas en Bash
La opción -e indica a echo que interprete secuencias de escape como \n. Puede ser una forma concisa de escribir texto fijo, aunque el comportamiento de echo -e varía según el shell; usa printf si necesitas un formato uniforme entre shells. El siguiente ejemplo mantiene las secuencias de escape dentro de un argumento entre comillas y redirige el texto resultante al archivo.
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
!
Las comillas simples mantienen intactas las secuencias de barra invertida hasta que echo las interpreta. La redirección escribe las líneas resultantes en el archivo. Como el comportamiento de la opción depende del shell, evita esta forma si el script debe producir un formato idéntico en distintos entornos de shell.
Usar echo para crear una cadena de varias líneas en Bash
Si una variable ya contiene saltos de línea literales, echo "$greet" entre comillas los escribe como saltos de línea sin necesidad de interpretar secuencias de escape. Este método se distingue del uso de -e con secuencias de barra invertida. Es práctico para un valor sencillo, aunque printf es mejor cuando necesitas controlar el salto de línea final o dar formato explícito a los valores.
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
!
Las comillas dobles conservan los saltos de línea incluidos en la variable y evitan la división de palabras. echo también añade un salto de línea final, lo cual es adecuado para archivos de texto corrientes. Elige > si el archivo debe contener únicamente este texto; usa >> si quieres añadirlo después del contenido existente.
