🇯🇵 日本語 | 🇺🇸 English | 🇪🇸 Español | 🇵🇹 Português | 🇹🇭 ไทย | 🇨🇳 中文

[Guía definitiva] 5 patrones de Bash que debes aprender y cómo evitar errores

En la serie de introducción a Bash hasta ahora, has adquirido la fuerza básica para manejar la pantalla negra, desde comandos básicos hasta la creación de scripts sencillos. ¿No has sentido que tus tareas diarias se han vuelto un poco más fáciles al combinar comandos? ¡Ha sido un gran trabajo!

Ahora, para concluir nuestra serie sobre Bash, esta vez daremos un paso más allá para pasar de un script que "simplemente funciona" a uno que es "seguro, legible y menos propenso a errores", es decir, un script profesional. Te enseñaremos 5 patrones especialmente importantes y cómo evitar las "trampas" en las que suelen caer los principiantes.

Lo que vamos a presentar no son comandos nuevos y difíciles. Se trata de "cómo usar correctamente" los conocimientos que ya has adquirido, algo así como los trucos para conducir. Al igual que un conductor novato aprende técnicas para conducir de forma segura en días de lluvia o por la noche, con el artículo de hoy, tú también dominarás cómo escribir scripts que puedas ejecutar con confianza en cualquier situación.

Patrón 1: ¡Encierra siempre las variables entre "comillas dobles"!

Esta es la regla de oro absoluta en la escritura de scripts de Bash. Omitir el uso de comillas dobles " " para encerrar las variables es la principal causa de errores inesperados. El problema se vuelve especialmente evidente cuando una variable contiene espacios.

Error común: variables sin comillas

Por ejemplo, echemos un vistazo al siguiente script que intenta crear un directorio con un espacio en su nombre.

#!/bin/bash
DIR_NAME="My Project"
mkdir $DIR_NAME

Al ejecutar este script, Bash lo interpreta como el comando mkdir My Project, lo que resulta en la creación de dos directorios separados, "My" y "Project". Este no es el resultado deseado.

Mejor práctica: encerrar las variables en " "

Para solucionar este problema, solo tienes que encerrar la variable entre comillas dobles. Esto hace que Bash reconozca correctamente toda la cadena de texto, incluido el espacio, como "una sola unidad".

#!/bin/bash
DIR_NAME="My Project"
mkdir "$DIR_NAME" # ¡Encierra la variable entre comillas dobles!
echo "Directorio '$DIR_NAME' creado."

Este simple hábito hará que tus scripts sean mucho más robustos. Grábate esto en la mente: "Encierra siempre tus variables entre comillas dobles".

Patrón 2: Diseño seguro que se detiene inmediatamente ante un error

Lo aterrador de los scripts de Bash es que, incluso si un comando a mitad de camino falla, continúan ejecutando el resto de las operaciones sin inmutarse. Por ejemplo, en un script que debe "moverse a un directorio y luego eliminar un archivo dentro de él", ¿qué pasaría si el movimiento falla? Podría ocurrir un desastre en el que se elimine un archivo en una ubicación no deseada.

Para evitar esto, escribe el siguiente "hechizo mágico" al principio de tu script.

set -e

set -e es un "interruptor de seguridad" que interrumpe inmediatamente la ejecución del script si alguno de los comandos ejecutados dentro de él falla. Veamos su efecto en el siguiente script.

#!/bin/bash
set -e # Activa el interruptor de seguridad

echo "Iniciando proceso..."

# Intenta moverse a un directorio inexistente, lo que causará un error aquí
cd /non-existent-directory

# Debido a set -e, esta línea nunca se ejecutará
echo "Este mensaje no se mostrará."

Al ejecutar este script, el proceso se detendrá en el momento en que falle el comando cd, y el último echo no se ejecutará. Acostúmbrate a incluir esta línea en cualquier script que realice operaciones importantes.

Patrón 3: Guardar el resultado de un comando en una variable

Al escribir scripts, te encontrarás frecuentemente con situaciones en las que quieres "usar el 'resultado' de un comando en otro comando o variable". Por ejemplo, podrías querer incluir la fecha de hoy en un nombre de archivo de copia de seguridad.

Para esto, usamos una función llamada Sustitución de Comandos (Command Substitution). La sintaxis es $(comando).

#!/bin/bash
set -e

# Obtiene la fecha de hoy en formato AAAA-MM-DD y la guarda en una variable
TODAY=$(date "+%Y-%m-%d")

# Incorpora la fecha en el nombre del archivo
BACKUP_FILENAME="backup_${TODAY}.tar.gz"

echo "Nombre del archivo de copia de seguridad: $BACKUP_FILENAME"
# tar -czf "$BACKUP_FILENAME" /ruta/a/la/fuente/de/backup

La parte $(date "+%Y-%m-%d") se reemplaza por el resultado de la ejecución del comando date (ej: 2025-07-06). Esto te permite generar fácilmente nombres de archivo dinámicos y descriptivos.

Patrón 4: Procesar archivos de forma segura, línea por línea

Leer un archivo de texto (una lista de dominios, una lista de URLs, etc.) y realizar alguna acción para cada línea es un caso de uso típico de un script. Sin embargo, este proceso tiene una "trampa" en la que los principiantes suelen caer.

Patrón incorrecto común

Una sintaxis como for line in $(cat file.txt) debe evitarse porque no puede procesar correctamente los casos en que un archivo contiene espacios.

Mejor práctica segura: el bucle `while read`

El patrón estándar para procesar un archivo de forma segura y eficiente, línea por línea, es el bucle while read. Puede parecer un poco complicado, pero lo mejor es memorizarlo en esta forma.

Primero, preparemos un archivo de lista para procesar, domains.txt.

example.com
example.net
example.org

A continuación, aquí está el script que lee este archivo y lo procesa.

#!/bin/bash
set -e

INPUT_FILE="domains.txt"

while IFS= read -r line
do
  echo "Procesando dominio: $line"
  # Aquí realizarías acciones como ping "$line" o curl "http://$line/"
done < "$INPUT_FILE"

Esta sintaxis se puede aplicar al procesamiento de cualquier archivo de texto porque conserva los espacios iniciales y finales de una línea y maneja correctamente los caracteres especiales.

Patrón 5: Crear y eliminar archivos temporales de forma segura

En medio de la ejecución de un script, es posible que necesites un archivo temporal para trabajar. En este caso, codificar un nombre de archivo como /tmp/my_temp_file es peligroso. Si otro programa está usando un archivo con el mismo nombre, o si se ejecutan varias instancias del script al mismo tiempo, el archivo podría ser sobrescrito.

Para crear un archivo temporal de forma segura, usa el comando mktemp. Esto crea un archivo vacío con un nombre único que no entrará en conflicto con nada más.

#!/bin/bash
set -e

# Crea un archivo temporal seguro y guarda su nombre en una variable
TEMP_FILE=$(mktemp)

# Elimina siempre el archivo temporal cuando el script termine (por éxito, error o interrupción)
trap 'rm -f "$TEMP_FILE"' EXIT

echo "Archivo temporal creado: $TEMP_FILE"
echo "Escribiendo datos en este archivo..."
echo "some temporary data" > "$TEMP_FILE"

echo "Contenido del archivo:"
cat "$TEMP_FILE"

echo "Proceso completado. El archivo temporal se eliminará automáticamente."

Además, al combinarlo con el comando trap, puedes programar una acción de limpieza para "eliminar siempre este archivo temporal al final, sin importar por qué termine el script". Esto evita que queden archivos basura innecesarios en el servidor.

Resumen

¡Buen trabajo! Con esto, concluimos nuestra serie de introducción a Bash. En esta última entrega, aprendiste 5 patrones importantes para elevar tus scripts de "juguetes" a "herramientas profesionales".

Solo con ser consciente de estos patrones, los scripts que escribas aumentarán significativamente su fiabilidad y mantenibilidad, haciéndolos fáciles de leer para tu yo futuro u otras personas. Por favor, úsalos en la creación de tus futuros scripts. ¡Esperamos sinceramente que tu vida en el desarrollo web, ahora armada con la poderosa herramienta de Bash, se vuelva aún más creativa y eficiente!

Plantillas Relacionadas