Probador de Regex Gratis — Depura Patrones en Línea
Prueba patrones de expresiones regulares al instante contra cualquier texto. Resaltado de coincidencias en vivo, grupos de captura, vista previa de reemplazo, división y explicador. Regex JavaScript, 100% privado, sin registro.
¿Qué Es un Probador de Regex?
Un probador de regex (probador de expresiones regulares) es una herramienta que te permite escribir un patrón regex, pegar un trozo de texto de prueba y ver exactamente con qué coincide el patrón, con grupos de captura, vista previa de reemplazo y desglose de flags, sin recompilar código ni ejecutar un script. Para desarrolladores, acorta el bucle de minutos a milisegundos: ajusta el patrón, mira cómo se mueven los resaltados, despliega el regex con confianza.
Una expresión regular es un lenguaje compacto para describir patrones de texto. `\d+` coincide con uno o más dígitos. `[A-Za-z_]\w*` coincide con un identificador típico. `(?
Este probador ejecuta el motor RegExp nativo de ECMA-262 que viene en cada navegador moderno: el mismo motor al que llamas desde JavaScript, TypeScript, Node.js, Deno o Bun. Eso significa: grupos de captura (numerados y nombrados con `(? Lo que el probador expone más allá de las coincidencias en bruto: el panel de Coincidencias y grupos de captura lista cada coincidencia con sus offsets [inicio, fin) y el valor de cada grupo de captura, la misma información que obtendrías de `String.prototype.matchAll` con el flag /d, pero dispuesta para escaneo visual. La pestaña Reemplazar muestra una vista previa de sustitución en vivo que soporta el alfabeto completo de plantillas $1 / $& / $` / $' / $$ / $ Sobre la privacidad: cada operación es local. Tu patrón y tu texto de prueba nunca salen de la página: no se registran, no se envían a un servicio de analítica, no se almacenan en disco. Solo tus preferencias de interfaz (pestaña activa + qué flags sueles tener encendidos) persisten en localStorage. Eso hace esta herramienta segura para muestras de log redactadas, patrones propietarios, configuración interna y patrones que incluyen pistas sobre el esquema de tus datos. Comparado con probadores con backend como regex101, la historia de privacidad y latencia es estrictamente mejor; el trade-off es soporte de un solo sabor (solo JavaScript). Si eres nuevo con regex, el desplegable Patrones comunes incluye iniciadores probados en combate: dirección de email, URL, IPv4, UUID, color hex, fecha ISO, número de teléfono de EE.UU. y un patrón para recortar espacios al final. Carga uno, observa las coincidencias contra el texto de muestra suministrado y luego muta el patrón un carácter cada vez para sentir cómo responde el motor. Combina esto con la herramienta Text Diff cuando quieras comparar antes/después de una limpieza guiada por regex, con Formateador JSON cuando tu entrada o salida esperada es JSON, o con codificador de URL cuando las cadenas con las que coincides están codificadas para URL.
// The pattern you build in this tester drops straight into JavaScript.
// Example: extract every ISO date from a string with named groups.
const pattern = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g;
const text = 'shipped 2026-05-21, scheduled 2026-06-30';
for (const m of text.matchAll(pattern)) {
console.log(m.groups.year, m.groups.month, m.groups.day);
// → 2026 05 21
// → 2026 06 30
}
// Same regex, used in a replace with $<name> templates:
text.replace(pattern, '$<day>/$<month>/$<year>');
// → 'shipped 21/05/2026, scheduled 30/06/2026'
// With the /d flag, every match carries [start, end] indices
// per capture group — the Matches panel uses this to paint offsets.
const p2 = /(?<year>\d{4})-(?<month>\d{2})/gd;
const m = [...text.matchAll(p2)][0];
m.indices.groups.year; // [8, 12] Características Clave
Resaltado de Coincidencias en Vivo
Cada coincidencia en tu texto de prueba se ilumina en el instante en que tu patrón parsea. Los colores alternos hacen fácil contar visualmente las coincidencias adyacentes y la insignia de conteo encima del resultado te dice el total exacto: sin botón Ejecutar, sin retraso de debounce mayor de 200 ms.
Panel Lateral de Grupos de Captura
El panel Coincidencias y grupos de captura a la derecha lista cada coincidencia como una tarjeta con sus offsets [inicio, fin), el texto completo de la coincidencia y cada grupo de captura posicional y nombrado dentro. Los grupos nombrados se etiquetan a sí mismos como $
Vista Previa de Reemplazo en Vivo con $1 / $& / $
Cambia a la pestaña Reemplazar para ver tu sustitución aplicada en tiempo real. El alfabeto completo de reemplazo de ECMAScript funciona: $1..$N para posicional, $
División por Fronteras de Regex
La pestaña Dividir llama a String.prototype.split con tu regex y muestra cada parte como una lista numerada. Las partes vacías se renderizan con un glifo ⏎ para que veas cómo el motor manejó los delimitadores adyacentes: útil para depurar limpieza de entrada tipo CSV.
Explicador de Patrón (Token a Token)
La pestaña Explicar tokeniza tu patrón en chips coloreados por clase (escape / cuantificador / clase de caracteres / grupo / ancla / alternación) y anota cada chip con una descripción de una línea. Léete tu propio regex antes de desplegar; úsalo para revisión de código o enseñanza.
A Salvo de ReDoS (Timeout de Reloj de Pared)
Cada llamada a coincidencia se envuelve en un presupuesto de 250 milisegundos. Las formas clásicas de retroceso catastrófico como `(a+)+`, `(a|aa)+b` y los cuantificadores profundamente anidados abortan limpiamente con una advertencia Patrón agotado: la página sigue respondiendo en lugar de bloquear la pestaña. Detección sin un sandbox del lado del servidor.
Biblioteca de Patrones Comunes
Iniciadores probados en combate para los ocho patrones a los que los desarrolladores más recurren: email, URL, IPv4, UUID v4, color hex, fecha ISO, número de teléfono de EE.UU. y recorte de espacios al final. Cada uno carga con una muestra coincidente para que veas el regex funcionando antes de adaptarlo.
Compartir por Permalink (Sin Subida)
Copiar enlace codifica patrón + flags + texto de muestra en el hash de la URL (#p=…&f=gim&t=…). Los navegadores nunca transmiten los fragmentos de URL en las peticiones, así que un enlace compartido reproduce tu estado en la máquina del destinatario sin tocar los servidores de go-tools.org. Autocontenido y amigable para auditoría.
100% Privado, Solo en el Navegador
Tu regex y texto de prueba nunca salen de tu dispositivo. Sin peticiones de red, sin logging, sin analítica de lo que escribes. Verifícalo en DevTools → Red: cero peticiones cuando escribes. Seguro para patrones propietarios, logs redactados y cualquier texto que no pegarías en regex101.
Ejemplos Trabajados
Extraer cada dirección de email de un párrafo
[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,} /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g Pega el patrón con el flag /g activado, suelta un párrafo en el texto de prueba y cada email se ilumina en la vista resaltada. El panel de Coincidencias y grupos de captura a la derecha lista cada dirección con sus offsets [inicio, fin): útil cuando canalizas el mismo regex hacia grep, sed o un editor de código.
Capturar partes de fecha con grupos nombrados
(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/g Los grupos nombrados de ECMA-262 aparecen en el panel derecho como $
Buscar y reemplazar con retrorreferencias $1
(\w+) (\w+)
Reemplazo: $2, $1 → Jack Doe → Doe, Jack
Dos grupos de captura sin nombre, plantilla de reemplazo $2, $1, y la pestaña Reemplazar te da una vista previa en vivo. $&, $`, $', $$ y $
Eliminar espacios en blanco al final línea por línea
[ \t]+$
/[ \t]+$/gm
Combina los flags /g (global) y /m (multilínea) para que $ ancle al final de cada línea, no solo al final de la entrada. La pestaña Reemplazar con un reemplazo vacío muestra una diff limpia: las tabulaciones y espacios finales desaparecen, la prosa se queda en su sitio. El mismo regex con el flag /s (dotAll) desactivado impide que . cruce saltos de línea.
Detectar retroceso catastrófico y sobrevivir a él
(a+)+b
Texto de prueba: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaac
Los cuantificadores + anidados forman un patrón ReDoS clásico. En un probador ingenuo esto cuelga la pestaña. Aquí el guardia de reloj de pared se dispara tras 250 ms, aparece el banner Patrón agotado y la página sigue respondiendo. Ancla el patrón, cambia a una alternación no solapada o usa modismos pseudoatómicos, y vuelve a probar.
Dividir una línea tipo CSV por delimitadores mixtos
[,;|]\s*
alpha, beta; gamma | delta → ["alpha", "beta", "gamma", "delta"]
Cambia a la pestaña Dividir. Cualquier coma, punto y coma o barra vertical (seguida de espacio opcional) se convierte en una frontera de partes. Útil para limpiar listas de etiquetas copiadas y pegadas, normalizar entrada de usuario o preprocesar campos de log antes de un parser CSV real: consulta CSV a JSON cuando los datos realmente sean RFC 4180.
Cómo Usar el Probador de Regex
- 1
Escribe tu patrón entre las barras
Suelta cualquier expresión regular ECMA-262 en el campo /…/. Los patrones incorrectos se resaltan en rojo con un mensaje del parser; los patrones válidos pasan a coincidencia en vivo.
- 2
Activa los flags que necesites
g (global), i (insensible a mayúsculas), m (multilínea), s (dotAll), u (unicode), y (sticky), d (índices). Cada chip se enciende cuando está activo; la lectura a la derecha del patrón muestra el literal canónico.
- 3
Pega tu texto de prueba
Las coincidencias se resaltan en colores alternos mientras escribes. El panel Coincidencias y grupos de captura a la derecha lista cada coincidencia con offsets [inicio, fin) y el valor de cada grupo de captura (grupos nombrados etiquetados como $
). - 4
Cambia de pestaña para Reemplazar, Dividir o Explicar
Reemplazar previsualiza una plantilla de sustitución junto a la entrada. Dividir corta en cada frontera de coincidencia. Explicar descompone el patrón token a token con una descripción en español llano por elemento.
- 5
Copia el literal o comparte un permalink
Copiar /patrón/flags suelta el literal canónico de regex en tu portapapeles para uso directo en JavaScript / TypeScript / Node. Copiar enlace codifica el estado completo en un hash de URL (sin subida) para que un colega pueda reproducirlo localmente.
Errores Comunes de Regex
Olvidaste el flag /g y solo conseguiste una coincidencia
Sin /g (o /y), el motor se detiene tras la primera coincidencia. Los métodos match, matchAll, replace y split se comportan de forma distinta alrededor del flag global. Activa /g y vuelve a ejecutar; el conteo sobre los resultados salta de 1 a N.
Patrón: /\d+/ → '1 22 333' produce solo ['1']
Patrón: /\d+/g → '1 22 333' produce ['1', '22', '333']
Un cuantificador codicioso consumió demasiado
`.+` consume tanto como sea posible, así que `<.+>` contra ` and ` captura ` and `, no ``. Usa cuantificadores perezosos (`.+?`), clases de caracteres más restrictivas (`[^>]+`) o ancla con look-arounds.
Patrón: /<.+>/ → coincide con '<a> and <b>'
Patrón: /<[^>]+>/ → coincide con '<a>' y '<b>' por separado
Retroceso catastrófico por cuantificadores anidados
`(a+)+b` contra una cadena larga que falla explota exponencialmente. El banner Patrón agotado se dispara tras 250 ms; reescribe para eliminar el anidamiento: `a+b` hace el mismo trabajo en tiempo lineal. La simulación de grupo atómico `(?=(a+))\1b` es otra opción.
Patrón: /(a+)+b/ sobre 'aaaaaaaaaaaaaaaaaaaaac' → timeout
Patrón: /a+b/ sobre la misma entrada → 'no coincide' al instante
Las anclas $ y ^ no se comportan como \A y \Z de Python
En JavaScript, `^` y `$` significan inicio de línea / fin de línea SOLO cuando /m está activado; en otro caso significan inicio de cadena / fin de cadena. `\A` y `\Z` de Python (que siempre significan fronteras de cadena) no existen en JS. Activa /m según haga falta.
Patrón: /^Error/ sobre un log multilínea sin /m → coincide solo con la primera línea
Patrón: /^Error/m sobre la misma entrada → coincide con cada línea que empiece por Error
Usaste $1 en una cadena pero llamaste a replace con una función
`text.replace(re, '$1')` expande la retrorreferencia. `text.replace(re, () => '$1')` pasa una cadena literal '$1' porque las funciones no ven los tokens de plantilla. Dentro de la función, los grupos de captura llegan como argumentos posicionales.
text.replace(/(\w+)/, m => '$1') → produce el literal '$1'
text.replace(/(\w+)/, (_, g1) => g1.toUpperCase()) → usa la captura
Caracteres Unicode no coinciden con \w o .
El `\w` por defecto es `[A-Za-z0-9_]`. Para coincidir con cada letra en cada escritura, activa /u y cambia a `\p{Letter}` (`\p{L}`). El punto también se detiene en los saltos de línea por defecto: usa /s (dotAll) cuando quieras un verdadero cualquier-carácter.
Patrón: /\w+/ coincide con 'hello' pero no con 'héllo' ni '你好'
Patrón: /\p{Letter}+/u coincide con los tres Pegaste un patrón PCRE; obtuviste un SyntaxError
JavaScript no soporta grupos atómicos `(?>...)`, cuantificadores posesivos `a++`, modificadores inline `(?i)`, condicionales `(?(1)yes|no)` ni `\A` / `\Z`. El error del parser nombra la construcción ofensora: reescribe al equivalente soportado por JS (simulación con look-around, conmutación de flag por separado, alternación).
Patrón: (?i)foo → SyntaxError: invalid group
Patrón: foo con flag /i activado → mismo efecto
Quién Usa Esta Herramienta
- Validar Entradas de Formulario Antes de Desplegar
- Confirma que tu regex de email / teléfono / código postal / nombre de usuario coincide con lo que esperas, y rechaza lo que no esperas, en casos límite (nombres unicode, alias con plus, formatos internacionales) antes de que la validación llegue a producción y rebote a usuarios reales.
- Extraer Datos de Logs y Configs
- Construye un patrón que extraiga IDs de petición, códigos de estado, latencias o líneas de stack-trace de una rebanada arbitraria de log. Los grupos nombrados hacen los datos autodocumentados; el panel de Coincidencias muestra offsets para que después canalices el mismo regex hacia `rg --replace` o `grep -oE`.
- Buscar y Reemplazar en una Base de Código
- Esboza un patrón de refactor (p. ej. `(\w+)\.apply\(null,\s*\[(.*?)\]\)` → `$1($2)`) aquí, previsualiza la sustitución contra fragmentos representativos y luego pega el regex validado en el buscar/reemplazar a nivel de proyecto de tu editor con confianza.
- Comprobar la Cordura de un Patrón Encontrado en Línea
- ¿Pegaste un regex de StackOverflow o un blog? Suéltalo en la pestaña Explicar: cada token se anota en español llano. Caza problemas sutiles (`.+?` donde querías `.+`, anclas `^`/`$` que faltan, cuantificadores accidentalmente codiciosos) antes de que el regex aterrice en tu código.
- Enseñar Regex a un Compañero de Equipo
- Abre la pestaña Explicar sobre un patrón que funciona y camina por él token a token. El código de color (escape / cuantificador / clase de caracteres / grupo / ancla / alternación) deja que quien aprende vea la forma estructural del regex, no solo los caracteres.
- Portar un Patrón Entre Lenguajes
- ¿Tienes un regex de Python o PCRE que necesitas usar en JavaScript? Pégalo aquí. Si parsea, el explicador te muestra la semántica equivalente en JS; si no, el error del parser nombra la construcción ofensora (grupos atómicos, cuantificadores posesivos, `(?i)` inline) para que sepas exactamente qué reescribir.
- Depurar un Regex Lento de Producción
- Si se sospecha que un regex de servidor sufre retroceso catastrófico, pégalo en este probador con una muestra de la entrada. El guardia de reloj de pared de 250 ms se dispara en casos patológicos, dándote un diagnóstico inmediato antes de que recurras a herramientas de profiling, y el explicador señala la causa raíz del cuantificador anidado.
Notas del Motor y Algoritmo
- Motor RegExp ECMA-262 (Navegador Nativo)
- Usa `new RegExp(pattern, flags)` y el motor que viene con V8 / JavaScriptCore / SpiderMonkey: la misma semántica de regex que obtienes en JavaScript en cualquier sitio. Los patrones que se validan aquí corren sin cambios en Node.js, Deno, Bun y cualquier navegador moderno.
- Iteración de Coincidencias vía String.matchAll
- La iteración global usa `text.matchAll(regex)` en lugar de un bucle manual de lastIndex, así que cada coincidencia lleva sus grupos de captura, grupos nombrados y (con /d) índices [inicio, fin]. Las coincidencias de ancho cero se manejan con el avance estándar +1 de lastIndex para evitar bucles infinitos.
- Timeout de Reloj de Pared para Protección ReDoS
- Un presupuesto de 250 milisegundos envuelve cada llamada a coincidir, reemplazar y dividir. El motor aún puede retroceder internamente en un solo intento de coincidencia, pero la iteración exterior coopera con el presupuesto: los patrones patológicos abortan con `timedOut: true` y la interfaz expone una advertencia en lugar de bloquear la pestaña.
- Reimplementación de la Plantilla de Reemplazo
- La pestaña Reemplazar parsea $1..$N, $&, $`, $', $$ y $
manualmente en lugar de delegar en `String.replace`, así que la vista previa se comporta de forma idéntica entre motores (Safari antiguo, Node antiguo) donde las plantillas de grupo nombrado tienen casos límite. La salida es exactamente lo que producen los motores de JavaScript actuales. - Tokenizador de Patrón para el Explicador
- La pestaña Explicar corre un tokenizador escrito a mano que clasifica cada fragmento de patrón (escape / metacarácter / cuantificador / clase de caracteres / apertura de grupo / cierre de grupo / ancla / alternación). Las construcciones no familiares caen a `literal` con una nota genérica para que el explicador nunca pierda contenido en silencio.
- Permalinks vía Hash de URL (Nunca Transmitido)
- El estado para compartir se codifica en el fragmento location.hash (`#p=…&f=…&t=…&tab=…`). Los navegadores nunca transmiten el fragmento en las peticiones HTTP, así que los servidores de go-tools.org reciben cero datos cuando se abre un permalink. La hidratación ocurre enteramente en el dispositivo del destinatario.
Buenas Prácticas de Regex
- Ancla los Patrones Cuando Lo Pretendas
- `^pattern$` coincide con una cadena exacta; `pattern` coincide en cualquier sitio. La elección equivocada es el bug más común en la validación de formularios: la falta de `^` deja pasar un `attacker.com/` inicial a una comprobación de dominio; la falta de `$` deja pasar basura final. Usa la pestaña Coincidir contra muestras rotas a propósito para confirmar qué se rechaza.
- Prefiere Grupos Sin Captura para Estructura Pura
- `(?:foo|bar)+` y `(foo|bar)+` son funcionalmente idénticos, pero el primero no asigna un grupo de captura. Recurre a `(?:…)` siempre que el grupo exista solo para un cuantificador o alternación: mantiene estables tus $1..$N numerados y ahorra una pequeña cantidad de trabajo del motor.
- Usa el Flag /u para Cualquier Cosa Más Allá de ASCII
- Sin /u, el punto y `\w` tratan los caracteres de par sustituto (emoji, puntos de código no BMP) como dos unidades UTF-16. Con /u, son un punto de código cada uno: lo que tus usuarios percibirán. /u también habilita `\p{Letter}` y otros escapes de propiedad. Por defecto, usa /u para patrones nuevos a menos que tengas una razón específica para no hacerlo.
- Nombra Tus Grupos de Captura
- `(?
\d{4})-(? \d{2})` es autodocumentado. Seis meses después, cuando releas el regex, `m.groups.year` es obviamente el año; `m[1]` no lo es. Las plantillas de reemplazo con $ sobreviven al reordenamiento de grupos: las plantillas posicionales se rompen en cuanto alguien añade otro grupo. - Prueba los Casos de Fallo, No Solo los de Éxito
- Un probador de regex es para los fallos. Confirma con qué coincide tu patrón, luego muta deliberadamente el texto de prueba para ver con qué no coincide: espacios iniciales, espacios finales, partes que faltan, partes extra, caso equivocado, escrituras mezcladas. Los patrones que pasan con entrada válida pero aceptan basura son los bugs que producción expone primero.
Preguntas Frecuentes
¿Mi regex o texto de prueba se envía a vuestro servidor?
¿Qué sabor de regex usa este probador: PCRE, Python, Java, JavaScript?
¿Qué hace cada uno de los flags g, i, m, s, u, y, d?
¿Cómo escribo grupos de captura y cómo me refiero a ellos?
¿Cómo funcionan look-ahead y look-behind, y para qué sirven?
¿Por qué mi regex cuelga el navegador y qué es el retroceso catastrófico?
¿En qué se diferencia este probador de regex de regex101.com?
¿Cómo escapo caracteres especiales como . | ( ) [ ] { } * + ? ^ $ \?
¿Puedo compartir un regex con un colega vía enlace?
¿El probador soporta Unicode, emoji y escrituras no latinas?
¿Cuál es la diferencia entre .match, .matchAll, .replace y .split con un regex?
¿Por qué mi regex de Python o Java no funciona aquí?
¿Hay un tamaño máximo de texto o conteo máximo de coincidencias?
Herramientas relacionadas
Ver todas las herramientas →Comparar dos textos — Diff
Procesamiento de Texto
Compara dos textos al instante en tu navegador. Vista lado a lado, resaltado palabra por palabra, exportación a diff unificado, opciones para ignorar mayúsculas/espacios/líneas vacías. 100 % navegador — sin uploads.
Contador de Palabras y Caracteres Gratis
Procesamiento de Texto
Cuenta palabras, caracteres, oraciones, párrafos y tiempo de lectura al instante. Contador de palabras en tiempo real con límites de Twitter, meta descripción e Instagram. Gratis, privado y sin registro.
Conversor de Bases — Binario, Hex, Decimal, Octal
Herramientas de Conversión
Convierte números entre binario, hexadecimal, decimal, octal y cualquier base personalizada (2-36) al instante. Gratis, privado, sin registro — todo el procesamiento ocurre en tu navegador.
Decodificador y Codificador Base64
Codificación y Formato
Decodifica y codifica Base64 online de forma gratuita. Conversión en tiempo real con soporte completo de UTF-8 y emojis. 100% privado — funciona en tu navegador. Sin registro.
Generador Crontab y Constructor de Expresiones Cron
Fecha y Hora
Construye, valida y decodifica expresiones cron en el navegador. Vista previa de próximas ejecuciones en hora local o UTC. POSIX 5 campos, presets y descripción natural. Gratis y privado.
Convertidor de CSV a JSON
Codificación y Formato
Convierte CSV a JSON en tu navegador. RFC 4180, inferencia de tipos, fila de cabecera, seguro para big-int. 100% privado, sin carga.