Regex Tester
| # | Índice | Coincidencia | Grupos |
|---|---|---|---|
| 1 | 5 | 42 | — |
| 2 | 14 | 7 | — |
Patrones comunes
Cómo funciona
Escribe una expresión regular arriba, escribe o pega debajo el texto que quieres probar y la herramienta resalta cada coincidencia en tiempo real. Cada coincidencia aparece en una etiqueta de color sobre el texto de prueba, y una tabla de resultados debajo indica la cadena coincidente, su índice, su longitud y los grupos de captura (posicionales y con nombre). Los patrones se compilan con el motor `RegExp` nativo del navegador, así que lo que ves aquí es exactamente lo que verá tu código JavaScript, Node o Deno en producción.
Una expresión regular es un minilenguaje compacto para describir patrones de texto. Estos son los bloques básicos que usarás una y otra vez:
• `.` coincide con cualquier carácter excepto el salto de línea • `\d` coincide con un dígito (0–9), `\D` con un no dígito • `\w` coincide con un carácter de palabra (letras, dígitos, guion bajo), `\W` con uno que no lo es • `\s` coincide con un espacio en blanco (espacio, tabulación, salto de línea), `\S` con un no espacio • `[abc]` coincide con cualquiera de a, b, c. `[a-z]` es un rango. `[^abc]` niega el conjunto • `+` es una o más. `*` es cero o más. `?` es cero o una. `{3}` exactamente 3. `{2,5}` de 2 a 5. `{2,}` 2 o más • `^` es el inicio de línea o de texto. `$` es el final de línea o de texto • `\b` es un límite de palabra. `\B` un no límite • `(...)` es un grupo de captura. `(?:...)` un grupo sin captura. `(?<nombre>...)` un grupo con nombre • `(?=...)` es lookahead. `(?!...)` lookahead negativo. `(?<=...)` lookbehind. `(?<!...)` lookbehind negativo • `|` es la alternancia (o)
Los flags (las letras después de la `/` final) cambian el comportamiento de todo el patrón: `g` encuentra todas las coincidencias en lugar de solo la primera, `i` ignora mayúsculas y minúsculas (A = a), `m` hace que `^` y `$` coincidan con el inicio y el final de cada línea en lugar de con los del texto entero, `s` hace que `.` también coincida con los saltos de línea, `u` activa Unicode completo (imprescindible para emoji y caracteres no latinos) e `y` coincide de forma pegajosa solo en la posición de lastIndex.
La trampa que conviene conocer: el backtracking catastrófico. Los patrones con cuantificadores anidados como `(a+)+$` sobre una cadena larga que casi coincide pueden tardar minutos en fallar, porque el motor prueba todas las divisiones posibles. La solución es evitar el anidamiento, usar grupos atómicos donde existan o reescribir el patrón (`a+$` funciona sin problema). Si la pestaña de tu navegador se congela al pegar un patrón, casi siempre es por esto.
La herramienta funciona por completo en tu navegador: el patrón y el texto de prueba se compilan y ejecutan con el motor RegExp de tu navegador. Nada sale de tu dispositivo, lo que importa porque al probar una regex se suelen usar direcciones de correo reales, tokens de autenticación, fragmentos de logs o datos personales que no querrías enviar a un servidor.
Preguntas frecuentes
¿Qué es una expresión regular?
- Un patrón que describe un conjunto de cadenas de texto. Bloques habituales: . (cualquier carácter), \d (dígito), \w (carácter de palabra), + (una o más), * (cero o más), ^ (inicio de línea), $ (final de línea), [] (conjunto de caracteres), () (grupo de captura). Ejemplo: \d{2}/\d{2}/\d{4} coincide con fechas como 25/12/2025.
¿Qué sintaxis de regex admite este probador?
- Toda la sintaxis estándar de regex de JavaScript, porque la herramienta usa el motor RegExp integrado del navegador. Eso incluye lookahead, lookbehind, grupos con nombre y escapes de propiedades Unicode.
¿Qué significan los flags g, i, m, s, u e y?
- g = global (encuentra todas las coincidencias, no solo la primera), i = sin distinguir mayúsculas (A coincide con a), m = multilínea (^ y $ coinciden con el inicio y el final de cada línea, no solo del texto entero), s = dotAll (. también coincide con los saltos de línea), u = Unicode (soporte completo de Unicode), y = sticky (coincide solo desde la posición exacta).
¿Por qué mi regex no coincide en varias líneas?
- Activa el flag m (multilínea) si tu patrón usa los anclajes ^ o $, para que coincidan con el inicio y el final de cada línea y no con los del texto entero. Ten en cuenta también que . no coincide con los saltos de línea por defecto: activa el flag s (dotAll) si quieres que lo haga.
¿Por qué se congela la pestaña del navegador con un patrón concreto?
- Casi seguro estás sufriendo backtracking catastrófico. Patrones como (a+)+$ o (.*)*$ sobre una cadena que casi coincide crecen de forma exponencial porque el motor prueba todas las divisiones posibles. La solución es hacer atómico el cuantificador interior, usar cuantificadores posesivos donde tu motor los tenga o reescribir el patrón sin cuantificadores anidados.
¿Cómo uso los grupos de captura en una regex?
- Encierra entre paréntesis la parte que quieres conservar, lo que crea un grupo numerado. (\d{4})-(\d{2})-(\d{2}) sobre “2026-04-18” captura “2026”, “04” y “18” como grupos 1, 2 y 3. También puedes poner nombre a un grupo con (?<year>\d{4}) y referirte a él por su nombre en los reemplazos o en el código, y usar (?:...) cuando necesites agrupar sin capturar.
¿Se envía mi texto a algún sitio?
- No. El patrón se compila y ejecuta en local con el motor RegExp nativo del navegador. Nada de tu patrón ni del texto de prueba sale de tu dispositivo, lo que importa porque es habitual probar patrones con direcciones de correo reales, tokens de autenticación o fragmentos de logs.
Patrones de regex habituales: chuleta para copiar y pegar
Patrones probados para lo que los desarrolladores buscan con más frecuencia. Todos son compatibles con JavaScript (úsalos tal cual en `new RegExp(...)` o `/.../flags`). Añade el flag `i` donde quieras ignorar mayúsculas y minúsculas.
| Qué busca | Patrón | Ejemplos que coinciden | Notas |
|---|---|---|---|
| Correo electrónico (pragmático) | ^[^\s@]+@[^\s@]+\.[^\s@]+$ | alice@example.com, bob+tag@a.co | No sigue el RFC 5322 al pie de la letra, pero acepta cerca del 99% de las direcciones reales sin falsos negativos. El patrón completo del RFC tiene 6000 caracteres y rechaza correos válidos. Aquí lo pragmático gana a lo correcto |
| URL (http/https) | https?:\/\/[\w\-]+(\.[\w\-]+)+[\/\w\-\.~:?#\[\]@!$&'()*+,;=%]* | https://example.com/path?q=1 | Coincide con la mayoría de las URL http(s). Para un análisis a fondo usa la API URL (`new URL(s)`) |
| Dirección IPv4 | \b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b | 192.168.1.1, 10.0.0.255 | Valida que cada octeto sea ≤ 255. Para solo “4 números separados por puntos” usa `\b\d{1,3}(\.\d{1,3}){3}\b` |
| IPv6 (flexible) | \b(?:[A-Fa-f0-9]{1,4}:){7}[A-Fa-f0-9]{1,4}\b | 2001:db8::1, ::1 (con compresión) | Un IPv6 estricto con todas sus formas ocupa unos 150 caracteres; esta forma pragmática cubre el caso completo sin comprimir |
| Código fiscal italiano (CF) | ^[A-Z]{6}\d{2}[A-EHLMPRST]\d{2}[A-Z]\d{3}[A-Z]$ | RSSMRA80A01H501Z | Comprobación estructural básica, sin dígito de control. 16 caracteres en mayúsculas |
| Número de IVA de la UE (genérico) | ^[A-Z]{2}[A-Z0-9]{2,12}$ | IT12345678901, DE123456789 | Solo estructural. Para una validación real usa el servicio web VIES |
| UUID v4 | ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$ | f47ac10b-58cc-4372-a567-0e02b2c3d479 | Usa el flag `i` para mayúsculas. El `4` y `[89ab]` imponen la especificación v4 |
| Color hexadecimal (#abc / #aabbcc) | ^#(?:[\dA-Fa-f]{3}|[\dA-Fa-f]{6}|[\dA-Fa-f]{8})$ | #fff, #1A73E8, #80ffffff | Acepta 3, 6 y 8 dígitos (con alfa) |
| Fecha ISO (AAAA-MM-DD) | ^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$ | 2026-04-18, 2026-12-31 | Estructural: no valida el 30 de febrero. Combínalo con `Date.parse()` para una validación completa |
| Fecha y hora ISO (con Z) | ^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z?$ | 2026-04-18T14:32:00Z | ISO 8601 con milisegundos opcionales y zona horaria Z |
| Hora de 24 horas HH:MM | ^([01]\d|2[0-3]):[0-5]\d$ | 09:30, 23:59 | Añade `:[0-5]\d` al final para HH:MM:SS |
| Contraseña fuerte (8 o más, mezcla) | ^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[^\w\s]).{8,}$ | P@ssw0rd, MyT@xes1 | Los lookaheads exigen al menos 1 minúscula, 1 mayúscula, 1 dígito y 1 carácter especial. Las recomendaciones actuales prefieren la longitud a la composición |
| Slug (seguro para URL) | ^[a-z0-9]+(?:-[a-z0-9]+)*$ | my-blog-post, hello | Letras minúsculas, dígitos y guiones. Sin guiones al principio, al final ni consecutivos |
| Línea solo con espacios en blanco | ^\s*$ | (vacía), (solo espacios) | Con el flag `m`, coincide con cada línea en blanco de una cadena multilínea |
| Quitar espacios del principio y del final | ^\s+|\s+$ | hello | Úsalo con `.replace(/^\s+|\s+$/g, '')`, equivale a `String.trim()` |
| Teléfono (internacional, flexible) | ^\+?[1-9]\d{1,14}$ | +393331234567, 14155551212 | Formato E.164. Prefijo de país opcional. Para una validación estricta por país usa libphonenumber |
| Tarjeta de crédito, solo dígitos (flexible) | ^\d{13,19}$ | 4111111111111111 | Solo comprueba la longitud. Usa el algoritmo de Luhn para una validación real |
| Enlace en Markdown | \[([^\]]+)\]\(([^)]+)\) | [Click](https://x.com) | Captura grupo 1 = texto, grupo 2 = URL. No admite corchetes anidados: es una limitación, no un fallo |
| Etiqueta HTML (flexible) | <\/?[a-z][\w-]*(?:\s+[\w-]+(?:="[^"]*"|='[^']*'|=\S+)?)*\s*\/?> | <a href="x"> | No uses regex para analizar HTML arbitrario. Para un análisis en producción usa DOMParser. Sirve para rastrear logs |
Los patrones son compatibles con JavaScript (regex de ECMAScript 2018 o posterior) y se han probado con el motor `RegExp` nativo de JavaScript. Las implementaciones de PCRE, Python o Java pueden diferir en casos límite (sobre todo en el soporte de lookbehind y de propiedades Unicode).