Dominando Comandos Externos: Optimiza el Rendimiento de Scripts Bash

El script Bash más rápido suele ser el que inicia menos programas.

Bash es bueno para trabajos de pegamento: leer un archivo, decidir qué hacer, iniciar otra herramienta, verificar el estado de salida y continuar. No es un lenguaje de procesamiento de datos de alto rendimiento. La trampa es usar Bash como si cada pequeña operación de cadena necesitara sed, cada comparación necesitara expr y cada bucle de archivo necesitara un grep nuevo. Ese estilo funciona en diez líneas. Se vuelve doloroso en 200,000 líneas.

El costo es el inicio del proceso. Cuando un script ejecuta grep, sed, awk, cut, tr, date o basename, el shell tiene que crear otro proceso y esperar por él. Una llamada no es un problema. Una llamada dentro de un bucle grande es un patrón que vale la pena corregir.

Comienza buscando comandos dentro de bucles:

grep -nE 'for |while ' script.sh
grep -nE 'grep|sed|awk|cut|tr|expr|basename|dirname|cat' script.sh

Eso no significa que cada coincidencia sea mala. Un solo awk sobre un archivo completo suele estar bien. Un sed lanzado una vez por línea es el tipo de cosa que convierte un script de mantenimiento en una interrupción misteriosa durante un despliegue.

Reemplaza Pequeñas Llamadas Externas con el Propio Bash

Las victorias más fáciles son aritmética, longitud de cadena, prefijos, sufijos y sustituciones simples. Bash ya sabe cómo hacer estas cosas.

Aritmética externa:

# Usa la utilidad externa 'expr'
RESULTADO=$(expr $A + $B)

Aritmética incorporada:

RESULTADO=$((A + B))

Sustitución de cadena externa:

MI_CADENA="hola mundo"
NUEVA_CADENA=$(echo "$MI_CADENA" | sed 's/mundo/universo/')

Expansión de parámetros:

MI_CADENA="hola mundo"
NUEVA_CADENA=${MI_CADENA/mundo/universo}
printf '%s\n' "$NUEVA_CADENA"

Tarea	Método Ineficiente (Externo)	Método Eficiente (Incorporado)
Extracción de Subcadena	`echo "$STR"	cut -c 1-5`
Verificación de Longitud	expr length "$STR"	${#STR}
Eliminar sufijo	basename "$archivo" .log	${archivo%.log}
Eliminar ruta	basename "$ruta"	${ruta##*/}
Eliminar nombre de archivo	dirname "$ruta"	${ruta%/*}
Reemplazar primera coincidencia	sed 's/foo/bar/'	${valor/foo/bar}
Reemplazar todas las coincidencias	sed 's/foo/bar/g'	${valor//foo/bar}

Prefiere [[ ... ]] para condicionales en Bash. Es una palabra clave del shell, maneja la coincidencia de patrones de manera limpia y evita algunas sorpresas de citas que aparecen con [ ... ].

if [[ $nombre == *.log && -s $nombre ]]; then
  printf 'log no vacío: %s\n' "$nombre"
fi

No fuerces esto demasiado lejos. El reemplazo de patrones de Bash no es un motor de expresiones regulares completo. Si la regla es genuinamente compleja, un pase de awk o perl es más limpio y generalmente más rápido que una expansión de shell ingeniosa.

Procesa por Lotes en Lugar de Repetir Trabajo

Si una herramienta puede procesar muchas entradas en una sola ejecución, aliméntala con muchas entradas. Esto es más importante para grep, awk, sed, find, herramientas de compresión, clientes de carga y cualquier cosa que se conecte a un servicio de red.

Este bucle inicia un grep por archivo:

for archivo in *.log; do
  grep "ERROR" "$archivo" > "${archivo}.errores"
done

Si solo necesitas un resultado combinado, usa un solo grep:

grep "ERROR" *.log > todos_los_errores.txt

Si necesitas salida por archivo, piensa si la división es realmente necesaria. A veces la herramienta downstream puede leer un prefijo de nombre de archivo desde grep -H:

grep -H "ERROR" *.log > errores_con_nombres_de_archivo.txt

Para transformaciones orientadas a líneas, colapsa cadenas simples de grep | awk en un solo programa awk:

awk '/data/ {print $1}' entrada.txt | sort > salida.txt

Eso aún ejecuta sort, y está bien. Ordenar es exactamente el tipo de trabajo que una herramienta externa debería hacer. El cambio útil es eliminar el cat innecesario y el grep separado.

Lee Archivos Sin cat

El bucle estándar de lectura de líneas es aburrido por una razón:

while IFS= read -r linea; do
  printf 'Procesando: %s\n' "$linea"
done < archivo.txt

IFS= preserva los espacios en blanco al inicio y al final. -r evita que read trate las barras invertidas como escapes. La redirección mantiene el bucle en el shell actual, lo cual importa si el bucle actualiza variables que necesitas después.

Esta versión parece inofensiva pero suele ser peor:

cat archivo.txt | while read -r linea; do
  contador=$((contador + 1))
done
printf '%s\n' "$contador"

En Bash, un segmento de tubería comúnmente se ejecuta en un subshell, por lo que contador puede no actualizarse en el shell padre. También inicia cat sin beneficio.

Usa sustitución de procesos cuando la entrada realmente sea producida por un comando:

while IFS= read -r archivo; do
  printf 'archivo grande: %s\n' "$archivo"
done < <(find /var/log -type f -size +100M)

Aquí find está haciendo trabajo real. Mantener el bucle en el shell actual sigue siendo útil.

Usa find -exec ... + y xargs con Cuidado

Los bucles de archivos son una fuente común de lentitud accidental:

for archivo in $(find . -name '*.tmp'); do
  rm "$archivo"
done

Eso se rompe con espacios e inicia rm repetidamente. Usa ejecución por lotes:

find . -name '*.tmp' -exec rm -f {} +

La forma + pasa muchas rutas a cada invocación de rm. La forma más antigua \; ejecuta el comando una vez por ruta.

Para comandos que se benefician de la concurrencia, xargs -P puede reducir el tiempo de reloj:

xargs -n 1 -P 4 curl -fsS -O < urls.txt

Usa -0 cuando estén involucrados nombres de archivo:

find uploads -type f -print0 | xargs -0 -n 50 -P 4 ./procesar-archivo

El paralelismo no es gratuito. Cuatro trabajos curl pueden ser más rápidos que uno. Cuarenta pueden hacer que te limiten por una API o saturar un host pequeño.

Mide Antes de Reescribir Todo

La optimización correcta depende de dónde se va el tiempo. Usa temporización simple primero:

time ./script.sh

Para scripts con muchos procesos, strace -c en Linux puede mostrar si el script está gastando tiempo creando procesos, abriendo archivos o esperando E/S:

strace -f -c ./script.sh

El rastreo del shell puede revelar comandos repetidos:

PS4='+ $SEGUNDOS ${BASH_SOURCE}:${LINENO}: '
bash -x ./script.sh

Si el script pasa el 95 por ciento de su tiempo esperando una exportación de base de datos, reemplazar ${valor/foo/bar} no importará. Si ejecuta sed 300,000 veces, sí importará.

Sabe Cuándo las Herramientas Externas Son Mejores

Objetivo	Mejor Herramienta (Generalmente)	Notas
Extracción y filtrado de campos	awk	Mejor que los bucles de Bash para texto tabular.
Edición de flujo	sed	Bueno para un solo pase sobre un archivo.
Recorrido de archivos	find	Más seguro que analizar ls.
JSON	jq	No analices JSON con cut.
Trabajos paralelos	xargs -P o GNU parallel	Agrega límites y maneja fallos.
Procesamiento de texto grande	awk, perl, Python	A menudo más claro que una expansión de shell heroica.

Los built-ins de Bash son rápidos, pero la mantenibilidad sigue ganando. Prefiero mantener un script awk claro que 40 líneas de frágil expansión de parámetros que solo el autor original entiende.

Una Lista de Verificación Práctica para Revisión

Cuando un script Bash se siente lento, recórrelo en este orden:

1. Encuentra comandos externos dentro de bucles.
2. Reemplaza operaciones aritméticas y de cadenas simples con expansión de Bash.
3. Elimina llamadas inútiles a cat.
4. Agrupa argumentos de archivos con grep, awk, sed, find -exec ... + o xargs.
5. Mantén los bucles de lectura de líneas en el shell actual cuando las variables deban sobrevivir al bucle.
6. Mide de nuevo.

No necesitas convertir cada script en un ejercicio de referencia. Las grandes victorias suelen venir de unos pocos puntos obvios: un comando por línea, un comando por archivo o un comando por elemento de API. Arregla esos, mantén el script legible y detente cuando el tiempo de ejecución ya no sea un problema.