Probador de Regex

/ /

Cadena de prueba

Modo reemplazo

Coincidencias 0

Detalles de coincidencia

Referencia rápida

Clases de caracteres

. Any character (except newline)

\d Digit [0-9]

\D Non-digit

\w Word char [A-Za-z0-9_]

\W Non-word char

\s Whitespace

\S Non-whitespace

Anclas

^ Start of string/line

$ End of string/line

\b Word boundary

\B Non-word boundary

Cuantificadores

* 0 or more

+ 1 or more

? 0 or 1 (optional)

{n} Exactly n

{n,m} Between n and m

*? Lazy (non-greedy)

Grupos

(...) Capture group

(?:...) Non-capturing group

(?<name>...) Named capture group

\1 Backreference to group 1

a|b Alternation (a or b)

Búsqueda anticipada/posterior

(?=...) Positive lookahead

(?!...) Negative lookahead

(?<=...) Positive lookbehind

(?<!...) Negative lookbehind

Acerca de esta herramienta

Un probador de regex en tiempo real que resalta las coincidencias, extrae capture groups (con nombre y numerados), soporta buscar y reemplazar con backreferences, y proporciona acceso rápido a patrones comunes usados en desarrollo web y administración de sistemas.

Características

Resaltado en tiempo real — las coincidencias se resaltan con colores alternos mientras escribes
Capture groups — tanto con nombre ( (?<name>...)) como numerados, se muestran con etiquetas
Modo de reemplazo — prueba sustituciones con backreferences ($1, $&, $<name>)
Flags de regex — alterna global, insensible a mayúsculas, multilínea, dot-all y Unicode
10 presets de patrones — email, URL, IPv4, UUID, teléfono, JWT, dirección MAC, color HEX, fecha ISO y location de Nginx
Estadísticas de coincidencias — recuento, tiempo de ejecución y posición línea:columna para cada coincidencia
Referencia rápida — hoja de referencia de regex desplegable con caracteres, anclas, quantifiers, grupos y lookaround

¿Cómo se usa?

Introduce tu patrón regex en el campo de patrón
Configura los flags deseados (g, i, m, s, u) usando las casillas
Escribe o pega tu cadena de prueba en el área de texto
Las coincidencias se resaltan en tiempo real con información detallada debajo
Activa el modo de reemplazo para probar sustituciones — introduce una cadena de reemplazo con backreferences $1, $& o $<name>
Haz clic en cualquier preset para cargar un patrón común con texto de ejemplo
Despliega la referencia rápida de la parte inferior para una hoja de referencia compacta de la sintaxis regex

¿Qué hacen los flags de regex?

Los flags (también llamados modificadores) cambian cómo el motor de regex interpreta tu patrón. En JavaScript se colocan después del delimitador de cierre: /pattern/flags. Esta herramienta te permite alternar cada uno individualmente.

Global

Encuentra todas las coincidencias en la cadena en lugar de detenerse tras la primera. Sin g, solo se devuelve la primera coincidencia. Esencial para contar ocurrencias o realizar un buscar y reemplazar global.

/\d+/g en “a1 b2 c3” → 3 coincidencias ( 1, 2, 3)

Insensible a mayúsculas

Hace que el patrón coincida sin importar mayúsculas o minúsculas. /abc/i coincide con abc, ABC, aBc, etc. Se aplica tanto a caracteres literales como a rangos de caracteres como [a-z].

/error/i coincide con “Error”, “ERROR”, “error”

Multilínea

Cambia el comportamiento de las anclas ^ y $. Normalmente coinciden con el inicio/fin de toda la cadena. Con m, coinciden con el inicio/fin de cada línea (separada por \n). No afecta a . — usa s para eso.

/^server/m coincide con “server” al inicio de cualquier línea, no solo la primera

Dot-All (línea única)

Hace que el metacarácter . coincida con cualquier carácter incluyendo saltos de línea (\n, \r). Por defecto, . coincide con todo excepto terminadores de línea. Útil para coincidencias en bloques multilínea.

/<div>.*?</div>/s coincide con un div y su contenido incluso si abarca varias líneas

Unicode

Habilita la coincidencia completa de Unicode. Sin él, los caracteres fuera del Basic Multilingual Plane (emojis, CJK, símbolos matemáticos) pueden tratarse como dos unidades de código separadas. También habilita escapes de propiedades Unicode como \p{Letter} y \p{Emoji}.

/\p{Emoji}/gu coincide correctamente con emojis como 🔥, 👋, 🎉

Combinaciones de flags comunes

gi

— Encuentra todas las coincidencias, insensible a mayúsculas. La combinación más habitual para búsqueda de texto.

gm

— Encuentra todas las coincidencias en múltiples líneas. Útil para archivos de log y de configuración.

gis

— Global, insensible a mayúsculas, dot-all. Para coincidencias en bloques HTML/XML multilínea.

gu

— Global con Unicode. Necesario cuando se trabaja con texto internacionalizado o emojis.

gms

— Global, multilínea, dot-all. Máxima potencia para analizar contenido estructurado multilínea.

¿En qué se diferencia el regex de JavaScript de otros sabores?

Esta herramienta usa el motor nativo RegExp de JavaScript, que sigue la especificación ECMAScript. Algunas diferencias a tener en cuenta al portar patrones a otros entornos:

Característica	JavaScript	PCRE (grep -P, PHP)	Python re
Grupos con nombre	`(?<name>...)`	`(?P<name>...)` or `(?<name>...)`	`(?P<name>...)`
Lookbehind	Longitud variable (ES2018+)	Solo longitud fija	Solo longitud fija
Propiedades Unicode	`\p{L}` (with `u` flag)	`\p{L}` (built-in)	Via `regex` module
Grupos atómicos	No soportado	`(?>...)`	No soportado
Recursión	No soportado	`(?R)`, `(?1)`	Via `regex` module
Cuantificadores posesivos	No soportado	`a++`, `a*+`	No soportado
Retro-referencia en reemplazo	`$1`, `$&`	`\1`, `$1`	`\1`, `\g<1>`

¿Cómo puedo mejorar el rendimiento de regex?

Evita el backtracking catastrófico — patrones como (a+)+b pueden hacer que el motor se bloquee con cadenas largas que no coinciden. Usa construcciones tipo atomic o reescribe como a+b.
Sé específico con los quantifiers — prefiere [^"]* sobre .*? cuando busques coincidencias entre delimitadores. La character class negada es más rápida porque no necesita backtracking.
Ancla cuando sea posible — si sabes que la coincidencia empieza al principio de una línea, usa ^ para que el motor descarte posiciones rápidamente.
Usa non-capturing groups — escribe (?:…) en lugar de (…) cuando no necesites el valor capturado. Evita reservar memoria para el grupo.
Monitoriza el tiempo de ejecución — esta herramienta muestra el tiempo de coincidencia para cada prueba. Si un patrón tarda más de unos milisegundos, considera simplificarlo.

Privacidad

Todo el análisis de patrones y procesamiento de texto se realiza íntegramente en tu navegador utilizando el motor RegExp nativo de JavaScript. Ningún dato se transmite a ningún servidor — tus patrones y cadenas de prueba nunca salen de tu dispositivo.

Referencia de comandos Linux

Las expresiones regulares están profundamente integradas en la línea de comandos de Linux. A continuación se muestran herramientas comunes con sus capacidades de regex.

grep — Buscar líneas con un patrón

grep -Pn ‘\b[A-Z][a-z]+\b’ /var/log/nginx/access.log | head -5

3:The Quick Brown Fox Jumps Over The Lazy Dog15:Server nginx/1.25.4...Starting worker process42:Connection from Remote host established

grep -oP — Extraer solo coincidencias

echo '192.168.1.1 and 10.0.0.254' | grep -oP '\b(?:\d{1,3}\.){3}\d{1,3}\b'

192.168.1.110.0.0.254

sed — Buscar y reemplazar

echo 'Date: 2025-06-15' | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'

Date: 15/06/2025

awk — Procesamiento basado en patrones

echo -e 'admin@example.com\ndev@test.org\ninvalid' | awk '/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/ {print "Valid:", $0}'

Valid: admin@example.comValid: dev@test.org

find — Buscar archivos por nombre con regex

find /etc/nginx -regextype posix-extended -regex '.*\.(conf|key|crt)$' -type f | head -5

/etc/nginx/snippets/disable_assets_log.conf/etc/nginx/snippets/server_ssl.conf/etc/nginx/conf.d/default.conf/etc/nginx/nginx.conf/etc/nginx/ssl/server.crt

Relacionado

Consulta los patrones regex usados en

Implementar Content Security Policy con Nginx

para ejemplos reales de validación de CSP, o prueba el analizador de cabeceras HTTP para inspeccionar cabeceras de seguridad validadas con regex.

Preguntas frecuentes

¿Mis patrones regex y cadenas de prueba se envían a un servidor?

No. Todo el análisis de patrones y el procesamiento de texto se ejecuta íntegramente en tu navegador usando el motor RegExp nativo de JavaScript. Tus patrones y cadenas de prueba nunca salen de tu dispositivo.

¿Qué sabor de regex usa este probador?

Usa el motor nativo RegExp de JavaScript, que sigue la especificación ECMAScript. Los patrones pueden comportarse de forma distinta en PCRE, Python o herramientas POSIX, así que consulta la tabla de comparación de sabores antes de portarlos.

¿Qué hacen los flags g, i, m, s y u?

g encuentra todas las coincidencias en lugar de solo la primera, i hace la búsqueda insensible a mayúsculas, m hace que ^ y $ coincidan con el inicio/fin de cada línea, s permite que . coincida con saltos de línea, y u habilita la coincidencia Unicode completa y los escapes de propiedades.

¿Cómo pruebo un buscar y reemplazar?

Activa el modo de reemplazo e introduce una cadena de reemplazo. Puedes referenciar grupos capturados con $1, la coincidencia completa con $&, y grupos con nombre con $<name>.

¿Por qué mi patrón se bloquea o tarda mucho?

Patrones como (a+)+b provocan backtracking catastrófico con entradas largas que no coinciden. La herramienta muestra el tiempo de ejecución de cada prueba, así que si un patrón tarda más de unos milisegundos, simplifícalo o usa character classes negadas en lugar de comodines voraces.