Estrategias de Bucle Potentes: Iterando Archivos y Listas en Scripts Bash

Los bucles en Bash son donde los pequeños comandos de shell se convierten en automatización útil. Ya sea que necesites procesar cada archivo en un directorio, realizar una tarea un número determinado de veces o leer datos de configuración línea por línea, los bucles te proporcionan la estructura para repetir el trabajo sin copiar y pegar comandos.

Los dos bucles que usarás más a menudo son for y while. Usa for cuando ya tengas un conjunto conocido de elementos, como un array o un glob de archivos. Usa while cuando el bucle esté impulsado por una condición o por la lectura de entrada. Esta simple división mantiene muchos scripts más fáciles de razonar.

---

El Bucle for: Iterando sobre Conjuntos Fijos

El bucle for es ideal cuando conoces de antemano la colección de elementos que necesitas procesar. Esta colección puede ser una lista explícita de valores, los resultados de un comando o un conjunto de archivos encontrados mediante globbing.

1. Iterando sobre Listas Estándar

El caso de uso más simple es iterar sobre una lista corta de palabras escritas directamente en el script.

Sintaxis

for VARIABLE in LISTA_DE_ELEMENTOS; do
    # Comandos usando $VARIABLE
done

Ejemplo: Procesando una Lista de Usuarios

# Lista de usuarios a procesar
USUARIOS="alice bob charlie"

for usuario in $USUARIOS; do
  echo "Verificando el directorio home para $usuario..."
  if [ -d "/home/$usuario" ]; then
    echo "$usuario está activo."
  else
    echo "Advertencia: El directorio home de $usuario falta."
  fi
done

Ese patrón está bien para nombres simples. Si un elemento puede contener espacios, usa un array en lugar de una cadena separada por espacios:

USUARIOS=("alice" "bob" "mary jane")

for usuario in "${USUARIOS[@]}"; do
  echo "Verificando $usuario"
done

2. Iteración Numérica al Estilo C

Para tareas que requieren contar o secuencias numéricas específicas, Bash admite un bucle for al estilo C, a menudo combinado con la expansión de llaves o el comando seq.

Sintaxis (Estilo C)

for (( INICIALIZACIÓN; CONDICIÓN; INCREMENTO )); do
    # Comandos
done

Ejemplo: Script de Cuenta Regresiva

# Bucle 5 veces (i comienza en 1, continúa mientras i sea menor o igual a 5)
for (( i=1; i<=5; i++ )); do
  echo "Número de iteración: $i"
  sleep 1
done
echo "¡Hecho!"

Alternativa: Usando Expansión de Llaves para Secuencias Simples

La expansión de llaves es más simple y rápida que usar seq para generar enteros o secuencias contiguas.

# Genera números del 10 al 1
for num in {10..1}; do
  echo "Contando hacia atrás: $num"
done

3. Iterando sobre Archivos y Directorios (Globbing)

Usar comodines (*) dentro del bucle for te permite procesar archivos que coinciden con un patrón específico, como todos los archivos de registro o todos los scripts en un directorio.

Ejemplo: Archivando Archivos de Registro

Cita la variable ("$archivo") cuando trabajes con nombres de archivo, especialmente aquellos que contienen espacios o caracteres especiales.

DIRECTORIO_DESTINO="/var/log/aplicacion"

# Bucle sobre todos los archivos que terminan en .log en el directorio destino
for archivo_log in "$DIRECTORIO_DESTINO"/*.log; do

  # Verifica si el archivo realmente existe (evita ejecutar sobre el literal "*.log" si no hay archivos que coincidan)
  if [ -f "$archivo_log" ]; then
    echo "Comprimiendo $archivo_log..."
    gzip "$archivo_log"
  fi
done

El Bucle while: Ejecución Basada en Condiciones

El bucle while continúa ejecutando un bloque de comandos mientras una condición especificada siga siendo verdadera. Se usa comúnmente para leer flujos de entrada, monitorear condiciones o manejar tareas donde se desconoce el número de iteraciones.

1. Bucle while Básico

Sintaxis

while CONDICIÓN; do
    # Comandos
done

Ejemplo: Esperando un Recurso

Este bucle usa el comando test ([ ]) para verificar si un directorio existe antes de continuar.

RUTA_RECURSO="/mnt/datos/compartido"

while [ ! -d "$RUTA_RECURSO" ]; do
  echo "Esperando a que el recurso $RUTA_RECURSO esté montado..."
  sleep 5
done

echo "El recurso está disponible. Iniciando copia de seguridad."

2. El Patrón Robusto while read

La aplicación más poderosa del bucle while es leer el contenido de un archivo o flujo de salida línea por línea. Este patrón es muy superior a usar un bucle for en la salida de cat, ya que maneja de manera fiable espacios y caracteres especiales.

Mejor Práctica: Leyendo Línea por Línea

Para garantizar la máxima robustez, utilizamos tres componentes clave:

1. IFS=: Limpia el Separador de Campos Interno, asegurando que la línea completa, incluidos los espacios iniciales/finales, se lea en la variable.
2. read -r: La opción -r evita la interpretación de barras invertidas (lectura sin procesar), lo cual es crítico para rutas y cadenas complejas.
3. Redirección de Entrada (<): Redirige el contenido del archivo dentro del bucle, asegurando que el bucle se ejecute en el contexto del shell actual (evitando problemas de subcapa).

# Archivo que contiene datos, un elemento por línea
ARCHIVO_CONFIG="/etc/app/servidores.txt"

while IFS= read -r nombre_servidor; do
  
  # Saltar líneas vacías o comentadas
  if [[ -z "$nombre_servidor" || "$nombre_servidor" =~ ^# ]]; then
    continue
  fi

  echo "Haciendo ping al servidor: $nombre_servidor"
  ping -c 1 "$nombre_servidor"

done < "$ARCHIVO_CONFIG"

Consejo: Evitando cat en Bucles

Prefiere while ... done < archivo sobre cat archivo | while ... al leer un archivo. En la mayoría de las configuraciones de Bash, una tubería ejecuta el bucle en una subcapa, por lo que las variables cambiadas dentro del bucle se pierden cuando el bucle termina.

3. Manejando Nombres de Archivo desde find

Para el procesamiento recursivo de archivos, evita analizar la salida simple de find línea por línea. Los nombres de archivo pueden contener espacios y, raramente, nuevas líneas. Usa la salida delimitada por nulos:

find /var/log/aplicacion -type f -name '*.log' -print0 |
while IFS= read -r -d '' archivo_log; do
  echo "Encontrado registro: $archivo_log"
  gzip -- "$archivo_log"
done

El par -print0 y read -d '' trata el byte nulo como separador. El -- antes de "$archivo_log" le dice a gzip que los siguientes valores son operandos, no opciones, lo que te protege de nombres de archivo que comienzan con -.

Control Avanzado de Bucles y Técnicas

Los scripts efectivos requieren la capacidad de controlar la ejecución del bucle basándose en condiciones de tiempo de ejecución.

1. Controlando el Flujo: break y continue

• break: Sale inmediatamente de todo el bucle, independientemente de las iteraciones o condiciones restantes.
• continue: Salta la iteración actual y salta inmediatamente a la siguiente iteración (o reevalúa la condición while).

Ejemplo: Buscar y Detener

OBJETIVO_BUSQUEDA="target.conf"

for archivo in /etc/*; do
  if [ -f "$archivo" ] && [[ "$archivo" == *"$OBJETIVO_BUSQUEDA"* ]]; then
    echo "Configuración objetivo encontrada en: $archivo"
    break  # Dejar de procesar una vez encontrado
  elif [ -d "$archivo" ]; then
    continue # Saltar directorios, solo verificar archivos
  fi
  echo "Verificando archivo: $archivo"
done

2. Manejando Delimitadores Complejos usando IFS

Mientras que leer archivos línea por línea requiere limpiar IFS, iterar sobre una lista separada por un carácter diferente (como una coma) requiere establecer temporalmente IFS.

DATOS_CSV="dato1,dato2,dato3,dato4"
IFS_ANTIGUO=$IFS # Guardar el IFS original
IFS=','       # Establecer IFS al carácter de coma

for elemento in $DATOS_CSV; do
  echo "Elemento encontrado: $elemento"
done

IFS=$IFS_ANTIGUO # Restaurar el IFS original inmediatamente después del bucle

Advertencia: Cambios Globales de IFS

Siempre guarda el $IFS original antes de modificarlo dentro de un script (por ejemplo, IFS_ANTIGUO=$IFS). No restaurar el valor original puede causar un comportamiento impredecible en comandos posteriores.

Mejores Prácticas para Bucles Bash Robusto

Práctica	Justificación
Citar Siempre las Variables	Usa "$variable" para evitar la división de palabras y la expansión de globs, especialmente en la iteración de archivos.
Usar while IFS= read -r	El método más fiable para procesar archivos línea por línea, manejando espacios y caracteres especiales correctamente.
Verificar la Existencia	Al usar globbing (*.txt), incluye siempre una verificación (if [ -f "$archivo" ];) para asegurarte de que el bucle no procese el nombre del patrón literal si no hay archivos que coincidan.
Localizar Variables	Usa la palabra clave local dentro de las funciones para evitar que las variables del bucle sobrescriban accidentalmente las variables globales.
Usar Comandos Internos sobre Comandos Externos	Usa la expansión de llaves ({1..10}) o bucles al estilo C en lugar de generar comandos externos como seq por rendimiento.

Una Regla Práctica

Usa arrays para listas en memoria, globs para conjuntos de archivos simples, while IFS= read -r para entrada orientada a líneas y salida de find delimitada por nulos para el manejo recursivo de nombres de archivo. Cita las expansiones por defecto. Agrega verificaciones de existencia alrededor de los globs. Mantén break y continue para casos en los que hagan que el bucle sea más fácil de leer, no como una forma de ocultar un flujo de control complicado.

La mayoría de los errores de bucle en Bash provienen de la división de palabras, nombres de archivo inesperados o suponer que la entrada es más limpia de lo que es. Si tu bucle maneja espacios, líneas vacías, comentarios y coincidencias faltantes deliberadamente, sobrevivirá al trabajo de automatización real.