La lección anterior terminó con una frontera clara: awk lee y resume, pero no es la herramienta para reescribir texto conservando su forma. Cuando hay que anonimizar las IP de acceso.log antes de mandárselo a un proveedor, arreglar los separadores de un CSV mal exportado o cambiar una clave de veloz-ops.conf sin abrir un editor, lo que hace falta es un editor de flujo: un programa que reciba texto por un lado, aplique una lista de órdenes de edición a cada línea y suelte el resultado por el otro. Eso es sed, y funciona con las mismas expresiones regulares que ya dominas desde 05-04, solo que aplicadas a transformar en lugar de a filtrar.

1. El ciclo de sed y el espacio de patrones
2. sed, awk o ${var//a/b}: cuál usar
3. Sintaxis y opciones
4. -i: editar ficheros en el sitio, con red de seguridad
5. Direcciones: a qué líneas se aplica un comando
6. El comando s/// a fondo
7. Otros comandos: p, d, q, a, i, c, y
8. Filtrar y extraer tramos
9. Encadenar comandos y bloques
10. Espacio de retención y N, en pinceladas
11. Recetas reales del toolkit
12. Aplicación: veloz_anonimiza_log en lib/comun.sh

sed no ve el fichero entero: trabaja línea a línea sobre un búfer llamado espacio de patrones. Para cada línea de la entrada repite siempre el mismo ciclo.

De este esquema salen tres consecuencias que explican casi todo el comportamiento de sed:

• Los comandos se aplican en orden sobre el mismo búfer. Si el primero sustituye A por B, el segundo ya ve B. Encadenar sustituciones no es lo mismo que aplicarlas por separado.
• La impresión es automática al final del ciclo, no la hace el comando. Por eso sed 's/a/b/' imprime todas las líneas, no solo las que cambió.
• -n apaga esa impresión automática, y a partir de ahí solo sale lo que pidas explícitamente con p. De ahí el idioma sed -n '...p'.

Las tres herramientas sustituyen texto, y elegir mal es la causa más común de código enrevesado:

La regla práctica: si el texto ya está en una variable, ${var//a/b} y no lances un proceso; si hay que reescribir un fichero o un flujo, sed; si hay que sumar, contar o mirar columnas, awk. Y si te encuentras contando campos con sed, o sustituyendo con awk en varias pasadas, casi seguro que has elegido la herramienta equivocada.

Los comandos van entre comillas simples por el mismo motivo que en awk: contienen $, & y barras invertidas que Bash expandiría. Las opciones que se usan de verdad:

-E merece una recomendación explícita. Por defecto sed habla BRE, el dialecto de 05-04 en el que +, ?, (, ) y | son literales y hay que escaparlos: s/[0-9]\+/N/. Con -E escribes s/[0-9]+/N/, que es lo que tienes en la cabeza. Usa -E siempre salvo que copies una receta ajena escrita en BRE.

-i es la opción más útil y la más peligrosa de sed: reescribe el fichero original sin preguntar y sin posibilidad de deshacer. Un patrón mal escrito puede vaciar un fichero de configuración en producción.

Dos hábitos que evitan el desastre:

1. Prueba siempre sin -i primero. Ejecuta el comando tal cual, mira la salida, y solo entonces añade -i. Es gratis y resuelve el 95 % de los sustos.
2. Usa un sufijo de copia, -i.bak, no -i a secas. Cuesta cinco pulsaciones y deja el original recuperable.

Aquí hay además una incompatibilidad clásica: en GNU sed (Linux) el sufijo va pegado, -i.bak, y -i solo es válido; en BSD/macOS -i exige argumento, así que sin copia se escribe -i ''. Consecuencia: sed -i.bak funciona en ambos, sed -i solo en Linux, y un script que use sed -i '' fallará en Linux interpretando '' como nombre de fichero. Si el script debe correr en los dos sitios, la salida limpia es escribir a un temporal (mktemp, 05-01) y mover encima con mv.

Y una advertencia seria: nunca lances sed -i sobre ficheros de /etc sin copia previa. sed -i 's/PermitRootLogin no/PermitRootLogin yes/' /etc/ssh/sshd_config es un cambio de seguridad hecho a ciegas, sin validación y sin vuelta atrás. Las implicaciones se ven en 08-03.

Un comando sin dirección se aplica a todas las líneas. Anteponiéndole una dirección se restringe:

Así, sed -n '/2026-08-03 10:/,/2026-08-03 11:/p' /var/log/veloz/app.log extrae una hora del log, y sed '1!d' envios.csv deja solo la cabecera. El ! se lee "excepto": 1!d es "borra las líneas que no son la 1". Es la forma idiomática de conservar solo algo, y aparece constantemente en recetas reales.

Es el comando estrella y el que justifica el 90 % de los usos de sed. Su forma es s/regex/reemplazo/banderas:

El delimitador no tiene que ser /. Cualquier carácter vale, y elegir bien evita el "síndrome de las barras inclinadas" al trabajar con rutas:

Las banderas que van tras el último delimitador:

En el reemplazo hay dos metacaracteres que hay que conocer. & significa "todo lo que emparejó", y \1, \2… son los grupos de captura de 05-04, con los grupos escritos \\(...\\) en BRE o (...) con -E:

Corolario práctico: si quieres un & literal en el reemplazo, escápalo (\&), igual que hay que escapar el delimitador si aparece dentro del patrón. Y recuerda que s/// sin g cambia solo la primera ocurrencia de cada línea: es el olvido número uno.

d tiene una peculiaridad importante: aborta el ciclo, así que los comandos posteriores no se ejecutan sobre esa línea. Y q es un optimizador silencioso: sed '100q' fichero_gigante deja de leer en la línea 100, mientras que head -100 con una tubería seguiría leyendo. La sintaxis de a/i/c con texto en la misma línea es una extensión de GNU cómoda pero no portable; la forma POSIX usa una barra invertida y salto de línea.

Con -n y p se filtra igual que con grep: sed -n '/ERROR/p' app.log hace exactamente lo mismo que grep ERROR app.log. Si solo vas a filtrar, usa grep. Es más legible, suele ser más rápido, y tiene -c, -v, -i, -l y -o para los casos habituales. sed gana en cuanto la operación deja de ser "sí o no" y pasa a ser "transformar", o cuando lo que quieres es un tramo por número de línea, que grep no sabe hacer:

Ese ;20q es el detalle que marca la diferencia en un log de dos gigas: sin él, sed sigue leyendo hasta el final aunque ya no imprima nada.

Varios comandos se separan con ; o con varios -e. Y si quieres aplicar un grupo de comandos a la misma dirección, se agrupan con llaves:

En el segundo ejemplo, { s/^/ /; p } se aplica únicamente a las líneas del rango: primero sangra, después imprime. El orden importa —recuerda la sección 1: los comandos ven el búfer tal como lo dejó el anterior—. Si invirtieras p y s, imprimirías la línea sin sangrar.

Además del espacio de patrones, sed tiene un segundo búfer, el espacio de retención, que sobrevive entre líneas. Se maneja con h (copiar patrón→retención), H (añadir), x (intercambiar) y G (añadir retención→patrón). Es lo que da a sed una memoria mínima: sed G informe.txt añade una línea en blanco tras cada línea, y el críptico sed '1!G;h;$!d' fichero invierte el orden de las líneas —el tac de sed—.

El comando N añade la línea siguiente al espacio de patrones, permitiendo que una regex cruce dos líneas —útil para juntar una línea de app.log con su traza—. Dicho esto, aquí está el límite honesto de la herramienta: en cuanto necesites este nivel de acrobacia, awk o un lenguaje de guion serán más legibles y más fáciles de mantener. Conoce que existe, no lo conviertas en tu estilo.

Anonimizar las IP de acceso.log conservando el primer octeto para saber la red de origen, y normalizar los separadores de un CSV exportado con punto y coma y coma decimal:

Cambiar una clave de configuración de forma idempotente, es decir, que se pueda ejecutar mil veces con el mismo resultado y que funcione tanto si la clave existía como si no:

El if no es un adorno: sed no puede añadir una línea que no existe, solo transformar las que hay. Sin la comprobación previa, el script parecería funcionar y no cambiaría nada. Nótese el ancla ^, que evita tocar una clave que solo contenga ese texto, y el .* que se come el valor antiguo sea cual sea.

Limpiar un fichero de configuración para verlo sin ruido, y insertar una cabecera a un CSV que la perdió:

La receta de la IP se convierte en función reutilizable, siguiendo las reglas de librería de 05-06: solo definición, prefijo de espacio de nombres, sin código de nivel superior:

Tres decisiones merecen comentario. La función no usa -i: escribe a la salida estándar y deja que el llamante decida (veloz_anonimiza_log "$LOG" > /tmp/compartir.log), que es lo correcto en una librería —una función que modifica ficheros ajenos por sorpresa es una trampa—. Los dos -e separados son más legibles que un ; largo y permiten comentar uno al depurar. Y el -- marca el fin de opciones, así que un fichero llamado -raro.log se trata como fichero y no como opción; es el mismo hábito defensivo de 03-05. El código 66 es EX_NOINPUT, de la tabla de 05-03.

Verificar antes de confiar es obligatorio con sed: una comprobación rápida como head -3 /var/log/veloz/acceso.log | veloz_anonimiza_log /dev/stdin basta para ver que las IP salen enmascaradas y el resto de la línea intacto.

• Olvidar la bandera g. s/,/;/ cambia solo la primera coma de cada línea. Para todas, s/,/;/g.
• Usar -i sin probar antes. Ejecuta siempre el comando sin -i, mira la salida y solo entonces edita. Y usa -i.bak, que funciona en GNU y en BSD.
• Esperar ERE por defecto. sed 's/[0-9]+/N/' no hace nada, porque en BRE + es un + literal. Añade -E.
• Escapar barras a mano. Si el patrón lleva rutas, cambia de delimitador: s|/a/b|/c/d|.
• Confundir el . dentro de una IP. [0-9]{1,3}.[0-9] empareja también 192x168; el punto literal se escribe \..
• Creer que sed puede añadir claves que faltan. Solo transforma líneas existentes; para añadir, comprueba con grep -q y usa >>.
• Usar sed para filtrar. Si es un "sí o no", grep; si hay que cambiar el texto, sed; si hay columnas o cuentas, awk.
• Consejo: con ficheros grandes, sed -n '10,20p;20q' y sed '100q' evitan leer de más. LC_ALL=C sed ... también acelera.
• Consejo: un guion de sed largo se saca a un fichero .sed y se invoca con -f, igual que en awk: se comenta con # y se versiona.

Ejercicio 1. Escribe un comando que extraiga de /var/log/veloz/app.log únicamente las líneas del intervalo entre 10:00:00 y 11:00:00 y les quite la fecha (dejando solo hora, nivel y mensaje), sin modificar el fichero original.

Ejercicio 2. Escribe una función veloz_set_conf para lib/comun.sh que fije una clave a un valor en ~/veloz-ops/etc/veloz-ops.conf de forma idempotente, con copia de seguridad, y que conserve los permisos 600 del fichero.

Ejercicio 3. El proveedor manda envios-crudo.csv con separador ;, importes con coma decimal, espacios sobrantes alrededor de los campos y una línea de comentario inicial que empieza por #. Escribe un solo sed que lo deje en el formato de envios.csv.

Solución 1.

El rango /inicio/,/fin/ selecciona el tramo, y las llaves aplican los dos comandos solo a él: primero se quita la fecha con s/// anclado en ^, después se imprime con p. -n es imprescindible —sin él saldría el fichero entero, con el tramo además duplicado por el p—. Y el orden dentro de las llaves importa: si p fuera primero, imprimiría la línea con la fecha todavía puesta.

Solución 2.

Aquí sí se usan comillas dobles, porque hay que interpolar $clave y $valor, y por eso la validación previa con =~ (05-04) no es opcional: sin ella, una clave con | o & rompería la sustitución o inyectaría comportamiento. El delimitador | evita problemas si el valor es una ruta, y chmod 600 al final restaura los permisos, porque sed -i crea un fichero nuevo y lo renombra, de modo que los permisos pueden cambiar. El código 64 es EX_USAGE.

Solución 3.

El orden es deliberado y es todo el ejercicio. Primero se borra el comentario (d aborta el ciclo, así que esa línea ni se procesa). Después se normalizan los ; absorbiendo los espacios que los rodean, lo que resuelve de golpe el sobrante interior. Luego se recortan los extremos de la línea. Y solo al final se arregla el decimal: si esa sustitución fuera antes, el , recién creado por el paso del ; podría confundirse con el decimal. Conviene verificarlo con head -3 envios-crudo.csv | sed -E '...' antes de sobrescribir nada.

sed es un editor de flujo: por cada línea la copia al espacio de patrones, le aplica los comandos en orden y la imprime al terminar el ciclo salvo que -n lo impida —de ahí el idioma sed -n '...p'—. Sus comandos aceptan direcciones (número de línea, $, regex, rangos 2,5 y /inicio/,/fin/, y la negación !) que deciden a qué líneas se aplican, y el rey de todos es s/regex/reemplazo/banderas, con delimitador libre para no pelearse con las rutas, banderas g, i, p y w, y un reemplazo donde & es lo emparejado y \1 los grupos de 05-04. Alrededor están d, p, q, a, i, c y y, los bloques { } para agrupar por dirección, y el espacio de retención (h, x, G, N) como memoria mínima que conviene conocer y no abusar. -E para escribir ERE cómodo, -i.bak siempre con copia y probando antes sin -i, y la frontera clara con sus vecinos: ${var//a/b} para una variable, grep para filtrar, awk para columnas y cuentas, sed para reescribir.

Con awk y sed, el toolkit ya sabe leer, resumir y transformar cualquier texto que le eches. Pero todo ese texto sigue viniendo de ficheros que alguien dejó en el disco. Un script de operaciones necesita algo más: preguntarle al propio sistema en qué estado está —cuánto disco queda, qué carga soporta, quién está conectado, qué versión de sistema operativo corre, si el servicio veloz-api está vivo— para poder decidir en función de la respuesta. Eso es la próxima lección (06-03): las órdenes que interrogan al sistema y cómo convertir sus respuestas en umbrales y decisiones dentro de un script.