find, xargs, sed y awk en macOS: trampas BSD vs GNU
find + xargs con espacios en los nombres, sed y awk sobre un log de accesos y las diferencias BSD vs GNU que rompen en una Mac las respuestas para Linux.
Serie: curso de línea de comandos 3/6 (intermedio). Para quien ya arma un pipeline (clase 2) y ahora necesita trabajar sobre árboles de carpetas completos y editar texto en el lugar: el freelancer que tiene que limpiar los logs del servidor de un cliente, quien en su primer trabajo hereda una carpeta con miles de archivos generados, o el estudiante que analiza los logs de su proyecto de la universidad. Vas a buscar archivos por nombre, antigüedad y tamaño, pasárselos de forma segura a otros comandos y responder preguntas sobre un log de accesos web con programas de una línea en sed y awk.
La mayoría de las respuestas sobre shell que hay en internet están escritas para Linux, y muchas se rompen en una Mac de una de dos formas: ruidosamente (illegal option) o, peor, en silencio (el comando corre y no cambia nada, o cambia lo que no era). Esta clase es para quien copia esas respuestas en una terminal de macOS, y para cualquiera cuyas carpetas tengan nombres con espacios. Cada comando de abajo se ejecutó en macOS con las herramientas de BSD, y donde GNU se comporta distinto lo decimos y lo marcamos como "no ejecutado aquí".
Clases anteriores: rutas y archivos, pipes y redirección. El panorama completo: la ruta de aprendizaje de programación.
Entorno: macOS 26.6, Mac con Apple Silicon (M1 Pro), zsh 5.9 y bash 3.2.57; find, xargs, sed, awk de BSD (awk version 20200816), grep 2.6.0-FreeBSD. Python 3.9.6 solo para generar el log de ejemplo. Las rutas del home en las salidas se acortaron a ~.
Preparación: un árbol de proyecto pequeño y un log de accesos
Primero, un generador de log de accesos de servidor web en el formato "combined" de siempre, con el tiempo de respuesta en segundos agregado al final (muchos servidores se pueden configurar para registrarlo). Usa rangos de IP de documentación y una semilla fija:
# gen_access.py - fake web access log in "combined" format + response time (seeded)
import random, sys
from datetime import datetime, timedelta
n = int(sys.argv[1]) if len(sys.argv) > 1 else 5000
rng = random.Random(7)
t = datetime(2026, 11, 12, 0, 0, 0)
ips = [f"203.0.113.{i}" for i in range(1, 40)] + [f"198.51.100.{i}" for i in range(1, 20)]
bot = "192.0.2.66"
pages = ["/", "/products/12", "/products/31", "/products/7", "/cart", "/login", "/api/search?q=mug"]
uas = ["Mozilla/5.0 (iPhone)", "Mozilla/5.0 (Windows NT 10.0)", "Mozilla/5.0 (Macintosh)"]
for _ in range(n):
t += timedelta(seconds=rng.randint(0, 30))
if rng.random() < 0.08: # a scanner probing for WordPress
ip, path, st, ua = bot, rng.choice(["/wp-login.php", "/xmlrpc.php", "/.env"]), 404, "curl/8.7.1"
else:
ip, path, ua = rng.choice(ips), rng.choice(pages), rng.choice(uas)
st = rng.choices([200, 304, 500], [90, 8, 2])[0]
size = "-" if st == 304 else str(rng.randint(300, 48000) if st == 200 else rng.randint(150, 600))
rt = round(rng.lognormvariate(-3.0, 0.9) + (1.5 if st == 500 else 0), 3)
print(f'{ip} - - [{t:%d/%b/%Y:%H:%M:%S} +0000] "GET {path} HTTP/1.1" {st} {size} "-" "{ua}" {rt}')
Después, un script que arma un árbol de proyecto con los problemas de siempre: una carpeta y un archivo con espacios, archivos viejos y basura:
# setup.sh - a small project tree with the usual problems (spaces, old files, junk)
rm -rf proj
mkdir -p proj/src proj/logs "proj/old logs" proj/notes proj/build
printf 'print("hi")\n' > proj/src/main.py
printf 'def add(a, b):\n return a + b\n' > proj/src/util.py
printf 'agenda\ndecisions\nnext steps\n' > "proj/notes/Meeting Notes.txt"
printf 'todo\n' > proj/notes/todo.txt
cp access.log proj/logs/access.log
head -100 access.log > "proj/old logs/access 2025.log"
for i in 1 2 3; do echo tmp > "proj/build/cache$i.tmp"; done
touch -t 202610010900 "proj/old logs/access 2025.log" proj/build/*.tmp
Ejecuta python3 gen_access.py > access.log y sh setup.sh. md5 -q access.log debería imprimir cc723029cc75f8a657bcfd445eee7818 (5000 líneas). La línea touch -t le pone fecha del 1 de octubre de 2026 a algunos archivos, para que las pruebas de antigüedad tengan algo que encontrar.
find: primero la ruta, el patrón entre comillas
find recorre un árbol de carpetas e imprime cada ruta que pasa sus pruebas:
~/demo/find % find proj -type f
proj/logs/access.log
proj/notes/todo.txt
proj/notes/Meeting Notes.txt
proj/old logs/access 2025.log
proj/build/cache1.tmp
proj/build/cache2.tmp
proj/build/cache3.tmp
proj/src/util.py
proj/src/main.py
~/demo/find % find -name '*.py'
find: illegal option -- n
usage: find [-H | -L | -P] [-EXdsx] [-f path] path ... [expression]
find [-H | -L | -P] [-EXdsx] -f path [path ...] [expression]
El find de GNU asume . cuando omites la ruta (no ejecutado aquí); el de BSD la exige. Escribe siempre la ruta, aunque sea solo ..
La segunda regla es poner el patrón entre comillas. Sin comillas, el shell expande *.log antes de que corra find, y el resultado depende de lo que haya por casualidad en la carpeta actual. Probamos los tres casos:
~/demo/find % touch a.log b.log
~/demo/find % find proj -name *.log
find: access.log: unknown primary or operator
~/demo/find % rm a.log b.log
~/demo/find % find proj -name *.log
proj/logs/access.log
~/demo/find % cd proj
~/demo/find/proj % find . -name *.log
zsh: no matches found: *.log
Con tres archivos que coincidían, el shell convirtió el comando en find proj -name a.log access.log b.log, que find rechaza. Con exactamente una coincidencia (access.log) quedó find proj -name access.log: sin error, pero access 2025.log falta en silencio del resultado. Sin coincidencias, zsh se niega a ejecutar el comando. bash 3.2 deja pasar sin cambios un *.log que no coincide, así que ahí encontró ambos archivos: la misma línea funciona o falla según el shell y la carpeta. Con comillas, find proj -name '*.log' encontró los dos archivos todas las veces.
Pruebas de find: tipo, antigüedad, tamaño y la trampa de -o
~/demo/find % find proj -type f -mtime +30
proj/old logs/access 2025.log
proj/build/cache1.tmp
proj/build/cache2.tmp
proj/build/cache3.tmp
~/demo/find % find proj -type f -size +100k
proj/logs/access.log
~/demo/find % find proj -name '*.log' -o -name '*.txt' -print
proj/notes/todo.txt
proj/notes/Meeting Notes.txt
~/demo/find % find proj \( -name '*.log' -o -name '*.txt' \) -print
proj/logs/access.log
proj/notes/todo.txt
proj/notes/Meeting Notes.txt
proj/old logs/access 2025.log
-mtime +30 significa "modificado hace más de 30 días", -size +100k "más grande que 100 KiB". Las pruebas escritas una detrás de otra se unen con un AND implícito, que tiene más precedencia que -o (OR). Así que el tercer comando significa "*.log OR (*.txt AND print)": los archivos .log coincidieron, pero nada los imprimió. Los paréntesis (escapados para que el shell no los toque) lo arreglan.
Pasar resultados a otro comando: xargs, -print0 y -exec
xargs lee palabras de stdin y las agrega como argumentos a un comando. El problema es justamente "palabras":
~/demo/find % find proj -name '*.txt' | xargs wc -l
wc: proj/notes/Meeting: open: No such file or directory
wc: Notes.txt: open: No such file or directory
1 proj/notes/todo.txt
1 total
~/demo/find % find proj -name '*.txt' -print0 | xargs -0 wc -l
1 proj/notes/todo.txt
3 proj/notes/Meeting Notes.txt
4 total
~/demo/find % find proj -name '*.txt' -exec wc -l {} +
1 proj/notes/todo.txt
3 proj/notes/Meeting Notes.txt
4 total
-print0 termina cada nombre con un byte NUL en vez de un salto de línea, y xargs -0 corta solo en NUL, que no puede aparecer en un nombre de archivo. -exec cmd {} + deja que find arme la lista de argumentos por su cuenta. Las dos son seguras; con rm en lugar de wc, la versión insegura habría intentado borrar proj/notes/Meeting y Notes.txt, que en otra carpeta podrían ser archivos reales.
Tres comportamientos más de xargs que comprobamos:
~/demo/find % find proj -name '*.bak' | xargs echo removing
~/demo/find % find proj -name '*.py' | xargs -n 1 echo file:
file: proj/src/util.py
file: proj/src/main.py
~/demo/find % find proj -name '*.py' | xargs -I {} cp {} {}.orig
Con entrada vacía, el xargs de BSD no ejecutó echo en absoluto. El xargs de GNU ejecuta el comando una vez sin argumentos salvo que agregues -r (no ejecutado aquí); por eso find … | xargs rm en Linux termina imprimiendo rm: missing operand. El xargs de macOS acepta -r y lo ignora, así que xargs -r es la forma portable. -n 1 ejecuta un comando por argumento, -I {} sustituye cada línea donde aparece {}.
¿Cuántos argumentos entran en un solo comando? Con 12,000 archivos vacíos, xargs -0 sh -c 'echo $#' sh imprimió 5000, 5000, 2000: el xargs de BSD usa por defecto un máximo de 5000 argumentos por comando (man xargs). -exec sh -c 'echo $#' sh {} + imprimió un único 12000; find llena la lista hasta el límite de tamaño de argumentos del sistema (getconf ARG_MAX es 1048576 aquí).
Error típico: -delete en el lugar equivocado
find evalúa su expresión de izquierda a derecha para cada archivo, y -delete es una acción, no una opción. Lo probamos sobre una copia:
~/demo/find % find proj -name '*.tmp' -print
proj/build/cache1.tmp
proj/build/cache2.tmp
proj/build/cache3.tmp
~/demo/find % find proj -name '*.tmp' -delete
~/demo/find % cp -R proj proj-copy
~/demo/find % find proj-copy -delete -name '*.tmp'
~/demo/find % ls proj-copy
ls: proj-copy: No such file or directory
Lo que pasó: con -delete primero, find borró cada archivo y carpeta que visitó, y después comprobó el nombre de lo que ya había borrado. El árbol proj-copy entero desapareció, sin un solo mensaje. Solución: ejecuta siempre primero el comando exacto con -print en lugar de -delete, revisa la lista y luego cambia solo esa palabra. El mismo hábito sirve con xargs: pon echo delante del comando (xargs -0 echo rm) para ver qué se ejecutaría.
sed: ediciones en flujo y los no-ops silenciosos
sed edita el texto línea por línea a medida que pasa. Sobre el log de accesos:
~/demo/find % sed -n '1,2p' access.log
203.0.113.26 - - [12/Nov/2026:00:00:10 +0000] "GET /login HTTP/1.1" 200 35419 "-" "Mozilla/5.0 (iPhone)" 0.011
203.0.113.3 - - [12/Nov/2026:00:00:39 +0000] "GET / HTTP/1.1" 200 16072 "-" "Mozilla/5.0 (Windows NT 10.0)" 0.017
~/demo/find % sed -n '/" 500 /p' access.log | head -2
203.0.113.11 - - [12/Nov/2026:00:10:42 +0000] "GET /login HTTP/1.1" 500 356 "-" "Mozilla/5.0 (Windows NT 10.0)" 1.537
203.0.113.33 - - [12/Nov/2026:00:11:08 +0000] "GET / HTTP/1.1" 500 553 "-" "Mozilla/5.0 (iPhone)" 1.521
~/demo/find % sed -E 's/^([0-9]+\.[0-9]+\.[0-9]+)\.[0-9]+/\1.x/' access.log | head -2
203.0.113.x - - [12/Nov/2026:00:00:10 +0000] "GET /login HTTP/1.1" 200 35419 "-" "Mozilla/5.0 (iPhone)" 0.011
203.0.113.x - - [12/Nov/2026:00:00:39 +0000] "GET / HTTP/1.1" 200 16072 "-" "Mozilla/5.0 (Windows NT 10.0)" 0.017
-n con p imprime solo las líneas seleccionadas (por número o por /regex/). s/old/new/ sustituye; -E activa las expresiones regulares extendidas, así que + y ( ) funcionan sin barras invertidas. El tercer comando enmascara la última parte de cada dirección IP antes de compartir un log, un pedido muy común (y una buena práctica si el log contiene datos personales).
Ahora, los hábitos de GNU que no hacen nada en macOS, sin ningún error:
~/demo/find % sed '/wp-login\|xmlrpc\|\.env/d' access.log | wc -l
5000
~/demo/find % sed -E '/wp-login|xmlrpc|\.env/d' access.log | wc -l
4598
~/demo/find % echo 'aaa bbb' | sed 's/a\+/X/'
aaa bbb
~/demo/find % echo 'aaa bbb' | sed -E 's/a+/X/'
X bbb
~/demo/find % echo 'cat category' | sed 's/\bcat\b/dog/g'
cat category
~/demo/find % echo 'cat category' | sed 's/[[:<:]]cat[[:>:]]/dog/g'
dog category
\|, \+ y \b son extensiones de GNU a las expresiones regulares básicas. El sed de BSD las interpreta como otra cosa, no encuentra nada y sigue de largo: el comando para "quitar las líneas del escáner" quitó cero de las 402 líneas. Con -E la misma intención funciona. Una sorpresa positiva: sed 's/,/\n/g' sí convirtió las comas en saltos de línea en esta versión de macOS; las guías más viejas dicen que el sed de BSD no puede, así que si la Mac más vieja de un compañero no está de acuerdo, usa tr ',' '\n'. Más sobre la sintaxis de las regex en sí en qué es una expresión regular (en inglés).
sed -i en macOS: tres resultados
Editar un archivo en el lugar es donde las respuestas para Linux se rompen de forma más visible:
~/demo/find % printf 'host=old.example.com\nport=8080\n' > app.conf
~/demo/find % sed -i 's/old/new/' app.conf
sed: 1: "app.conf
": command a expects \ followed by text
~/demo/find % sed -i -e 's/old/new/' app.conf
~/demo/find % ls app.conf*
app.conf
app.conf-e
~/demo/find % sed -i '' 's/8080/9090/' app.conf
~/demo/find % sed -i.bak 's/9090/9191/' app.conf && rm app.conf.bak
~/demo/find % cat app.conf
host=new.example.com
port=9191
En BSD, -i toma como argumento el sufijo del backup. En el primer comando, sed usó s/old/new/ como sufijo e intentó ejecutar app.conf como script de sed (a es el comando "append"). El segundo "funcionó", pero usó -e como sufijo y dejó tirado un app.conf-e, el tipo de archivo que termina en un commit de git. -i '' significa "sin backup" solo en BSD. -i.bak, con el sufijo pegado, funciona igual en BSD y en GNU (la forma de GNU sed -i 's/…/' no se ejecutó aquí).
awk: columnas, filtros, sumas y grupos
awk divide cada línea en campos $1, $2, … según los bloques de espacios ($NF es el último) y ejecuta pattern { action } sobre las líneas que coinciden. En el formato combined, $1 es la IP del cliente, $7 la ruta, $9 el estado, $10 el tamaño y, en nuestro log, $NF el tiempo de respuesta.
~/demo/find % awk '{print $9}' access.log | sort | uniq -c | sort -rn
4126 200
402 404
373 304
99 500
~/demo/find % awk '{print $1}' access.log | sort | uniq -c | sort -rn | head -3
402 192.0.2.66
95 203.0.113.12
92 203.0.113.2
~/demo/find % awk '$9 == 500 {n++; t += $NF} END {printf "%d errors, avg %.3f s\n", n, t/n}' access.log
99 errors, avg 1.566 s
~/demo/find % awk '$9 == 200 {b[$7] += $10} END {for (p in b) printf "%10d %s\n", b[p], p}' access.log | sort -rn | head -3
14591902 /api/search?q=mug
14525275 /products/31
14192831 /products/12
~/demo/find % awk -F'"' '{print $6}' access.log | sort | uniq -c | sort -rn
1535 Mozilla/5.0 (Windows NT 10.0)
1535 Mozilla/5.0 (Macintosh)
1528 Mozilla/5.0 (iPhone)
402 curl/8.7.1
~/demo/find % awk '$9 == 200 {print $NF}' access.log | sort -n | awk '{v[NR] = $1} END {print "n=" NR, "p50=" v[int(NR*0.50)], "p95=" v[int(NR*0.95)], "max=" v[NR]}'
n=4126 p50=0.05 p95=0.228 max=0.811
En orden: peticiones por estado, el cliente más ruidoso (nuestro escáner), el tiempo promedio de las peticiones fallidas, los bytes servidos por ruta (b[$7] += $10 es un array asociativo cuya clave es la ruta), los user agents (con -F'"' la comilla es el separador, así que el user agent es el campo 6), y la mediana y el percentil 95 del tiempo de respuesta. Ese último es el número a vigilar: el promedio esconde la cola lenta.
Dos errores de comillas que producen una salida incorrecta en vez de un error:
~/demo/find % awk "{print $1}" access.log | head -1
203.0.113.26 - - [12/Nov/2026:00:00:10 +0000] "GET /login HTTP/1.1" 200 35419 "-" "Mozilla/5.0 (iPhone)" 0.011
~/demo/find % awk '{print $1 $9}' access.log | head -1
203.0.113.26200
Entre comillas dobles, el shell reemplazó $1 (vacío en un shell interactivo) antes de que awk lo viera, así que awk ejecutó {print } e imprimió las líneas completas; pon siempre los programas de awk entre comillas simples. Y sin coma, $1 $9 concatena; print $1, $9 separa con un espacio.
Medido: -exec {} \; vs {} + vs xargs -0
La forma más rápida de volver lento un trabajo con find es lanzar un proceso por archivo. Creamos 5000 archivos de una línea en 50 carpetas, todos con un espacio en el nombre (file 1.txt …), y ejecutamos wc -l sobre todos de tres formas, cinco veces cada una:
zmodload zsh/datetime
rm -rf tree; mkdir tree
for i in {1..5000}; do d=tree/d$(( i % 50 )); [[ -d $d ]] || mkdir $d; print "line $i" > "$d/file $i.txt"; done
for c in "find tree -name '*.txt' -exec wc -l {} \;" \
"find tree -name '*.txt' -exec wc -l {} +" \
"find tree -name '*.txt' -print0 | xargs -0 wc -l"; do
for r in 1 2 3 4 5; do
s=$EPOCHREALTIME; eval "$c" > out.txt; e=$EPOCHREALTIME
printf '%s: %.0f ms\n' "$c" $(( (e-s)*1000 ))
done
done
| Comando (5000 archivos) | Procesos wc |
Mediana de 5 | Ejecuciones (ms) |
|---|---|---|---|
-exec wc -l {} \; |
5000 | 11,958 ms | 10,198 – 12,386 |
-exec wc -l {} + |
1 | 136 ms | 123 – 428 |
-print0 en pipe a xargs -0 wc -l |
1 | 137 ms | 125 – 181 |
Unas 88 veces más lento, para la misma salida. Las tres formas manejaron bien los espacios. Ejecutar los lotes en paralelo con xargs -P se mide en la clase 5.
BSD (macOS) vs GNU (Linux): con qué nos topamos
| Tarea | macOS, ejecutado aquí | Forma GNU/Linux (no ejecutada aquí) |
|---|---|---|
| Editar en el lugar | sed -i '' 's/a/b/' f |
sed -i 's/a/b/' f |
| Edición en el lugar portable | sed -i.bak 's/a/b/' f && rm f.bak |
igual |
| Uno o más en sed | sed -E 's/a+/X/' |
sed 's/a\+/X/' también funciona |
| Límite de palabra en sed | [[:<:]]word[[:>:]] |
\bword\b |
| find sin ruta | error: illegal option -- n |
usa . por defecto |
| Imprimir tamaño y nombre | stat -f '%z %N' f |
find -printf '%s %p\n', stat -c %s f |
| xargs con entrada vacía | no ejecuta nada; acepta -r |
se ejecuta una vez salvo con -r |
| Regex de Perl en grep | grep: invalid option -- P |
grep -P '\d+' |
| La fecha de ayer | date -j -v-1d -f %Y-%m-%d 2026-11-12 +%Y-%m-%d → 2026-11-11 |
date -d yesterday |
| Extras de awk | calling undefined function strftime / asort |
gawk tiene strftime, asort, -i inplace |
En esta Mac, stat -c %s imprimió stat: illegal option -- c, find … -printf imprimió find: -printf: unknown primary or operator y date -d yesterday imprimió date: illegal option -- d. Si un script tiene que correr en ambos sistemas, quédate con el subconjunto portable de la columna izquierda, o revisa uname y bifurca.
Límites honestos y notas de versión
- Todo se comprobó solo en macOS 26.6 (
find,xargs,sedde BSD, onetrueawk20200816,grep2.6.0-FreeBSD). La columna de GNU describe el comportamiento documentado de GNU; no lo ejecutamos. - Que
sed 's/,/\n/g'produzca saltos de línea reales es lo que hizo esta versión; no probamos versiones anteriores de macOS. - El valor por defecto de 5000 argumentos de xargs viene de
man xargsen este sistema y coincidió con lo que observamos. -mtime +30cuenta períodos de 24 horas desde ahora, así que los archivos de ejemplo con fecha del 1 de octubre de 2026 van a seguir coincidiendo; si cambias las fechas, cambia el resultado.- La tabla de tiempos es de una sola Mac con Apple Silicon (M1 Pro) con otros trabajos corriendo; la ejecución de
{} +de 428 ms fue la primera, en frío. Una segunda sesión, ejecutando exactamente el script de arriba con la máquina más tranquila, dio medianas de 8636 ms, 105 ms y 112 ms: los números absolutos se movieron, la proporción (unas 80×) no.
Ejercicios
- Comprime con
gzip, en un solo comando, cada archivo.logbajoprojcon más de 30 días de antigüedad, de forma segura para nombres con espacios. - Con
awk, cuenta las peticiones por hora del día enaccess.log.
Respuestas
- Deja que find arme la lista de argumentos:
~/demo/find % find proj -name '*.log' -mtime +30 -exec gzip {} +
~/demo/find % find proj -name '*.gz'
proj/old logs/access 2025.log.gz
- Divide el campo de fecha y hora
$4([12/Nov/2026:00:00:10) por:; la segunda parte es la hora:
~/demo/find % awk '{split($4, t, ":"); print t[2]}' access.log | sort | uniq -c | head -4
238 00
244 01
246 02
256 03
Lo que sigue
Anterior: Clase 2: pipes y redirección. Siguiente: Clase 4: variables, scripts y códigos de salida, donde estos one-liners se convierten en scripts que fallan ruidosamente en vez de en silencio. Vuelve a la ruta de aprendizaje.
Preguntas frecuentes
¿Por qué sed -i 's/old/new/' archivo da error en una Mac?
El sed de BSD exige un argumento después de -i: el sufijo del backup. Tomó el script como sufijo y el nombre del archivo como script, e imprimió 'command a expects \ followed by text'. En macOS usa sed -i '' 's/old/new/' archivo, o sed -i.bak … && rm archivo.bak, que funciona tanto con el sed de BSD como con el de GNU.
¿Cómo paso nombres de archivo con espacios de find a otro comando?
Usa find … -print0 | xargs -0 cmd, o find … -exec cmd {} +. Un find | xargs simple partió 'Meeting Notes.txt' en 'Meeting' y 'Notes.txt'. -exec cmd {} \; también es seguro, pero arranca un proceso por archivo: 11,958 ms para 5000 archivos contra 136 ms con {} +.
¿Por qué mi regex de sed con \+ o \| no hace nada en macOS?
Las expresiones regulares básicas del sed de BSD no soportan las extensiones de GNU \+, \? y \|, y \b no es un límite de palabra. Fallan en silencio: sin error y sin cambios. Usa sed -E con +, ? y |, y [[:<:]] / [[:>:]] para los límites de palabra.