Sed Borrar Líneas: Técnicas Avanzadas y Ejemplos Prácticos

El comando sed para borrar líneas (sed 'Nd') elimina líneas específicas de archivos de texto en segundos. Borra una línea por número, un rango de líneas, o cualquier línea que coincida con un patrón. Esta guía cubre cada técnica de borrado de líneas con sed, más los gotchas de GNU vs BSD sed y las trampas de la edición in-place que muerden en producción. Cada comando de abajo fue verificado en GNU sed 4.9.

¿Qué es sed y por qué usarlo para borrar líneas?

sed (Stream Editor) es una utilidad de línea de comandos para filtrar y transformar texto en sistemas tipo Unix. Encaja bien para borrar líneas porque procesa el texto línea a línea en vez de cargar archivos enteros en memoria.

Por qué se gana un hueco en tu toolkit:

• No interactivo: los cambios ocurren sin abrir un editor, que es lo que quieres en scripts, cron jobs y pipelines de CI
• Apunte flexible: números de línea (5d), rangos (10,20d), patrones (/error/d) o expresiones regulares completas
• Barato en recursos: memoria constante sin importar el tamaño del archivo, rápido incluso en logs de varios GB
• Componible: se lleva bien con pipes, grep, awk y redirecciones
• En todas partes: disponible en prácticamente cualquier sistema tipo Unix

Esta guía es parte de una serie de sed en cuatro partes:

• Borrar líneas usando el comando d (esta guía)
• Insertar o añadir texto con los comandos i y a
• Cambiar mayúsculas del texto para estandarización
• Buscar y reemplazar texto con coincidencia de patrones

Sintaxis básica de sed para borrar líneas

La estructura combina una dirección (qué líneas apuntar) con el comando de borrado (d).

sed 'ADDRESS d' filename

• ADDRESS: especifica qué líneas borrar
• d: el comando de borrado
• filename: archivo objetivo (o stdin si se omite)

Métodos de direccionamiento

1. Números de línea:

sed '5d' file.txt          # Delete line 5
sed '1d' file.txt          # Delete first line
sed '$d' file.txt          # Delete last line

2. Rangos de líneas:

sed '2,5d' file.txt        # Delete lines 2-5
sed '10,$d' file.txt       # Delete from line 10 to end
sed '1,3d' file.txt        # Delete first 3 lines

3. Coincidencia de patrones:

sed '/error/d' file.txt    # Delete lines containing "error"
sed '/^#/d' file.txt       # Delete lines starting with #
sed '/^$/d' file.txt       # Delete empty lines

4. Expresiones regulares:

sed '/^[0-9]/d' file.txt   # Delete lines starting with digits
sed '/\.log$/d' file.txt   # Delete lines ending with .log

Opciones clave

Antes que nada, corre sed --version. En GNU sed imprime la versión (4.9 o 4.10 en sistemas actuales). En macOS falla con un error illegal option, lo que te dice que cada ejemplo solo-GNU de esta guía necesita la variante portable.

Flujo de ejecución

sed opera en un ciclo simple: lee una línea al pattern space, aplica comandos y saca el resultado. El comando d cortocircuita ese ciclo: la línea nunca llega a la salida y sed salta directo a la siguiente línea.

Diagrama del ciclo de ejecución de sed: lee una línea al pattern space, aplica comandos, y el comando d borra la línea para que nunca se imprima, en bucle hasta el final del archivo

Como sed procesa una línea cada vez, el uso de memoria se mantiene constante sin importar lo grande que sea el archivo. Un log de varios GB recibe el mismo tratamiento que un config de 10 KB.

Verifica sobre la marcha: sin -i, sed imprime a stdout y no toca nada. Esa previsualización es tu primera comprobación de seguridad, y es gratis.

Borrando líneas específicas

sed apunta a líneas específicas a través de su sistema de direccionamiento.

Borrar por número de línea

sed '2d' filename          # Delete line 2
sed '1d' filename          # Delete first line
sed '$d' filename          # Delete last line

Múltiples líneas concretas:

sed '1d;3d;5d' filename    # Delete lines 1, 3, and 5
sed -e '2d' -e '5d' filename # Alternative syntax

Borrar rangos de líneas

sed '10,20d' filename      # Delete lines 10-20
sed '1,5d' filename        # Delete first 5 lines
sed '10,$d' filename       # Delete from line 10 to end

Ejemplos prácticos:

sed '1d' config.txt        # Remove header line
sed '$d' data.txt          # Remove footer/last line
sed '2,4d' log.txt         # Remove lines 2-4

Borrar las últimas N líneas

sed no tiene sintaxis $-2,$d, así que “borrar las últimas 3 líneas” necesita otra herramienta o un truco:

head -n -3 file.txt                 # GNU coreutils head (Linux)
tac file.txt | sed '1,3d' | tac     # Portable: works on macOS/BSD too

head -n -3 imprime todo menos las últimas 3 líneas, pero los conteos negativos son una extensión GNU. La receta con tac invierte el archivo, borra las (ahora) primeras 3 líneas y lo invierte de vuelta. Ambas imprimen a stdout, así que redirige a un archivo nuevo y compara antes de reemplazar el original.

Borrar por coincidencia de patrón

El borrado por patrón merece su propia sección: mira Borrado de líneas por patrón con expresiones regulares abajo para el tratamiento completo.

Seguridad y pruebas

Previsualiza los cambios primero:

sed '2d' file.txt             # Shows output without modifying file
sed '2d' file.txt > new.txt   # Save to new file

Edición in-place con backup:

# GNU sed (Linux)
sed -i.bak '2d' file.txt      # Creates file.txt.bak

# BSD sed (macOS)
sed -i '.bak' '2d' file.txt   # Creates file.txt.bak

La sección de in-place de abajo cubre los modos de fallo (-i es menos inocente de lo que parece).

Prueba con números de línea:

nl file.txt | sed '2d'        # Show line numbers to verify targeting

Casos de uso prácticos

• Limpieza de logs: sed '/DEBUG/d' app.log. Si los logs viven en Docker, redirige los logs de Docker a un solo archivo primero, luego recorta las líneas DEBUG y de error con sed
• Archivos de configuración: sed '/^#/d' nginx.conf
• Procesamiento de datos: sed '1d' data.csv (quita el header del CSV)
• Limpieza de código: sed '/^\/\//d' script.js (quita comentarios JS)

Borrado de líneas por patrón con expresiones regulares

La coincidencia de patrones es donde sed se gana el sueldo: borra cualquier línea que coincida con un patrón, no solo líneas en una posición fija.

Coincidencia de patrones básica

sed '/error/d' filename       # Delete lines containing "error"
sed '/warning/d' logfile.txt  # Delete lines with "warning"
sed '/DEBUG/d' app.log        # Delete debug messages

La coincidencia es sensible a mayúsculas: /error/ no coincide con Error. Mira la sección de insensible a mayúsculas abajo para la forma portable y el atajo GNU.

Quitar líneas vacías (incluidos archivos CRLF)

La receta clásica:

sed '/^$/d' filename              # Delete empty lines
sed '/^[[:space:]]*$/d' filename  # Delete blank lines, including whitespace-only

Aquí está la trampa: si un archivo pasó por Windows, las líneas “vacías” a menudo contienen solo un carriage return (\r). sed '/^$/d' no las borra, porque la línea no está vacía, contiene \r. La versión con clase POSIX sí las atrapa:

sed '/^[[:space:]]*$/d' win-file.txt   # CRLF-safe: \r is in the POSIX space class

GNU sed también acepta sed '/^\r$/d' para exactamente el caso de solo \r, pero es una extensión GNU. Quédate con la clase [:space:], es portable.

Verifica con qué estás lidiando: cat -A file.txt | head muestra $ en los finales de línea y ^M$ en las líneas CRLF.

Coincidir solo palabras completas

Borrar cada línea que contiene err cuando querías error es una mala tarde. Los límites de palabra lo arreglan, pero la sintaxis difiere entre implementaciones:

sed '/\berror\b/d' file.txt

sed '/[[:<:]]error[[:>:]]/d' file.txt

sed -E '/(^|[^[:alnum:]_])error([^[:alnum:]_]|$)/d' file.txt

Borrado insensible a mayúsculas: /error/Id vs portable

sed '/[Ee]rror/d' file.txt   # Portable: matches "Error" or "error"
sed '/error/Id' file.txt     # GNU only: cleaner, handles all casing

El modificador I tras el patrón hace la coincidencia insensible a mayúsculas. GNU sed lo soporta; BSD sed no. En macOS, o extiendes la clase de corchetes (que se vuelve fea rápido para mayúsculas completas) o instalas GNU sed con brew install gnu-sed y usas gsed.

Clases de caracteres y anclas

sed '/[0-9]/d' filename       # Delete lines containing any digit
sed '/[A-Z]/d' filename       # Delete lines with uppercase letters
sed '/^error/d' filename      # Delete lines starting with "error"
sed '/error$/d' filename      # Delete lines ending with "error"

Cuantificadores:

sed '/[0-9]\{3\}/d' filename     # Delete lines with 3+ consecutive digits
sed '/^.\{80,\}/d' filename      # Delete lines longer than 80 chars
sed '/error.*critical/d' file    # "error" followed by "critical"

Patrones de comentarios

sed '/^#/d' config.txt            # Delete lines starting with #
sed '/^[[:space:]]*#/d' file.txt  # Delete comments with leading whitespace
sed '/^\/\//d' script.js          # Delete JavaScript comments
sed '/^\/\*/d' style.css          # Delete CSS comment starts

Patrones complejos

sed '/^[0-9]\{4\}-[0-9]\{2\}-[0-9]\{2\}/d' file.txt  # Delete date lines (YYYY-MM-DD)

Líneas con forma de email: usa -E y un + plano:

sed -E '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/d' file.txt

También lo verás escrito con \+ ([a-zA-Z0-9._%+-]\+@...). Eso es una extensión BRE de GNU; la forma con -E es la portable.

Negación: quedarse solo con las líneas coincidentes

El ! invierte la dirección, así que d borra todo lo que no coincide:

sed '/success/!d' filename    # Keep only lines with "success"
sed '/^#/!d' config.txt       # Keep only comment lines
sed '/error/!d' log.txt       # Keep only error lines

Para quedarte con varios niveles de log, usa regex extendida (portable) en vez de alternación BRE (solo GNU):

sed -E '/INFO|WARN|ERROR/!d' log.txt   # Portable: keep only these levels
sed '/INFO\|WARN\|ERROR/!d' log.txt    # [GNU only] BRE \| alternation

Expresiones regulares extendidas

-E cambia a ERE: nada de backslashes en +, ?, | o grupos. Es portable entre GNU y BSD; GNU también acepta el alias más viejo -r.

sed -E '/^[0-9]{3}-[0-9]{3}-[0-9]{4}$/d' file.txt    # Delete phone numbers
sed -E '/^(http|https):/d' urls.txt                   # Delete HTTP URLs
sed -E '/^[A-Z]{2,}/d' file.txt                       # Lines starting with 2+ caps

Ejemplos prácticos

Limpieza de archivos de log:

sed '/INFO/d' app.log         # Remove info messages
sed '/^\[.*DEBUG.*\]/d' log   # Remove debug entries
sed '/^$/d' access.log        # Remove empty lines

Archivos de configuración:

sed '/^#/d' nginx.conf        # Remove comments
sed '/^[[:space:]]*$/d' config.ini  # Remove blank lines

Procesamiento de datos: si tu fuente es un PDF, extrae texto de un PDF en la línea de comandos de Linux con pdftotext, luego pásalo por sed para quitar líneas vacías y de header antes de seguir procesando:

pdftotext report.pdf - | sed -e '/^$/d' -e '/^Page [0-9]/d' > report.txt

Seguridad y pruebas

Previsualiza lo que se va a borrar:

grep 'pattern' filename | head    # See matching lines
sed -n '/pattern/p' filename      # Print matches without deleting

Comprueba los números de línea para contexto:

nl filename | sed '/pattern/d' | head

Errores comunes a evitar:

• Olvidar escapar caracteres especiales: /./d coincide con cada línea no vacía, /\./d coincide con puntos literales
• Sensibilidad a mayúsculas: sed '/Error/d' se pierde error. Usa [Ee]rror de forma portable o /error/I en GNU
• Patrones demasiado amplios: /log/d también mata login, catalog, logger. Usa límites de palabra

Técnicas avanzadas de borrado de líneas

Más allá de coincidencias de una línea, sed maneja rangos, bloques multilínea y decisiones basadas en líneas vecinas.

Borrado por rangos de patrones

sed '/START/,/END/d' file.txt         # Delete from START to END markers
sed '/BEGIN/,/FINISH/d' config.txt    # Delete configuration blocks
sed '/<!--/,/-->/d' html.txt          # Delete HTML comments
sed '/ERROR/,10d' file.txt            # Delete from first ERROR to line 10
sed '5,/STOP/d' file.txt              # Delete from line 5 to first STOP after it
sed '/FOOTER/,$d' file.txt            # Delete from FOOTER to end

sed -n '/ERROR/,10p' file.txt | nl | head

Borrado de patrones multilínea

sed '/^$/,/^$/d' file.txt             # Delete empty-line blocks
sed '/^function/,/^}/d' script.js     # Delete JavaScript functions
sed '/^def /,/^$/d' script.py         # Delete Python function definitions

Más formas de direcciones GNU que vale la pena conocer

Tres formas de dirección que hacen el borrado quirúrgico más fácil. Todas son extensiones GNU:

La forma 0,/re/ importa: con 1,/END/d, una coincidencia en la línea 1 termina el rango en la segunda coincidencia en su lugar, que rara vez es lo que quieres al recortar un banner inicial.

Usando rangos de direcciones con pasos

Borrar cada línea n:

sed '1~2d' file.txt                   # Delete every odd line (1st, 3rd, 5th...) [GNU only]
sed '2~3d' file.txt                   # Delete every 3rd line starting from line 2 [GNU only]
sed '0~5d' file.txt                   # Delete every 5th line [GNU only]

first~step es una extensión GNU. En macOS falla con sed: 1: '0~5d': invalid command code ~. Para un borrado portable de cada línea n, usa awk: awk 'NR % 5 == 0 {next} {print}' file.txt.

Trabajando con hold space y pattern space

sed tiene dos buffers. El pattern space contiene la línea actual (o varias líneas si añades con N). El hold space es un buffer de repuesto al que puedes copiar desde y hacia con h, H, g, G y x. Para borrar, las técnicas multilínea importan cuando la decisión depende de líneas o bloques adyacentes.

El famoso one-liner de duplicados consecutivos:

sed '$!N; /^\(.*\)\n\1$/d' file.txt   # Deletes duplicate pairs, NOT like uniq

Sabe qué hace esto antes de usarlo: junta cada línea con la siguiente, y cuando son idénticas borra ambas. Con la entrada a\na\n la salida es vacía; con a\na\na\nb\nc\nc\n obtienes a y b, porque la tercera a solitaria se empareja con la b y ambas se imprimen. Eso normalmente no es lo que la gente quiere de un “dedup”.

Para quitar duplicados de verdad, usa uniq (guarda una línea de cada serie) o uniq -u (guarda solo las líneas que nunca se repiten). Ordena primero si los duplicados pueden no ser adyacentes: sort file.txt | uniq.

Borrar una línea según la siguiente línea

Encontrarás este one-liner circulando por ahí:

sed '$!N; /error\n/d' file.txt   # BROKEN: deletes nothing useful

No hace lo que dice. /error\n/ solo coincide cuando la primera línea de un par unido termina en error, y entonces d quita ambas líneas de ese par. En un log realista (a1, ERROR, b1, c1), no borra nada. Verificado.

Aquí están los dos patrones que sí funcionan:

Borrar una línea que contiene ERROR más la línea siguiente:

sed '/ERROR/{N;d}' file.txt

Cuando una línea coincide con ERROR, N añade la línea siguiente al pattern space, y d borra ambas. Verificado: entrada a1, ERROR, b1, c1 → salida a1, c1.

Borrar una línea solo si la línea siguiente contiene ERROR (un lookahead de verdad). sed se pone feo aquí, y awk es honesto al respecto:

awk 'NR>1 && $0 !~ /ERROR/ {print prev} {prev=$0} END {print prev}' file.txt

Verificado: entrada a1, ERROR, b1, c1, ERROR, d1 → salida ERROR, b1, ERROR, d1 (las líneas seguidas de ERROR desaparecen). awk guarda una línea de lookahead en prev y solo la imprime una vez sabe que la siguiente línea es segura.

Operaciones complejas multi-comando

sed -e '/^#/d' -e '/^$/d' -e '/DEBUG/d' file.txt    # Remove comments, empty lines, debug
sed -f delete_script.sed file.txt                    # Or keep the logic in a script

Donde delete_script.sed contiene:

/^#/d
/^$/d
/DEBUG/d

Ejemplos avanzados prácticos

Limpiar archivos de log:

sed -e '/DEBUG/d' -e '/^$/d' -e '/^\[.*\]$/d' app.log

Procesar archivos de configuración:

sed -e '/^[[:space:]]*#/d' -e '/^[[:space:]]*$/d' nginx.conf

Limpieza de código:

sed -e '/^$/d' -e '/^[[:space:]]*\/\//d' -e '/console\.log/d' script.js

Prácticas avanzadas de seguridad

Prueba comandos complejos paso a paso:

sed '/^#/d' file.txt | head -20                                  # Step 1
sed -e '/^#/d' -e '/^$/d' file.txt | head -20                    # Step 2
sed -e '/^#/d' -e '/^$/d' -e '/DEBUG/d' file.txt | head -20      # Step 3

Usa archivos intermedios para operaciones por capas:

sed '/START/,/END/d' file.txt > temp1.txt
sed '/ERROR/d' temp1.txt > temp2.txt
sed '/^$/d' temp2.txt > final.txt

Backups fechados antes de corridas in-place arriesgadas:

cp original.txt original.txt.backup.$(date +%Y%m%d-%H%M%S)
sed -i.bak 'complex_deletion_commands' original.txt

¿Entrada no confiable? El --sandbox de GNU sed deshabilita los comandos e, r y w para que un archivo manipulado no pueda hacer que sed ejecute comandos o escriba archivos:

sed --sandbox '/DEBUG/d' untrusted.log   # [GNU only]

GNU vs BSD sed: chuleta de portabilidad

La mitad de los one-liners de sed en internet son solo-GNU, y fallan en macOS con errores confusos. Esta matriz mapea cada hueco a una alternativa portable:

Tres hábitos que mantienen los scripts de sed portables:

1. Lint con --posix. Correr sed --posix -f cleanup.sed file.txt hace que GNU sed 4.10+ avise sobre constructos con backslash que GNU acepta pero otros sed no. Forma barata de pillar sintaxis no portable antes de que tu script llegue a una máquina macOS.

2. Fija el locale para texto generado por máquina. Los rangos [A-Z] y [a-z] siguen la collation del locale, y en algunos locales caracteres inesperados caen dentro de un rango. Para logs y configs, prefija con LC_ALL=C:

LC_ALL=C sed '/^[A-Z]/d' app.log

La coincidencia por bytes es predecible, que es lo que quieres para borrado automatizado.

3. Comprueba la versión en CI. Añade sed --version || echo "BSD sed" a la salida de debug de tu pipeline. Las diferencias de comportamiento (especialmente -i y $ entre archivos) son mucho más fáciles de depurar cuando sabes qué sed corrió.

Un edge más: GNU sed preserva un newline final ausente solo mientras la última línea sobrevive. printf 'a\nb\nc' | sed '1d' saca b\nc sin newline final (verificado en 4.9). Borra esa última línea con $d en su lugar, y la nueva línea final obtiene un newline normal, así que printf 'a\nb\nc' | sed '$d' saca a\nb\n. Si tu pipeline hashea o compara la salida byte a byte entre plataformas, prueba en la versión de macOS que uses; se reporta ampliamente que BSD sed añade newlines donde GNU no.

Edición in-place con sed -i: gotchas que muerden en producción

-i parece un flag de conveniencia. Es una operación de reemplazo de archivo, e interactúa mal con hard links, symlinks y el flag -n.

Qué hace -i bajo el capó

GNU sed no edita el archivo. Escribe el resultado a un archivo temporal y lo renombra sobre tu original. El nombre de archivo se queda, pero el inodo cambia:

Diagrama mostrando que sed -i escribe un archivo temporal con un inodo nuevo y lo renombra sobre el original, lo que rompe los hard links al inodo viejo y reemplaza los symlinks con archivos regulares

Los hard links se rompen silenciosamente. Comportamiento verificado:

ln orig.txt hard.txt
sed -i '1d' orig.txt
ls -li orig.txt hard.txt
# Both now show link count 1. hard.txt still has the OLD content.

Los symlinks se reemplazan por un archivo regular. Verificado:

ln -s real.conf link.conf
sed -i '1d' link.conf
# link.conf is now a regular file with edited content.
# real.conf is untouched. The symlink is gone.

El arreglo GNU es --follow-symlinks, que edita el destino in-place y preserva el link:

sed -i --follow-symlinks '1d' link.conf

Vale saberlo: --follow-symlinks -i tenía una carrera time-of-check-to-time-of-use que permitía a un atacante cambiar el symlink entre la resolución y la escritura, arreglada en GNU sed 4.10. En máquinas multi-inquilino donde los usuarios pueden escribir en tus directorios temporales, es una razón más para saber qué versión de sed estás corriendo.

Numeración de líneas multi-archivo y $

GNU sed cuenta líneas de forma continua a través de todos los archivos de entrada a menos que pases -i o -s (in-place implica -s):

sed -n '2p' f1.txt f2.txt     # Prints line 2 OVERALL (from f1) only
sed -s -n '2p' f1.txt f2.txt  # Prints line 2 of EACH file
sed -s -i '$d' f1.txt f2.txt  # Deletes the last line of EACH file

Sin -s, $d solo toca la última línea del último archivo. BSD sed reinicia la numeración por archivo por defecto, así que el mismo comando significa cosas distintas en cada plataforma. Verifica con sed -s -n '$=' f1.txt f2.txt (imprime el conteo de líneas de cada archivo) antes de confiar en él.

sed -ni '/DEBUG/d' file.txt   # file.txt is now 0 bytes

Checklist previo para ediciones in-place

La forma correcta en cada plataforma

sed -i.bak '2d' file.txt

sed -i '.bak' '2d' file.txt

sed '2d' file.txt > file.txt.new && mv file.txt.new file.txt

Verifica y revierte

diff file.txt.bak file.txt     # See exactly what was removed
mv file.txt.bak file.txt       # Roll back

El diff es el paso de verificación: debería mostrar solo las líneas que pretendías borrar, nada más. Para comprobar ediciones a lo largo de un árbol de configs, mira cómo comparar dos archivos o carpetas en la terminal. Mantén el hábito del backup fechado (cp file.txt file.txt.$(date +%Y%m%d-%H%M%S)) para cualquier cosa que no puedas permitirte perder.

Consideraciones de rendimiento

sed es rápido para un editor de streaming, pero el filtrado puro de líneas es el trabajo de grep, y la diferencia es amplia.

Borrando cada línea que contiene DEBUG de un archivo de ~5 millones de líneas / 69 MB, medido en una máquina Linux con GNU sed 4.9:

Los números absolutos dependen de tu hardware y I/O. El orden no: grep -v fue aproximadamente dos órdenes de magnitud más rápido porque hace una sola cosa, mientras sed carga su motor de direccionamiento completo incluso cuando no lo usas.

La regla de decisión:

Conclusión

sed borra líneas por número, rango, patrón o cualquier combinación, procesa archivos de cualquier tamaño con memoria constante, y encaja en cualquier parte desde el history de shell de un uso único hasta pipelines de CI. La diferencia entre una edición sed segura y un incidente de pérdida de datos suele ser un flag que falta.

Puntos clave:

1. Empieza simple: los números de línea y patrones básicos cubren la mayoría de necesidades diarias
2. Previsualiza sin -i antes de cada edición in-place, y haz diff al .bak antes de borrarlo
3. Etiqueta todo lo específico de GNU (~, \|, \b, /I, 0,/re/) y comprueba sed --version en cualquier máquina que el script no conozca
4. Nunca combines -n con -i. Esa es la trampa del archivo de 0 bytes
5. Para filtrado puro, grep -v le gana a sed por órdenes de magnitud

Cuándo usar alternativas:

• grep -v: exclusión pura por patrón, la opción más rápida para filtrar
• awk: procesamiento por campos, lookaheads, conteo de líneas por archivo
• uniq / uniq -u: eliminación real de duplicados (el truco de sed borra ambas líneas de un par)
• Un editor de texto: borrado interactivo cuando necesitas confirmación visual

Domina el toolkit completo de sed

El resto de la serie de sed:

• Insertar o añadir texto con los comandos i y a
• Cambiar mayúsculas del texto para estandarización
• Buscar y reemplazar texto con coincidencia de patrones

FAQ