Cómo concatenar cadenas en Bash: guía con ejemplos de código

En resumen.

• Concatenar cadenas en Bash es sencillo: coloca dos variables o literales uno junto al otro.
• Usa el operador += cuando construyas una cadena en varios pasos.
• printf permite controlar con precisión los espacios y saltos de línea.
• Heredoc maneja cadenas multilínea sin secuencias de escape complicadas.
• La mayoría de los errores provienen de comillas, espacios o variables no definidas.

Unir cadenas en Bash parece extraño la primera vez. No existe un operador +. Solo colocas las variables una junto a otra y funciona. Esta guía presenta las principales formas de concatenar cadenas en Bash, muestra problemas comunes y explica cuándo conviene elegir cada método.

Qué es el scripting en Bash

El scripting en Bash consiste en escribir pequeños programas para el shell Bash. Es una de las formas más comunes de shell scripting en Linux y se usa para automatización, administración de servidores, despliegues y código que conecta herramientas. Los scripts de Bash son archivos de texto plano que el shell lee de arriba abajo y ejecuta línea por línea.

La mayoría de los servidores Linux incluyen Bash de forma predeterminada. Por eso, crear un script de shell en Bash suele ser la forma más rápida de resolver una tarea. Escribes un archivo .sh, lo marcas como ejecutable y lo corres. No necesitas compilador ni proceso de build. Por eso resulta adecuado cuando el manejo de cadenas forma parte de una tarea más amplia.

Cuándo usar Bash para trabajar con cadenas

Usa scripting en Bash cuando las cadenas sean pequeñas, la lógica sea sencilla y el script deba ejecutarse solo con las herramientas ya disponibles en el sistema. Las variables y operaciones con cadenas de Bash ofrecen suficiente velocidad para generar configuraciones, analizar logs, crear nombres de archivos y automatizar tareas cortas.

Para procesar grandes cantidades de texto, otro lenguaje suele producir código más claro. Pero si necesitas unir algunas variables de Bash para formar una ruta o un mensaje, Bash es difícil de superar.

Qué es la concatenación de cadenas en Linux

La concatenación consiste en unir dos o más cadenas para crear una sola. En Bash, una cadena es una secuencia de caracteres guardada en una variable o escrita como literal. Para concatenarlas, colócalas una junto a otra sin ningún operador entre ellas.

first="hello"
second="world"
full="$first $second"
echo "$full"   # hello world

Esta es la idea en la que se basan casi todos los métodos que aparecen a continuación.

Método 1: yuxtaposición de variables

La forma más sencilla de concatenar cadenas en Bash es la yuxtaposición: coloca las variables una junto a otra dentro de una variable nueva o una cadena entre comillas.

name="Ada"
greeting="Hello, $name!"
echo "$greeting"   # Hello, Ada!

Sin operadores ni funciones. Solo necesitas respetar el orden y las comillas.

Concatenación de cadenas literales

Puedes concatenar cadenas literales del mismo modo: escríbelas dentro de un solo par de comillas o coloca dos fragmentos entre comillas uno junto al otro.

path="/var""/log"   # /var/log
message="user: ""$USER"

La segunda forma resulta útil cuando quieres mantener las partes de la cadena separadas visualmente sin dejar de unirlas.

Uso de llaves para delimitar variables

Cuando una variable de Bash está junto a texto que podría parecer parte de su nombre, enciérrala en ${}. Así evitas que Bash interprete la cadena de forma incorrecta.

file="report"
name="${file}_2026.txt"   # report_2026.txt

Sin las llaves, $file_2026 parecería una variable nueva. Las llaves son la solución más sencilla para uno de los errores más comunes en Bash.

Método 2: operador de anexado +=

El operador += es una forma abreviada de anexar texto a una cadena en Bash. Amplía una variable directamente, lo que resulta útil cuando quieres agregar texto sin reescribir su valor. La concatenación con += es clara y rápida.

log="Started"
log+=" at $(date)"
echo "$log"
# Output: Started at Mon May 11 17:20:00 CEST 2026

Cada += anexa texto al valor existente. No necesitas volver a escribir el nombre de la variable a la derecha ni corres el riesgo de olvidar un signo de dólar en medio de una cadena larga.

Construcción incremental de cadenas en loops

+= resulta especialmente útil dentro de loops. También funciona con arrays de Bash, lo que ayuda a recopilar elementos y convertirlos en una sola cadena al final. Este es el patrón para concatenar cadenas dentro de un loop:

result=""
for item in one two three; do
result+="$item,"
done
echo "${result%,}"   # one,two,three

Para datos similares a una lista, suele ser más claro usar arrays de Bash y unirlos con IFS (Internal Field Separator, la variable que Bash usa para decidir cómo dividir y unir campos) que construir una cadena paso a paso.

parts=(one two three)
IFS=','; joined="${parts[*]}"; unset IFS
echo "$joined"   # one,two,three

Método 3: concatenación con printf

printf resulta útil cuando necesitas controlar el formato con precisión. Es más estricto que echo, por lo que muchos scripts lo usan para imprimir en logs o pasar contenido a otra herramienta. En tareas de concatenación, printf también funciona como una forma clara de unir cadenas.

first="api"
second="contabo"
third="com"
url=$(printf "%s.%s.%s" "$first" "$second" "$third")
echo "$url"   # api.contabo.com

La cadena de formato define la estructura y cada %s toma un argumento. Así evitas resultados inesperados con las comillas y errores en los espacios.

Método 4: uso de here-strings y heredoc

Cuando una cadena ocupa más de una línea, manejar las comillas se complica rápidamente. Heredoc resuelve este problema. Permite escribir una cadena multilínea de Bash entre dos marcadores y asignarla a una variable sin escapar cada comilla. Úsalo cuando, de otro modo, necesitarías varias líneas con += o varios echo seguidos, como en el contenido de un archivo de configuración, una plantilla de correo o un mensaje de log multilínea.

message=$(cat <<EOF
Hello, $USER.
Your server is ready.
EOF
)
echo "$message"
# Output:
# Hello, yourname.
# Your server is ready.

Las variables se expanden dentro del bloque. Si quieres texto sin procesar y sin expansión, escribe el marcador inicial entre comillas: <<'EOF'. Esa es la diferencia entre una plantilla que inserta valores y un bloque literal que imprime exactamente lo que escribiste.

Este es el mismo patrón sin expansión. Resulta útil al escribir un fragmento de configuración que contiene signos de dólar literales:

config=$(cat <<'EOF'
host=$SERVER_HOST
port=$SERVER_PORT
EOF
)
echo "$config"
# Output:
# host=$SERVER_HOST
# port=$SERVER_PORT

Las here-strings son la variante más pequeña. Envían una sola cadena de Bash a un comando:

grep "error" <<< "$log"

Ambos patrones mantienen legible el manejo de cadenas multilínea en Bash.

Técnicas para manipular cadenas en Bash

La concatenación es solo una parte de la manipulación de cadenas en Bash. Después de crear la cadena, puedes usar operadores para extraer fragmentos, reemplazar contenido y consultar su longitud. En combinación con echo o printf, puedes dar forma a casi cualquier salida sin llamar herramientas externas.

Extracción y reemplazo de subcadenas

Para manipular cadenas, Bash usa ${var:offset:length} con subcadenas y ${var/old/new} para reemplazos. Estas expresiones trabajan directamente con las variables de Bash sin necesidad de sed o awk.

text="hello world"
echo "${text:0:5}"          # hello
echo "${text/world/bash}"   # hello bash

Es una opción breve, rápida e integrada en Bash.

Anexado de texto a cadenas multilínea

Puedes ampliar una cadena multilínea de Bash anexando más líneas con += y un salto de línea inicial. Otra opción es escribir un segundo heredoc y unir ambos bloques.

block=$(cat <<EOF
Line 1
Line 2
EOF
)
block+=$'\nLine 3'
echo "$block"

La sintaxis $'\n' inserta un salto de línea real. Es una alternativa más segura que intentar incluirlo dentro de comillas dobles.

Errores comunes con cadenas de Bash y cómo corregirlos

La mayoría de los errores con cadenas en scripts de Bash siguen unos cuantos patrones. Presta atención a estos casos para evitar los problemas más comunes.

• Olvidar las comillas en una variable con espacios: cp $file /tmp falla si $file contiene espacios. Usa cp "$file" /tmp.
• Omitir las llaves junto al texto: "$name_log" busca una variable llamada name_log. Escribe "${name}_log".
• Usar comillas simples cuando necesitas expansión: 'Hello $name' se imprime literalmente. Usa comillas dobles para interpolar.
• Las variables vacías producen cadenas vacías sin avisar: usa set -u para detectar pronto las variables no definidas.
• Mezclar arrays y cadenas sin cuidado: ${arr[*]} y ${arr[@]} se comportan de manera diferente dentro de comillas.

Muchos parecen simples detalles de estilo, pero no lo son. Son puntos en los que fallan scripts reales.

Preguntas frecuentes sobre la concatenación de cadenas en Bash