Busca entre las cuarenta filas por sintaxis, significado o ejemplo, o recorre la tabla entera. Las notas señalan dónde se separan JavaScript, PCRE, Python, Java, .NET, Go y Ruby.
Se ejecuta localmente en tu navegador| Sintaxis | Función | Ejemplo |
|---|---|---|
\ | Escapa un metacarácter o inicia una secuencia especial. | \. coincide con un punto literal. |
^ | Coincide con el inicio de la entrada o de una línea en modo multilínea. | ^Error |
$ | Coincide con el final de la entrada o de una línea en modo multilínea. | done$ |
i, m, s, u, x | Modificadores que se escriben tras el delimitador de cierre: i ignora mayúsculas y minúsculas, m hace que ^ y $ coincidan con los saltos de línea, s hace que . coincida también con saltos de línea, u activa el modo Unicode en JavaScript y x ignora los espacios no escapados y los comentarios con # en PCRE, Python, Java y Ruby. | /^done$/im |
. | Coincide con un carácter; excluye los saltos de línea salvo que se active el modo dot-all. | a.c |
* | Repite el token anterior cero o más veces. | ab*c |
+ | Repite el token anterior una o más veces. | ab+c |
? | Hace opcional el token anterior. | colou?r |
{n} | Repite el token anterior exactamente n veces. | \d{4} |
{n,} | Repite el token anterior al menos n veces. | \w{3,} |
{n,m} | Repite el token anterior entre n y m veces. | [A-F0-9]{2,8} |
*?, +?, ?? | Usa repetición lazy y consume la menor cantidad de entrada posible. | <.*?> |
*+, ++, ?+ | Cuantificadores posesivos: coinciden de forma greedy y nunca devuelven caracteres, así que el motor no puede retroceder dentro de ellos. Los admiten PCRE, Perl, Java y Python 3.11 o posterior; JavaScript, Go y las versiones anteriores de Python no. | \d++ |
(?>pattern) | Grupo atómico: el grupo conserva su primera coincidencia y no se vuelve a evaluar durante el backtracking. Lo admiten PCRE, .NET, Java, Perl y Python 3.11 o posterior; JavaScript no tiene grupos atómicos. | (?>a|ab)c |
[abc] | Coincide con un carácter del conjunto. | gr[ae]y |
[^abc] | Coincide con un carácter que no pertenece al conjunto. | [^0-9] |
[a-z] | Coincide con un carácter del intervalo indicado. | [A-Za-z] |
[[:alpha:]] | Clase de caracteres POSIX dentro de una expresión de corchetes; la admiten PCRE, Java, Ruby y los motores tipo grep, pero no JavaScript ni Python, donde la propiedad Unicode es la forma portable. | [[:digit:]]+ |
x|y | Coincide con la expresión de la izquierda o la de la derecha. | cat|dog |
(pattern) | Agrupa una subexpresión y captura la coincidencia. | (ab)+ |
(?:pattern) | Agrupa una subexpresión sin crear una captura. | (?:https?):// |
(?<name>pattern) | Crea un grupo de captura con nombre cuando el motor lo admite. | (?<year>\d{4}) |
(?P<name>pattern) | Forma de grupo con nombre que usan Python y el motor RE2 de Go, que no acepta referencias inversas al grupo. | (?P<year>\d{4}) |
(?'name'pattern) | Forma alternativa de grupo con nombre que usan .NET, PCRE, Perl y Ruby; Java y JavaScript solo aceptan la forma con ángulos. | (?'year'\d{4}) |
\1 | Coincide con el mismo texto capturado por el primer grupo. | \b(\w+)\s+\1\b |
\k<name> | Referencia inversa a un grupo con nombre en JavaScript, .NET, PCRE, Java y Ruby; Python escribe la forma con P=. | (?<w>\w+)\s+\k<w> |
(?=pattern) | Lookahead positivo: exige una coincidencia posterior sin consumirla. | \d+(?=px) |
(?!pattern) | Lookahead negativo: exige que el texto posterior no coincida. | foo(?!bar) |
(?<=pattern) | Lookbehind positivo: exige una coincidencia anterior sin consumirla. | (?<=\$)\d+ |
(?<!pattern) | Lookbehind negativo: exige que el texto anterior no coincida. | (?<!-)\b\d+ |
\A, \z, \Z | Anclas del inicio y del final absolutos de la cadena en PCRE, Python, Java y Ruby; allí la forma de final también permite un salto de línea final. JavaScript no tiene equivalente, así que usa ^ y $ sin el modificador m. | \A\d{4}\z |
\d / \D | Coincide con un dígito / un carácter que no es dígito. El comportamiento Unicode depende del motor. | \d+ |
\w / \W | Coincide con un carácter de palabra / que no es de palabra. El conjunto exacto depende del motor. | \w+ |
\s / \S | Coincide con espacio en blanco / un carácter que no es espacio. | \s+ |
\b / \B | Coincide con un límite de palabra / una posición que no es límite de palabra. | \bword\b |
\n, \r, \t | Coincide con salto de línea, retorno de carro o tabulación. | \r?\n |
\xNN | Coincide con un carácter mediante su unidad de código hexadecimal de dos dígitos. | \x41 coincide con A. |
\uNNNN | Coincide con un carácter mediante una unidad de código Unicode de cuatro dígitos en motores compatibles. | \u00A9 coincide con ©. |
\u{1F600}, \x{1F600} | Coincide con un punto de código superior a U+FFFF: JavaScript escribe \u{...} con el modificador u, mientras que PCRE, Perl y Java escriben \x{...} y Python escribe \U0001F600. | \u{1F600} |
\p{Letter} | Coincide con una propiedad Unicode cuando los escapes de propiedades están disponibles y activados. | \p{Letter}+ |
El motor de Go basado en RE2 omite intencionadamente lookaround y referencias inversas. JavaScript requiere el modo Unicode para muchos escapes de propiedades Unicode. PCRE, .NET, Java, Python y Ruby también difieren en sintaxis de grupos, modificadores y reglas de sustitución.
Cuando un patrón procese entradas no fiables o muy grandes, evita cuantificadores anidados ambiguos, limita el tamaño de entrada y prueba el peor caso para reducir el riesgo de backtracking excesivo.
Cuarenta construcciones en tres columnas: la sintaxis que escribes, qué hace y un ejemplo corto. Las filas cubren los escapes, anclas, cuantificadores, clases de caracteres, grupos, aserciones, modificadores y escapes Unicode que comparten JavaScript, PCRE, Python, Java, .NET, Go y Ruby, e indican qué motores rechazan cada forma avanzada.
La página no ejecuta ningún patrón: aquí no se compila ni se compara nada. La tabla viene con la página, el buscador solo oculta filas en tu navegador y lo que escribes no se envía a ningún sitio.
Escapes (\d, \w, \b, \xNN, \uNNNN, \p{Letter}), anclas (^, $, \A, \z, \Z), cuantificadores greedy, lazy y posesivos, expresiones de corchetes y clases POSIX, grupos de captura y sin captura, tres formas de grupo con nombre, referencias inversas, lookahead y lookbehind, modificadores en línea y escapes de puntos de código por encima de U+FFFF.
Los ejemplos son fragmentos, no programas completos: \d++ y (?>a|ab)c muestran la construcción en contexto, y las tres filas que terminan en frase — \. coincide con un punto literal., \x41 coincide con A., \u00A9 coincide con ©. — se leen como los escribirías al probar un patrón.
El motor RE2 de Go omite lookaround y referencias inversas; JavaScript no tiene grupos atómicos ni cuantificadores posesivos y necesita el modificador u para los escapes \u{...}; y una clase POSIX como [[:alpha:]] funciona en PCRE, Java, Ruby y motores tipo grep, pero no en JavaScript ni en Python.
Python 3.11 y posteriores admiten grupos atómicos y cuantificadores posesivos, que PCRE, Perl y Java ya tenían. Los grupos con nombre se escriben (?P<name>...) en Python y RE2 y (?'name'...) en .NET, PCRE, Perl y Ruby; la referencia inversa con nombre es \k<name> salvo en Python, que escribe (?P=name).
Es una tabla de consulta, no un probador: no compila patrones, no compara nada con tu texto y no genera código. Las pestañas de arriba cubren el resto de la familia: Regex Tester ejecuta un patrón, Regex Code Generator lo escribe para siete lenguajes y Common Regex Patterns reúne patrones ya hechos.
La tabla es HTML plano y sigue siendo legible con JavaScript desactivado; solo el filtro, el recuento y los botones de copiar necesitan el script. La búsqueda compara el texto de la página, así que una consulta como \d+ se lee como los tres caracteres que contiene, no como un patrón.