Cargando aplicación...
Preparando tu experiencia meskeIA
Testa y valida regex con resaltado de coincidencias
Escribe un patrón y texto para ver las coincidencias
. Cualquier carácter\d Dígito (0-9)\w Alfanumérico\s Espacio en blanco* 0 o más+ 1 o más? 0 o 1{n} Exactamente n^ Inicio$ Final\b Límite de palabra(abc) Grupo de captura[abc] Clase de caracteresa|b AlternanciaSintaxis avanzada, diferencias entre motores (JS, Python, PCRE) y patrones para casos comunes
Las expresiones regulares (regex o regexp) son secuencias de caracteres que definen un patrón de búsqueda. Desarrolladas en los años 50 por el matemático Stephen Kleene, hoy son omnipresentes en programación, validación de formularios, procesamiento de texto y herramientas de línea de comandos.
(?<nombre>patrón) — en lugar de referirse al grupo por número (\1), usa el nombre (\k<nombre>). Más legible y mantenible.(?:patrón) — agrupa sin crear un grupo de captura. Útil cuando necesitas alternancia pero no quieres el overhead de captura.(?=patrón) — asegura que el texto va seguido de algo, sin incluirlo en la coincidencia. Ej: \d+(?= €) captura el número antes del símbolo del euro.(?!patrón) — asegura que el texto NO va seguido de algo. Ej: foo(?!bar) captura "foo" solo cuando no va seguido de "bar".(?<=patrón) — asegura que el texto va precedido de algo. Ej: (?<=€)\d+ captura el número después del euro.*?, +?, ?? — por defecto los cuantificadores son «voraces» (greedy) y capturan lo máximo posible. El ? los hace «perezosos» y capturan lo mínimo posible.s (dotAll, ES2018+), flag d (indices, ES2022+). No soporta: lookbehind de longitud variable en motores antiguos.re.fullmatch), re.VERBOSE para comentarios en el patrón. Sintaxis de grupos: (?P<nombre>).(?R)), condicionales, posesivos (a++), atómicos.\d, \w. Usa [0-9], [a-zA-Z0-9_]. No tiene grupos de no captura ni lookaheads.Nota: Esta herramienta usa el motor de JavaScript (navegador).
(a+)+ con texto largo pueden bloquear el navegador. Ocurre cuando el motor explora exponencialmente todas las combinaciones posibles. Evita anidar cuantificadores sobre clases ambiguas.. * + ? ^ $ [ ] | ( ) \ tienen significado especial. Para buscarlos literalmente, escápalos con \.^ y $, el patrón puede coincidir en cualquier parte del texto. Para validación, siempre ancla: ^\d5$ valida exactamente 5 dígitos.regex.exec() con flag g mantiene estado. Si reseteas el texto sin resetear el regex, el índice queda desalineado. Usa regex.lastIndex = 0 o crea una nueva instancia.^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$ — al menos 8 caracteres con minúscula, mayúscula, número y símbolo.^[a-z0-9]+(?:-[a-z0-9]+)*$ — solo minúsculas, números y guiones intermedios.^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$^\d+([.,]\d{1,2})?$ — admite tanto punto como coma decimal.#[a-zA-ZÀ-ÿ\w]+ — incluye caracteres acentuados.| Categoría | Metacarácter | Significado | Ejemplo de patrón | Caso de uso típico |
|---|---|---|---|---|
| Anchors | ^ | Inicio de cadena / línea | ^\d+ | Validar que la cadena empieza con dígitos |
$ | Final de cadena / línea | \d+$ | Validar que la cadena termina con dígitos | |
\b | Límite de palabra | \bcat\b | Buscar palabra exacta sin substring parcial | |
| Cuantificadores | * | 0 o más repeticiones (greedy) | ab*c | Campos opcionales de longitud variable |
+ | 1 o más repeticiones (greedy) | \w+ | Palabras que deben tener al menos un carácter | |
? | 0 o 1 repetición (opcional) | colou?r | Aceptar variantes ortográficas (color / colour) | |
{n} | Exactamente n repeticiones | \d{5} | Código postal español de 5 dígitos exactos | |
{n,m} | Entre n y m repeticiones | [a-z]{2,4} | Extensiones de dominio (es, com, info) | |
| Clases | \d | Dígito (equivale a [0-9]) | \d{2}/\d{2}/\d{4} | Validar fecha en formato DD/MM/YYYY |
\w | Alfanumérico + guión bajo | \w+@\w+\.\w+ | Estructura básica de email | |
\s | Espacio en blanco (espacio, tab, salto) | \s+ | Normalizar espacios múltiples en texto | |
[abc] | Clase de caracteres personalizada | [aeiou] | Encontrar todas las vocales en un texto | |
| Grupos | (...) | Grupo de captura | (\d{4}-\d{2}-\d{2}) | Extraer fechas para procesarlas por partes |
(?:...) | Grupo de no captura | (?:https?://)\w+ | Agrupar sin crear referencia de captura | |
(?=...) | Lookahead positivo | \d+(?= €) | Capturar precio sin incluir el símbolo | |
| Alternación | a|b | Coincide con a o con b | cat|dog | Validar múltiples valores permitidos |
Validación de formularios de usuario en el frontend y backend.
/^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$/Email/^(\+34)?[6789]\d{8}$/Teléfono España/^[0-9XYZ]\d{7}[A-Z]$/DNI/NIE/^\d{5}$/Código PostalTip: Combina regex con validación semántica (verificar dominio del email) para mayor fiabilidad.
Extracción de datos estructurados desde texto no estructurado (logs, documentos, scraping).
/\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}/gIPs en logs/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/gTimestamps ISO/\d+[.,]\d{2}\s*€/gPrecios en eurosTip: Usa grupos de captura nombrados (?<nombre>...) para acceder a los datos extraídos por clave en lugar de por índice.
Filtrado y análisis de logs del sistema con herramientas de línea de comandos.
grep -E 'ERROR|WARN' app.logFiltrar por nivelgrep -P '\[5\d{2}\]' access.logErrores 5xx HTTPsed -E 's/(\d+\.\d+\.\d+\.\d+)/[IP]/g'Anonimizar IPsTip: En POSIX (grep básico, sed sin -E) usa [0-9] en lugar de \d y [a-zA-Z0-9_] en lugar de \w.
Verificación automatizada de formatos en salidas de la aplicación y APIs.
/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/iUUID v4/^\d{4}-\d{2}-\d{2}$/Fecha ISO 8601/^https?:\/\/.+\..+/URLs en respuestasTip: Escribe siempre casos negativos: cadenas vacías, longitudes límite y caracteres especiales como ñ, tildes o emojis.
Los cuantificadores greedy (voraces) como *, + y ? capturan la mayor cantidad de texto posible. Los lazy (perezosos) como *?, +? capturan la mínima cantidad. Ejemplo: ante <b>texto</b>, el patrón <.*> (greedy) captura todo, mientras que <.*?> (lazy) captura solo <b>.
Un patrón práctico es /^[\w.-]+@[\w.-]+\.[a-zA-Z]{2,}$/. No existe una regex perfecta para email (la especificación RFC 5322 es muy compleja). Para producción, lo más fiable es validar el formato básico con regex y luego enviar un email de confirmación para verificar que el buzón existe.
El estándar permite caracteres como +, comillas y paréntesis en el usuario del email, que muchas regex descartan. Decide el nivel de permisividad según tu caso de uso.
Los paréntesis (...) crean un grupo de captura: la parte del texto que coincide queda almacenada para usarla después. En JavaScript, match[1] devuelve el primer grupo. Con grupos nombrados (?<año>\d{4}), accedes por match.groups.año. Los grupos de no captura (?:...) agrupan sin almacenar.
En la mayoría de motores modernos (JavaScript, Python, PCRE) son equivalentes para el ASCII básico. Sin embargo, \d en algunos motores puede incluir dígitos Unicode (como dígitos árabes ٠١٢ o dígitos de escrituras asiáticas). Si necesitas estrictamente dígitos ASCII, usa [0-9]. En POSIX (grep sin -P) \d no está disponible, debes usar [0-9].
Añade el flag i al patrón. En JavaScript: /patrón/i o new RegExp('patrón', 'i'). En Python: re.compile('patrón', re.IGNORECASE). En grep: grep -i. En esta herramienta, activa el botón i (insensible) en la sección de flags.
Son aserciones de posición que comprueban qué hay delante o detrás sin incluirlo en la coincidencia. Lookahead positivo (?=...): el texto debe ir seguido de algo. Lookahead negativo (?!...): el texto NO debe ir seguido de algo. Lookbehind positivo (?<=...): el texto debe ir precedido de algo. Lookbehind negativo (?<!...): el texto NO debe ir precedido de algo.
Cada motor tiene pequeñas diferencias. Las más comunes: (1) Python usa (?P<nombre>) para grupos nombrados, JavaScript usa (?<nombre>). (2) Python no soporta lookbehind de longitud variable en algunos casos. (3) En Python, re.match() ancla al inicio pero no al final (usar re.fullmatch() para anclar ambos). (4) En Python los strings raw r'\d+' evitan problemas con el escape de barras invertidas.
El ReDoS (Regular Expression Denial of Service) ocurre con patrones que generan backtracking exponencial, como (a+)+ ante cadenas largas. Estrategias de mitigación: (1) Evita anidar cuantificadores sobre clases ambiguas. (2) Usa cuantificadores posesivos (a++) o grupos atómicos ((?>a+)) si el motor los soporta. (3) Añade anchors para reducir el espacio de búsqueda. (4) Usa herramientas como safe-regex o rxxr2 para detectar patrones vulnerables.
Antes de escribir ningún símbolo, describe con palabras qué quieres encontrar. Ejemplo: “un número de teléfono español que puede empezar con +34, seguido de 9 dígitos que empiecen por 6, 7, 8 o 9”. Esta descripción es tu especificación de requisitos.
Distingue qué partes son texto fijo (literal) y qué partes varían. En el ejemplo del teléfono, +34 es literal, pero los 9 dígitos varían. Los caracteres con significado especial en regex (. * + ? ^ $ [ ] | ( ) \) deben escaparse con \ cuando los usas como literales.
Reemplaza las descripciones de las partes variables por metacaracteres: \d para dígitos, \w para alfanuméricos, [6789] para una clase de caracteres concreta. Construye el esqueleto del patrón: (\+34)?[6789]\d\d\d\d\d\d\d\d.
Sustituye repeticiones por cuantificadores. \d\d\d\d\d\d\d\d se convierte en \d{8}. El patrón queda: (\+34)?[6789]\d{8}. Elige entre greedy (*, +), lazy (*?) o exacto ({n}) según el caso.
Valida el patrón contra ejemplos válidos (+34612345678, 912345678) e inválidos (123456789, +34512345678, cadena vacía). Si algún caso no funciona como esperas, ajusta el patrón. Usa esta herramienta para probar en tiempo real.
Si el patrón debe validar toda la cadena (no buscar dentro de ella), añade ^ al inicio y $ al final: ^(\+34)?[6789]\d{8}$. Sin anchors, el patrón encontraría el teléfono aunque la cadena contuviese texto adicional alrededor.
Guarda el patrón junto a una descripción, los casos de prueba y la fuente normativa (si valida un formato oficial). En Python puedes usar re.VERBOSE para añadir comentarios dentro del propio patrón. En JavaScript, considera definirlo como constante con nombre descriptivo: const TELEFONO_ESPANOL = /^(\+34)?[6789]\d{8}$/.
Cadena vacía, un solo carácter, el valor mínimo y máximo permitido, caracteres especiales (@, -, _), unicode (tildes, ñ, emojis) y saltos de línea. El 80% de los bugs de regex aparecen en los extremos, no en los casos típicos.
Cuando solo necesitas agrupar para aplicar un cuantificador o alternación, usa (?:...) en lugar de (...). Los grupos de captura tienen un coste de memoria y hacen el código más difícil de mantener si hay muchos grupos numerados.
En Python usa el modo verbose (re.VERBOSE) para añadir comentarios y espacios dentro del patrón. En otros lenguajes, define la regex como constante con nombre descriptivo y añade un comentario explicando su propósito, formato esperado y ejemplos válidos.
Un patrón demasiado amplio como .* acepta casi cualquier cosa y da falsos positivos. Define exactamente qué caracteres son válidos, sus rangos de longitud y su estructura. Cuanto más específico sea el patrón, menos mantenimiento necesitará en el futuro.
Nunca confíes únicamente en la validación regex del frontend. Un atacante puede saltársela manipulando la petición HTTP. La regex del cliente mejora la experiencia de usuario; la del servidor protege la integridad de los datos.
Si aplicas el mismo patrón en un bucle de miles de registros, compila la regex una sola vez fuera del bucle. En Python: patrón = re.compile(r'\d+'). En JavaScript, define el literal de regex fuera de la función. Esto puede mejorar el rendimiento en factores de 10x o más.
. en regex significa “cualquier carácter”, no un punto literal. Para buscar un punto real escribe \.. El patrón 3.14 coincide con 3X14, 3014, etc. Siempre escapa los metacaracteres cuando los uses como literales.(a+)+, (\w+\s?)+ o ([a-zA-Z]+)* ante entradas largas que no coinciden pueden causar backtracking exponencial y bloquear el hilo de ejecución durante segundos o minutos. Nunca uses estos patrones en código expuesto a datos de usuarios no confiables.\d puede incluir dígitos de otros sistemas de escritura (٣, ৩, ３...). Si necesitas estrictamente 0-9, usa [0-9]. En JavaScript con flag u, el comportamiento es más predecible.^ y $, el patrón \d{5} coincide con cualquier cadena que contenga 5 dígitos consecutivos, incluyendo abc12345xyz. Para validación de formato completo, siempre añade anchors: ^\d{5}$.DOMParser en JavaScript, BeautifulSoup en Python, SimpleXML en PHP) para trabajar con documentos HTML/XML.re.match() con re.fullmatch() en Python: re.match() ancla al inicio pero no al final, por lo que re.match(r'\d{5}', '12345abc') devuelve coincidencia. Para validar la cadena completa usa re.fullmatch() o añade $ al patrón.