Procesar lotes de archivos

1. Cuándo alcanzan los comodines

Para un lote dentro de un solo directorio, seleccionado por el nombre, un bucle sobre un comodín es lo más simple, como vimos en el tema 14:

shopt -s nullglob
for registro in /var/log/app/*.log; do
  gzip -- "$registro"
done

Los comodines dejan de alcanzar cuando la selección depende de algo más que el nombre, como la antigüedad o el tamaño; cuando hay que recorrer subdirectorios a cualquier profundidad (globstar lo permite, pero arma toda la lista en memoria); o cuando los archivos son tantos que la lista supera el límite de longitud de una línea de comandos, con el error Argument list too long. Para todo eso está find.

2. Elegir archivos con find

find recorre un árbol de directorios y selecciona los archivos que cumplen una serie de criterios, que se combinan como condiciones. El curso de Terminal lo presentó; estos son los criterios que más aparecen en la automatización:

# Registros de más de 7 días que todavía no están comprimidos, sin entrar en .git
find /var/log/app -path '*/.git' -prune -o -type f -name '*.log' ! -name '*.gz' -mtime +7 -print

Los criterios se evalúan en orden y se combinan con «y» implícito; -o significa «o». La forma con -prune se lee: «si la ruta es un .git, no entres; si no, y es un archivo .log…, muéstralo». El -print final es necesario cuando hay un -o, para que solo se muestren los de la segunda rama. Antes de actuar sobre los archivos, conviene siempre ejecutar el find solo, con -print, y mirar la lista.

3. Actuar con find -exec

find puede ejecutar un comando sobre cada archivo que encuentra, con -exec. Las llaves {} se reemplazan por la ruta del archivo, y la acción termina con \; o con +, que se comportan de forma muy distinta:

$ find . -name '*.log' -exec echo "uno:" {} \;
uno: ./-raro.log
uno: ./a b.log
uno: ./normal.log
$ find . -name '*.log' -exec echo "todos:" {} +
todos: ./-raro.log ./a b.log ./normal.log

Con +, find agrupa tantas rutas como admite una línea de comandos, y ejecuta el comando las veces necesarias. Para comprimir diez mil registros, -exec gzip {} + crea unos pocos procesos en lugar de diez mil. Y como find pasa las rutas directamente como argumentos, sin pasar por la shell, los espacios y caracteres raros no son un problema.

4. Los nombres problemáticos

En Linux, un nombre de archivo puede contener cualquier carácter, salvo la barra y el carácter nulo. Tres casos rompen los scripts descuidados:

$ touch "-raro.log"
touch: invalid option -- 'r'
$ touch -- "-raro.log"                      # ahora sí
$ for f in *.log; do ls -d "$f"; done
ls: invalid option -- '.'
a b.log
normal.log
$ for f in ./*.log; do ls -d "$f"; done
./-raro.log
./a b.log
./normal.log

Comprobado así, el nombre con guion inicial confundió a touch y a ls, aunque estaba entre comillas: las comillas protegen de la división en palabras, no de que el comando interprete un argumento como opción. Escribir el patrón como ./*.log hace que todas las rutas empiecen con ./, y el problema desaparece; find ya las devuelve así. Los saltos de línea son raros, pero un script que procesa archivos ajenos, como los de un directorio compartido, debe estar preparado para ellos.

5. xargs

xargs lee una lista de su entrada y la convierte en argumentos de un comando. Combinado con find, es una alternativa a -exec con más opciones de control:

$ find . -name '*.log' | xargs ls -d
ls: cannot access './a': No such file or directory
ls: cannot access 'b.log': No such file or directory
./-raro.log
./normal.log
$ find . -name '*.log' -print0 | xargs -0 ls -d --
./-raro.log
./a b.log
./normal.log

Sin opciones, xargs separa la entrada por espacios y saltos de línea, y además interpreta comillas, de modo que parte los nombres con espacios. Por eso se usa siempre con find -print0 y xargs -0, que separan por el carácter nulo. Estas son sus opciones más útiles:

find . -name '*.tmp' -print0 | xargs -0 -r rm -f --                     # borrar, si hay algo
find fotos -iname '*.png' -print0 | xargs -0 -I {} cp -- {} {}.original  # una copia de cada una
printf '%s\0' "${servidores[@]}" | xargs -0 -n 1 ping -c1 -W2            # una lista propia

6. Un bucle sobre la salida de find

Cuando la acción sobre cada archivo tiene varios pasos, o necesita variables del script, o hay que contar resultados, la forma más flexible es el bucle del tema 16, con la salida de find separada por nulos:

comprimidos=0
while IFS= read -r -d '' registro; do
  if gzip -- "$registro"; then
    comprimidos=$(( comprimidos + 1 ))
  else
    echo "No se pudo comprimir $registro" >&2
  fi
done < <(find /var/log/app -type f -name '*.log' -mtime +7 -print0)
echo "Comprimidos: $comprimidos"

Esta forma combina lo mejor de las dos herramientas: find elige con sus criterios, y el cuerpo del bucle tiene toda la expresividad de Bash. Su costo es que cada vuelta ejecuta los comandos uno por vez, de modo que es más lenta que -exec … + para operaciones simples sobre muchísimos archivos.

7. Procesar en paralelo

Cuando cada archivo requiere un trabajo pesado, como comprimir, convertir una imagen o calcular una suma de verificación, procesarlos de a uno desaprovecha los procesadores del equipo. La opción -P de xargs ejecuta varios comandos a la vez:

$ printf '%s\0' 1 2 3 4 | xargs -0 -n 1 -P 4 sh -c 'sleep 1; echo "terminó $0"'
terminó 1
terminó 2
terminó 3
terminó 4
# en total, un segundo y no cuatro

El número de procesos simultáneos conviene ajustarlo a los procesadores disponibles, que da el comando nproc. Para usar una función del script como tarea, se exporta con export -f, como vimos en el tema 18, y se llama a través de bash -c:

reducir() {
  convert "$1" -resize 1600x1600\> "${1%.*}-web.jpg"
}
export -f reducir

find fotos -iname '*.jpg' ! -name '*-web.jpg' -print0 \
  | xargs -0 -n 1 -P "$(nproc)" bash -c 'reducir "$1"' _

El _ final ocupa el lugar de $0 dentro de bash -c, de modo que la ruta llega como $1. Dos advertencias: las salidas de las tareas simultáneas pueden mezclarse en la pantalla, y las tareas no deben escribir en los mismos archivos. Para necesidades más complejas existe GNU parallel, una herramienta dedicada con muchas más opciones.

8. Cuál elegir

9. Renombrar en masa

Renombrar muchos archivos es una de las tareas por lotes más frecuentes, y una de las más peligrosas: un error puede hacer que dos archivos reciban el mismo nombre, y que uno pise al otro. Con las expansiones del tema 6, un bucle resuelve casi cualquier renombrado:

for f in ./*.jpeg; do mv -n -- "$f" "${f%.jpeg}.jpg"; done           # cambiar la extensión
for f in ./*\ *; do mv -n -- "$f" "${f// /_}"; done                  # espacios por guiones bajos
for f in ./IMG_*; do mv -n -- "$f" "./vacaciones_${f#./IMG_}"; done   # cambiar un prefijo
n=1; for f in ./*.png; do printf -v nuevo './captura-%03d.png' "$n"; mv -n -- "$f" "$nuevo"; n=$(( n + 1 )); done

La opción -n de mv (no clobber) es la protección esencial: si el destino ya existe, mv no lo sobrescribe. Sin ella, un renombrado que produce dos veces el mismo nombre borra un archivo en silencio. Pero -n solo evita el daño; el archivo que no se movió sigue con su nombre viejo, y el script debería detectarlo o, mejor, elegir otro nombre, como hace el script de la sección 11.

Muchas distribuciones incluyen además un comando rename para renombrar con expresiones, aunque hay dos versiones incompatibles con el mismo nombre: la de Perl, que usa rename 's/\.jpeg$/.jpg/' *.jpeg, y la de util-linux, que usa rename .jpeg .jpg *.jpeg. Por esa ambigüedad, en un script es más predecible el bucle de Bash.

10. Antes de tocar mil archivos

Una operación por lotes multiplica las consecuencias de un error, como advirtió el tema 1. Antes de ejecutarla sobre los datos reales:

1. Mirar la selección. Ejecutar el find solo, con -print, o contar los resultados con | wc -l (o -printf '.' | wc -c, que no se confunde con saltos de línea). ¿Son los archivos esperados? ¿Son tantos como se esperaba?
2. Simular. Reemplazar la acción por un echo, o usar una opción -n como la del script de este tema, y revisar la lista de cambios.
3. Probar en una copia. Un cp -a del directorio a un lugar de pruebas, y ejecutar allí.
4. Preferir lo reversible. Mover a un directorio de descarte antes que borrar; renombrar con mv -n; comprimir conservando el original con gzip -k hasta verificar.
5. Hacer el proceso repetible. Que una segunda ejecución reconozca lo ya hecho y no lo rehaga, como en el tema 27. Así, si se interrumpe a la mitad, se vuelve a lanzar sin miedo.

11. Un script completo

Las cámaras y los teléfonos nombran las fotos con números, como IMG_4031.JPG, que no dicen nada y se repiten entre dispositivos. Este script las renombra con su fecha y hora de modificación, como 2026-10-14_10-32-07.jpg, de modo que quedan ordenadas cronológicamente. Resuelve los choques de nombres, admite simular y recorrer subdirectorios, y una segunda ejecución no cambia nada.

#!/usr/bin/env bash
#
# renombrar-por-fecha — renombra fotos y videos con su fecha y hora de modificación:
# IMG_4031.JPG → 2026-10-14_10-32-07.jpg
#
# Uso: renombrar-por-fecha [-n] [-r] DIRECTORIO
#   -n  muestra los cambios sin hacerlos
#   -r  incluye los subdirectorios
#
set -euo pipefail

simular=0
profundidad=(-maxdepth 1)
while getopts ":nr" opcion; do
  case "$opcion" in
    n) simular=1 ;;
    r) profundidad=() ;;
    *) echo "Uso: ${0##*/} [-n] [-r] DIRECTORIO" >&2; exit 2 ;;
  esac
done
shift $(( OPTIND - 1 ))
(( $# == 1 )) || { echo "Uso: ${0##*/} [-n] [-r] DIRECTORIO" >&2; exit 2; }
dir="${1%/}"
[[ -d "$dir" ]] || { echo "${0##*/}: no existe el directorio $dir" >&2; exit 1; }

declare -A reservado=()                  # nombres ya asignados en esta ejecución
renombrados=0
sin_cambio=0

while IFS= read -r -d '' ruta; do
  carpeta="${ruta%/*}"
  nombre="${ruta##*/}"
  ext="${nombre##*.}"
  ext="${ext,,}"
  [[ "$ext" == jpeg ]] && ext=jpg

  base=$(date -r "$ruta" +%Y-%m-%d_%H-%M-%S)
  if [[ "$nombre" =~ ^${base}(_[0-9]+)?\.${ext}$ ]]; then
    sin_cambio=$(( sin_cambio + 1 ))   # ya tiene el nombre que le corresponde
    continue
  fi

  nuevo="$base.$ext"
  n=1
  while [[ -e "$carpeta/$nuevo" || -n "${reservado[$carpeta/$nuevo]:-}" ]]; do
    n=$(( n + 1 ))
    nuevo="${base}_$n.$ext"              # dos fotos del mismo segundo
  done
  reservado[$carpeta/$nuevo]=1

  if (( simular )); then
    printf '%s → %s\n' "${ruta#"$dir"/}" "$nuevo"
  else
    mv -n -- "$ruta" "$carpeta/$nuevo"
  fi
  renombrados=$(( renombrados + 1 ))
done < <(find "$dir" "${profundidad[@]}" -type f \
           \( -iname '*.jpg' -o -iname '*.jpeg' -o -iname '*.png' -o -iname '*.heic' -o -iname '*.mp4' \) \
           -print0 | sort -z)

verbo=$( (( simular )) && echo "se renombrarían" || echo "renombrados" )
echo "Archivos $verbo: $renombrados; ya tenían el nombre correcto: $sin_cambio" >&2

$ renombrar-por-fecha -n ~/fotos
IMG_4031.JPG → 2026-10-14_10-32-07.jpg
IMG_4032.JPG → 2026-10-14_10-32-07_2.jpg
foto de mamá.jpeg → 2026-10-14_10-35-00.jpg
Archivos se renombrarían: 3; ya tenían el nombre correcto: 0
$ renombrar-por-fecha -r ~/fotos
Archivos renombrados: 4; ya tenían el nombre correcto: 0
$ find ~/fotos -type f | sort
/home/ana/fotos/2026-10-14_10-32-07.jpg
/home/ana/fotos/2026-10-14_10-32-07_2.jpg
/home/ana/fotos/2026-10-14_10-35-00.jpg
/home/ana/fotos/viaje 2026/2026-09-01_08-00-00.png
$ renombrar-por-fecha -r ~/fotos
Archivos renombrados: 0; ya tenían el nombre correcto: 4

• find elige y el bucle actúa: los archivos llegan separados por nulos y ordenados con sort -z, de modo que el resultado no depende del orden en que el sistema de archivos los devuelve, y ningún nombre puede romper el bucle.
• -r vacía un array de opciones, la técnica del tema 8: sin -r, find recibe -maxdepth 1; con -r, no recibe nada.
• Los choques se resuelven con un sufijo: dos fotos del mismo segundo reciben _2, _3… El array asociativo reservado recuerda los nombres ya asignados en esta ejecución, para que la simulación también los respete aunque los archivos todavía no existan con ese nombre. Y mv -n es la última red de seguridad.
• El script es idempotente: antes de calcular un nombre nuevo, comprueba con una expresión regular si el actual ya corresponde a su fecha, con o sin sufijo, y en ese caso lo deja.
• La extensión se normaliza a minúsculas, y jpeg pasa a jpg, para que todas las fotos sigan una convención.
• El resumen va a la salida de errores, y la estándar queda solo con la lista de cambios de la simulación, que puede guardarse o revisarse.

La fecha de modificación es la que tienen todos los archivos, pero no siempre es el momento en que se tomó la foto: copiarla o editarla la cambia. Las fotos guardan además la fecha original en sus metadatos EXIF, que se leen con herramientas como exiftool; el mismo script, con exiftool en lugar de date -r, daría fechas más fieles.

12. Errores frecuentes

13. Resumen

• Los comodines alcanzan para un directorio y una selección por nombre; para criterios como la fecha o el tamaño, árboles de directorios o listas enormes, hace falta find.
• find combina criterios como -type, -name, -mtime, -size y -prune; antes de actuar, se mira la selección con -print.
• -exec … {} \; ejecuta una vez por archivo; -exec … {} +, con muchos a la vez; -delete borra.
• Los nombres con espacios, con guion inicial o con saltos de línea se manejan con comillas, -- o rutas con ./, y separadores nulos.
• xargs -0, con find -print0, convierte una lista en argumentos; -r evita ejecutar sin entrada, -n limita los argumentos, -I ejecuta uno por uno.
• while IFS= read -r -d '' f sobre find -print0 permite varios pasos por archivo, con contadores y mensajes.
• xargs -P N procesa en paralelo; una función se usa exportándola y llamándola con bash -c.
• Un renombrado masivo usa expansiones de Bash y mv -n, y resuelve los choques de nombres.
• Antes de tocar muchos archivos: mirar la selección, simular, probar en una copia, preferir lo reversible y hacer el proceso repetible.

14. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. En un directorio de prueba, crea archivos con espacios, con un guion inicial y, si tu sistema lo permite, con un salto de línea (touch $'a\nb.txt'). Procésalos con for, con find | xargs y con find -print0 | xargs -0, y compara.
2. Escribe un find que liste los archivos de más de 100 MiB de tu directorio personal, sin entrar en .cache.
3. Comprime en paralelo, con xargs -P, los .log de más de una semana de un directorio de prueba, conservando los originales con gzip -k. Mide el tiempo con y sin -P.
4. Escribe un bucle que reemplace los espacios por guiones en todos los nombres de un directorio, con mv -n, y prueba qué pasa si dos nombres terminan iguales.
5. Copia algunas fotos a un directorio de prueba y usa renombrar-por-fecha -n y luego sin -n. Comprueba que una segunda ejecución no cambia nada.
6. Si tienes exiftool, modifica el script para que use la fecha EXIF cuando existe, y la de modificación cuando no.