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.

Diagrama de decisión. Inicio: find encontró algunos archivos. Pregunta: ¿algún nombre podría contener un espacio, una comilla o un salto de línea? Si no estás seguro, toma la respuesta como sí. El sí lleva a dos opciones seguras: find -print0 en pipe a xargs -0, o find -exec comando {} +, que ejecuta un proceso para muchos archivos. find | xargs sin -0 se marca como inseguro, porque 'Meeting Notes.txt' se convierte en dos argumentos. -exec comando {} \; se marca como seguro pero lento, un proceso por archivo.
Cómo pasar los resultados de find a otro comando. Un pipe simple a xargs parte los nombres en los espacios; -print0 con xargs -0, o -exec … {} +, mantiene cada nombre entero.

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
Gráfico de barras: find -exec wc -l {} \; 11.958 ms; find -exec wc -l {} + 136 ms; find -print0 | xargs -0 wc -l 137 ms.
wc -l sobre 5000 archivos pequeños encontrados con find, mediana de 5 ejecuciones, Mac con Apple Silicon (M1 Pro). {} \; arranca 5000 procesos wc; {} + y xargs -0 arrancan uno.

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, sed de BSD, onetrue awk 20200816, grep 2.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 xargs en este sistema y coincidió con lo que observamos.
  • -mtime +30 cuenta 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

  1. Comprime con gzip, en un solo comando, cada archivo .log bajo proj con más de 30 días de antigüedad, de forma segura para nombres con espacios.
  2. Con awk, cuenta las peticiones por hora del día en access.log.

Respuestas

  1. 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
  1. 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.

  • #shell
  • #find
  • #xargs
  • #sed
  • #awk
  • #macos
  • #intermedio

t.laboratory

A technical blog that records real problems from the apps, servers and services we build and run — and the code that fixed them.

Acerca de · Apps

↑