Guía rápida de expresiones regulares: todos los tokens con ejemplos
Todos los tokens de expresiones regulares con un ejemplo que funciona, su compatibilidad en JavaScript, PCRE/PHP, Python, Go, Java y .NET, y un enlace Pruébalo que abre el probador de regex ya relleno.
Última verificación: 2026-10-18, contrastado con ECMAScript 2025 (MDN), PCRE2 10.45, re de Python 3.14, regexp/syntax de Go 1.27, Pattern de Java 25 y la referencia de regex de .NET. Fuentes: MDN regular expressions, PCRE2 pattern syntax, Python re, Go regexp/syntax, Java Pattern, .NET regex quick reference.
Caracteres y escapes
La mayoría de los caracteres se encuentran a sí mismos. Estos doce tienen un significado especial y necesitan una barra invertida para encontrarlos de forma literal: \ ^ $ . | ? * + ( ) [ { (y ] } en algunas posiciones).
.Cualquier carácterCualquier carácter salvo un salto de línea. Añade el flag s (dotAll) para incluir los saltos de línea.
/h.t/g
en “hat hot h t hit h↵t”
encuentra “hat” “hot” “h t” “hit”- Python re: Solo excluye \n; JavaScript también excluye \r, \u2028 y \u2029.
- Go RE2: Solo excluye \n.
\. \$ \(Escapar un metacarácterUna barra invertida hace literal el siguiente carácter especial: \. es un punto de verdad y \$ un signo de dólar.
/\$\d+\.\d{2}/g
en “Total $45.00, tax $3.15, tip 5”
encuentra “$45.00” “$3.15”\t \n \rTabulación, salto de línea, retorno de carroCaracteres de control por nombre. Los finales de línea de Windows son \r\n; \r?\n encuentra ambos estilos.
/\w+\t\w+/g
en “name⇥age↵ana⇥31”
encuentra “name⇥age” “ana⇥31”\xhhCarácter por código hexadecimalExactamente dos dígitos hexadecimales: \x41 es A y \x20 un espacio.
/\x41/g
en “A b A”
encuentra “A” “A”\uhhhhCarácter por unidad de código UnicodeCuatro dígitos hexadecimales para un carácter del plano multilingüe básico: \u00e9 es é.
/\u00e9/g
en “café résumé”
encuentra “é” “é” “é”- PCRE / PHP: Usa \x{e9}.
- Go RE2: Usa \x{e9}.
\u{1F600}Cualquier punto de código (también de los planos suplementarios)Punto de código entre llaves, necesario para emojis y otros caracteres por encima de U+FFFF. JavaScript exige el flag u o v.
/\u{1F600}/gu
en “Hi 😀 there 😀”
encuentra “😀” “😀”- PCRE / PHP: Escribe \x{1F600} (PHP necesita el modificador u).
- Python re: Escribe \U0001F600 (ocho dígitos hexadecimales).
- Go RE2: Escribe \x{1F600}.
- Java: Escribe \x{1F600}.
- .NET: Solo \uhhhh; un emoji son dos unidades de código UTF-16, p. ej. \uD83D\uDE00.
Clases de caracteres
Una clase encuentra exactamente un carácter de un conjunto. Dentro de [ ] la mayoría de los metacaracteres pierden su significado; solo hay que tener cuidado con ] \ ^ y -.
[abc]Uno cualquiera deUn carácter de la lista.
/gr[ae]y/g
en “gray grey groy”
encuentra “gray” “grey”[^abc]Ninguno deUn carácter que no está en la lista (un ^ en cualquier posición que no sea la primera es literal). También encuentra saltos de línea.
/[^aeiou\s]/g
en “regex”
encuentra “r” “g” “x”[a-z]RangoCaracteres entre dos puntos de código. Puedes combinar rangos: [A-Fa-f0-9] es un dígito hexadecimal. Un - al principio o al final es literal.
/[A-Fa-f0-9]+/g
en “x: 3fA9 zz”
encuentra “3fA9”\d \DDígito / no dígito\d es un dígito y \D cualquier otra cosa.
/\d+/g
en “Order 66, room 101”
encuentra “66” “101”- Python re: En patrones str, \d encuentra cualquier dígito Unicode (p. ej. ٣); usa re.ASCII para limitarlo a 0-9.
- .NET: Encuentra cualquier dígito Unicode salvo que se active RegexOptions.ECMAScript.
\w \WCarácter de palabra / no de palabraLetras, dígitos y guion bajo. En JavaScript y Go solo ASCII: \w no encuentra é.
/\w+/g
en “snake_case and kebab-case”
encuentra “snake_case” “and” “kebab” “case”- PCRE / PHP: ASCII salvo con PCRE2_UCP (PHP: modificador u más (*UCP)).
- Python re: Letras y dígitos Unicode por defecto en patrones str.
- Java: ASCII salvo que esté activo el flag U (UNICODE_CHARACTER_CLASS).
- .NET: Letras, dígitos y signos de puntuación conectores Unicode.
\s \SEspacio en blanco / no espacioEspacio, tabulación, saltos de línea y (en la mayoría de los motores) otros espacios Unicode.
/\s+/g
en “a b⇥c”
encuentra “ ” “⇥”- Go RE2: Solo espacios en blanco ASCII: \t \n \f \r y el espacio.
[[:alpha:]]Clase POSIX entre corchetesClases con nombre como [:alpha:], [:digit:], [:space:] o [:punct:], usadas dentro de corchetes.
[[:alpha:]]+- JavaScript: Usa [A-Za-z] o \p{L} con el flag u.
- Java: Usa \p{Alpha}, \p{Digit}, \p{Punct}.
[\p{L}--[a-z]]Resta / intersección de clasesOperaciones de conjuntos dentro de una clase. JavaScript necesita el flag v (ES2024): -- resta y && interseca.
/[\p{L}--[a-z]]+/gv
en “abcÉtéXYZ”
encuentra “É” “éXYZ”- PCRE / PHP: Solo PCRE2 10.45+, con la sintaxis de clase extendida (?[ … ]).
- Java: Intersección [a-z&&[^aeiou]]; la resta se escribe como intersección con una negación.
- .NET: Resta [a-z-[aeiou]]; sin intersección.
Anclas y límites
Las anclas encuentran una posición, no un carácter, así que nunca consumen texto.
^ $Inicio / fin de cadena (o de línea con m)Sin el flag m, ^ y $ son el inicio y el fin de toda la entrada; con él, de cada línea.
/^\w+/gm
en “first line↵second line”
encuentra “first” “second”- PCRE / PHP: $ también coincide antes de un \n final.
- Python re: $ también coincide antes de un \n final.
- Java: $ también coincide antes de un terminador de línea final.
- .NET: $ también coincide antes de un \n final.
\bLímite de palabraEntre un carácter de palabra y uno que no lo es (o el borde de la entrada). Úsalo para encontrar palabras completas.
/\bcat\b/g
en “cat concat cats cat.”
encuentra “cat” “cat”- JavaScript: Solo caracteres de palabra ASCII, incluso con el flag u.
- Go RE2: Solo caracteres de palabra ASCII.
\BNo límite de palabraDentro de una palabra, p. ej. "cat" solo cuando forma parte de una palabra más larga.
/\Bcat/g
en “concat cat bobcat”
encuentra “cat” “cat”\A \z \ZInicio / fin absolutosInicio y fin de la entrada sea cual sea el modo multilínea. \Z también admite un salto de línea final (excepto en Python, donde es sinónimo de \z).
\A\d+\z- JavaScript: Usa ^ y $ sin el flag m.
- Python re: \A y \z (3.14+); \Z significa fin absoluto, como \z en otros motores.
- Go RE2: \A y \z; sin \Z.
\GFin de la coincidencia anteriorPosición donde terminó la última coincidencia; sirve para encontrar tramos contiguos.
\G\d- JavaScript: No hay \G; el flag y (sticky) da el mismo comportamiento de "empezar justo aquí".
Cuantificadores: codiciosos, perezosos, posesivos
Un cuantificador repite el elemento anterior. El codicioso (por defecto) toma todo lo que puede y luego retrocede; el perezoso (añade ?) toma lo mínimo posible; el posesivo (añade +) nunca retrocede.
*Cero o másRepite de 0 a infinitas veces.
/ba*/g
en “b ba baaa”
encuentra “b” “ba” “baaa”+Uno o másRepite de 1 a infinitas veces.
/lo+l/g
en “lol loool ll”
encuentra “lol” “loool”?OpcionalCero o una vez.
/colou?r/g
en “color colour colouur”
encuentra “color” “colour”{n}Exactamente nExactamente n repeticiones.
/\d{3}/g
en “12 345 6789”
encuentra “345” “678”{n,}n o másAl menos n repeticiones.
/\d{2,}/g
en “1 22 333”
encuentra “22” “333”{n,m}Entre n y mDe n a m repeticiones, tantas como sea posible.
/\d{2,3}/g
en “1 22 4444”
encuentra “22” “444”- Go RE2: Rechaza los recuentos superiores a 1000.
{,m}Hasta mDe cero a m repeticiones. Solo algunos motores lo aceptan; en el resto es el literal "{,m}" o un error. {0,m} funciona en todas partes.
\d{,3}- JavaScript: Texto literal sin u, error de sintaxis con u; escribe {0,3}.
- PCRE / PHP: Solo PCRE2 10.43+.
- Go RE2: Escribe {0,3}.
- Java: Escribe {0,3}.
- .NET: Se trata como texto literal; escribe {0,3}.
.* .+Codicioso (por defecto)Toma la coincidencia más larga posible y luego devuelve caracteres hasta que encaja el resto. Aquí se traga las dos etiquetas.
/<.+>/g
en “<b>bold</b>”
encuentra “<b>bold</b>”*? +? ?? {n,m}?Perezoso (no codicioso)Toma la coincidencia más corta posible. Suele ser la solución cuando un patrón "encuentra demasiado".
/<.+?>/g
en “<b>bold</b>”
encuentra “<b>” “</b>”- Go RE2: También disponible como flag U, que intercambia codicioso y perezoso.
*+ ++ ?+PosesivoCodicioso sin backtracking: una vez encontrados, los caracteres nunca se devuelven. Falla antes y protege contra el backtracking catastrófico.
"[^"]*+"- JavaScript: No hay cuantificadores posesivos ni grupos atómicos; emúlalos con (?=(…))\1.
- Python re: Python 3.11+.
- Go RE2: No hace falta: RE2 nunca hace backtracking.
- .NET: Usa un grupo atómico (?>…).
Grupos y referencias inversas
Los paréntesis agrupan elementos para los cuantificadores y la alternancia y (salvo que se marquen como no capturadores) guardan lo que encontraron.
( … )Grupo de capturaAgrupa y captura; se numeran desde 1 según el paréntesis de apertura.
/(\d{3})-(\d{4})/g
en “Call 555-0199 or 555-0123”
encuentra “555-0199” “555-0123”(?: … )Grupo no capturadorAgrupa sin guardar, así que los números de grupo no cambian y la búsqueda es algo más ligera.
/(?:ab)+/g
en “ababab ab a”
encuentra “ababab” “ab”(?<name> … )Grupo con nombreCaptura con un nombre que puedes leer después (match.groups.name en JavaScript).
/(?<year>\d{4})-(?<month>\d{2})/g
en “Released 2026-10”
encuentra “2026-10”- PCRE / PHP: También (?'name'…) y (?P<name>…).
- Python re: Solo (?P<name>…).
- Go RE2: (?P<name>…); (?<name>…) también se acepta desde Go 1.22.
- .NET: También (?'name'…).
\1Referencia inversa por númeroEncuentra el mismo texto que capturó antes un grupo.
/(\w)\1/g
en “bookkeeper”
encuentra “oo” “kk” “ee”- Go RE2: RE2 no tiene referencias inversas (romperían su garantía de tiempo lineal).
\k<name>Referencia inversa por nombreIgual que \1, pero por nombre. El ejemplo encuentra texto entre comillas del mismo tipo.
/(?<q>['"]).*?\k<q>/g
en “say "hi" or 'yo'”
encuentra “"hi"” “'yo'”- PCRE / PHP: También \k{name}, \g{name} y (?P=name).
- Python re: Escribe (?P=name).
a|bAlternancia (o)Uno u otro lado. Las alternativas se prueban de izquierda a derecha, así que pon primero las más largas cuando una sea prefijo de otra.
/cat|dog/g
en “hotdog catalog”
encuentra “dog” “cat”(?> … )Grupo atómicoUna vez que el grupo ha coincidido, el motor no vuelve a entrar en él haciendo backtracking.
(?>a|ab)c- Python re: Python 3.11+.
- Go RE2: No hace falta: RE2 nunca hace backtracking.
(?i) (?i: … )Flags en líneaActiva o desactiva flags dentro del patrón. (?i) se aplica al resto del patrón; (?i:…) solo al grupo; (?-i:…) desactiva un flag.
/(?i:hello) world/g
en “HELLO world HELLO WORLD”
encuentra “HELLO world”- JavaScript: Solo la forma acotada (?i:…) / (?-i:…), para i, m y s (ES2025). (?i) al principio es un error de sintaxis.
- Python re: El (?i) global debe ir al principio del patrón (en otro sitio es un error desde 3.11); (?i:…) funciona en cualquier parte.
(?(1)yes|no)CondicionalEncuentra "yes" si el grupo 1 participó y, si no, "no".
(<)?\w+(?(1)>)(?R) (?1)Recursión / subrutinaVuelve a entrar en el patrón completo o en un grupo, para estructuras anidadas como paréntesis equilibrados.
\((?:[^()]|(?R))*\)- Python re: Disponible en el módulo de terceros regex.
- .NET: Sin recursión; los grupos de equilibrio (?<open-close>…) manejan el anidamiento.
(?# … )Comentario en líneaEl motor lo ignora. Para comentarios más largos usa el flag x (extendido).
\d{3}(?#area code)Lookahead y lookbehind
Los lookarounds comprueban lo que hay junto a la posición actual sin incluirlo en la coincidencia. Tienen ancho cero, como las anclas.
(?= … )Lookahead positivoSeguido de … (no se incluye en la coincidencia).
/\d+(?=px)/g
en “10px 20em 30px”
encuentra “10” “30”- Go RE2: RE2 no tiene ningún tipo de lookaround.
(?! … )Lookahead negativoNo seguido de …. El \d de dentro impide que el motor devuelva dígitos para que la comprobación se cumpla.
/\d+(?!px|\d)/g
en “10px 20em”
encuentra “20”(?<= … )Lookbehind positivoPrecedido de … (no se incluye en la coincidencia).
/(?<=\$)\d+(?:\.\d\d)?/g
en “Cost: $42.50 or 42”
encuentra “42.50”- JavaScript: Cualquier longitud (ES2018).
- PCRE / PHP: Cada alternativa debe tener una longitud acotada; longitud variable (máx. 255 por defecto) desde PCRE2 10.43.
- Python re: Solo ancho fijo: (?<=ab|cd) vale, (?<=a+) es un error.
- Java: Solo longitud acotada: nada de * o + dentro.
- .NET: Cualquier longitud.
(?<! … )Lookbehind negativoNo precedido de ….
/(?<!\$)\b\d+\b/g
en “$30 and 45”
encuentra “45”- PCRE / PHP: Mismas reglas de longitud que el lookbehind positivo.
- Python re: Solo ancho fijo.
- Java: Solo longitud acotada.
\KReiniciar el inicio de la coincidenciaQuita del resultado todo lo encontrado hasta ese punto; un lookbehind sin límites de longitud.
price: \K\d+- JavaScript: Usa (?<=…) o un grupo de captura.
Flags (modificadores)
JavaScript escribe los flags tras la barra de cierre (/x/gi). Otros lenguajes pasan constantes (re.I, Pattern.CASE_INSENSITIVE, RegexOptions.IgnoreCase) o usan (?i) en línea.
gGlobal (todas las coincidencias)Encuentra todas las coincidencias en lugar de detenerse en la primera. Lo exigen matchAll y replaceAll.
/o/g
en “foo boo”
encuentra “o” “o” “o” “o”- PCRE / PHP: Sin flag: usa preg_match_all() / preg_replace().
- Python re: Sin flag: usa re.findall(), re.finditer(), re.sub().
- Go RE2: Sin flag: usa los métodos FindAll….
- Java: Sin flag: recorre con matcher.find() en un bucle.
- .NET: Sin flag: usa Regex.Matches().
iIgnorar mayúsculasBúsqueda sin distinguir mayúsculas y minúsculas.
/hello/gi
en “Hello HELLO hello”
encuentra “Hello” “HELLO” “hello”- Python re: re.I / re.IGNORECASE o (?i).
- Java: CASE_INSENSITIVE (ASCII salvo con UNICODE_CASE) o (?i).
- .NET: RegexOptions.IgnoreCase o (?i).
mMultilínea^ y $ coinciden al principio y al final de cada línea, no solo en los extremos de la entrada.
/^-\s.+$/gm
en “- one↵- two↵three”
encuentra “- one” “- two”- Python re: re.M / re.MULTILINE.
- .NET: RegexOptions.Multiline.
sEl punto incluye saltos de líneaHace que . también encuentre saltos de línea. Sin él, [\s\S] es el "cualquier cosa" portable.
/<p>.*?</p>/gs
en “<p>a↵b</p>”
encuentra “<p>a↵b</p>”- Python re: re.S / re.DOTALL.
- Java: Pattern.DOTALL.
- .NET: Se llama RegexOptions.Singleline.
xExtendido (espaciado libre)Se ignoran los espacios del patrón y # inicia un comentario, así que los patrones largos pueden repartirse en varias líneas.
(?x) \d{3} - \d{4} # local number- Python re: re.X / re.VERBOSE.
- Java: Pattern.COMMENTS.
- .NET: RegexOptions.IgnorePatternWhitespace.
uUnicodeTrata la entrada como puntos de código (así . encuentra un emoji entero), activa \p{…} y \u{…}, y convierte los escapes no válidos en errores.
/^.$/gu
en “😀”
encuentra “😀”- PCRE / PHP: Modificador u de PHP (modo UTF-8); añade (*UCP) para \w y \d Unicode.
- Python re: No hace falta flag: los patrones str son Unicode; re.ASCII lo desactiva.
- Go RE2: Sin flag: Go siempre trabaja con puntos de código UTF-8.
- Java: UNICODE_CASE y UNICODE_CHARACTER_CLASS (U).
- .NET: Sin flag: siempre unidades de código UTF-16 (un emoji son dos).
vConjuntos UnicodeMejora de u en ES2024: operaciones de conjuntos en clases (--, &&), clases anidadas y propiedades de cadena como \p{RGI_Emoji}. No se puede combinar con u.
/[\p{L}&&\p{ASCII}]+/gv
en “Ünïcode text”
encuentra “n” “code” “text”ySticky (anclado)Cada coincidencia debe empezar justo donde terminó la anterior (lastIndex). Útil para tokenizadores.
/\d/gy
en “12a3”
encuentra “1” “2”- PCRE / PHP: Usa \G.
- Python re: Usa pattern.match(text, pos).
- Java: Usa \G o matcher.lookingAt().
- .NET: Usa \G.
dÍndices de coincidenciaAñade match.indices con el inicio y el fin de cada grupo de captura (ES2022).
/(?<y>\d{4})/d- PCRE / PHP: Las posiciones siempre están disponibles (PREG_OFFSET_CAPTURE).
- Python re: Siempre disponible: m.span(n).
- Go RE2: Siempre disponible: FindStringSubmatchIndex.
- Java: Siempre disponible: matcher.start(n) / end(n).
- .NET: Siempre disponible: Group.Index / Length.
Propiedades Unicode \p{…}
Los escapes de propiedad encuentran caracteres por categoría o escritura Unicode, la única forma fiable de encontrar "cualquier letra" en cualquier idioma. En JavaScript necesitan el flag u o v.
\p{L}Cualquier letraLetras de cualquier escritura: é, ß, 東, д.
/\p{L}+/gu
en “naïve café 東京 123”
encuentra “naïve” “café” “東京”- PCRE / PHP: PHP necesita el modificador u para entradas UTF-8.
- Python re: Usa el módulo de terceros regex, o [^\W\d_] para "letras".
\p{Lu} \p{Ll}Letra mayúscula / minúsculaCategorías generales: Lu mayúscula, Ll minúscula, N número, P puntuación, S símbolo, Z separador.
/\p{Lu}/gu
en “Élan Vital”
encuentra “É” “V”\P{…}Fuera de la propiedadLa P mayúscula niega: \P{L} es todo lo que no sea una letra.
/\P{L}+/gu
en “abc-123”
encuentra “-123”\pLForma abreviada de una letraCategorías de una sola letra sin llaves.
\pL+- JavaScript: Las llaves son obligatorias: \p{L}.
- .NET: Las llaves son obligatorias: \p{L}.
\p{Script=Greek}EscrituraCaracteres de un sistema de escritura. sc= es la forma corta; Script_Extensions (scx=) incluye también caracteres compartidos entre escrituras.
/\p{Script=Greek}+/gu
en “alpha α, beta β”
encuentra “α” “β”- PCRE / PHP: \p{Greek}, \p{sc:Greek} o \p{scx:Greek}.
- Go RE2: \p{Greek}.
- Java: Escribe \p{script=Greek}, \p{sc=Greek} o \p{IsGreek}.
- .NET: Solo bloques con nombre como \p{IsGreek} (un rango de códigos, no la escritura).
\p{sc=Han}Hanzi / kanji chinos y japonesesIdeogramas han. Para el kana japonés añade \p{sc=Hiragana} y \p{sc=Katakana}.
/\p{sc=Han}+/gu
en “Tokyo 東京 2026 中文”
encuentra “東京” “中文”- PCRE / PHP: \p{Han}.
- Python re: Usa un rango como [\u4e00-\u9fff] (solo cubre el bloque principal).
- Go RE2: \p{Han}.
- Java: También \p{IsHan}.
- .NET: Solo bloques, p. ej. \p{IsCJKUnifiedIdeographs}.
\p{RGI_Emoji}Emojis (secuencias completas)Con el flag v encuentra emojis completos, incluidos tonos de piel y secuencias de familia. Con u, \p{Extended_Pictographic} solo encuentra pictogramas sueltos.
/\p{RGI_Emoji}/gv
en “Go 👍🏽 team 👨👩👧!”
encuentra “👍🏽” “👨👩👧”- PCRE / PHP: Puntos de código sueltos mediante propiedades booleanas en PCRE2 reciente (10.40+); no hay propiedad de secuencias.
- Java: \p{IsEmoji} encuentra puntos de código sueltos (Java 21+).
\XClúster de grafemasUn carácter tal como lo percibe el usuario, p. ej. e + acento combinable, o un emoji de bandera.
\X- JavaScript: Usa Intl.Segmenter para dividir en grafemas.
- Python re: Disponible en el módulo regex.
Sintaxis de sustitución (reemplazo)
Qué escribir en la cadena de reemplazo. Aquí es donde más difieren los lenguajes, así que importa más la columna de tu lenguaje que el ejemplo de JavaScript.
$&Coincidencia completaInserta todo el texto encontrado.
/\d+/g
en “3 apples, 12 pears”
reemplazar por “[$&]” → “[3] apples, [12] pears”- PCRE / PHP: $0 o \0 en preg_replace.
- Python re: \g<0>.
- Go RE2: ${0} o $0 (Expand / ReplaceAllString).
- Java: $0.
- .NET: También $0.
$1Grupo numeradoInserta lo que capturó el grupo 1. Intercambiar dos palabras:
/(\w+)\s(\w+)/g
en “hello world”
reemplazar por “$2 $1” → “world hello”- PCRE / PHP: También \1 y ${1}.
- Python re: \1 o \g<1> (usa una cadena raw r"\1").
- Go RE2: Usa ${1}x cuando le sigue una letra o un dígito; si no, Go lee $1x como un grupo llamado "1x".
$<name>Grupo con nombreInserta un grupo con nombre. Reformatear una fecha ISO como día/mes/año:
/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/g
en “2026-10-18”
reemplazar por “$<d>/$<m>/$<y>” → “18/10/2026”- PCRE / PHP: preg_replace no tiene referencias por nombre; usa el número del grupo o preg_replace_callback().
- Python re: \g<name>.
- Go RE2: ${name} (o $name).
- Java: ${name}.
- .NET: ${name}.
$$Signo de dólar literalEscapa $ en el reemplazo.
/(\d+)/g
en “Price: 20”
reemplazar por “$$$1” → “Price: $20”- PCRE / PHP: Un $ que no va seguido de un dígito o { ya es literal; escribe ${1} después de él.
- Python re: $ no es especial; escapa las barras invertidas como \\.
- Java: \$ (Matcher.quoteReplacement() escapa una cadena entera).
$` $'Texto antes / después de la coincidenciaInserta la parte de la entrada anterior o posterior a la coincidencia. Rara vez hace falta, pero a veces viene bien.
/=/
en “key=value”
reemplazar por “ is set ($') and was ($`) ” → “key is set (value) and was (key) value”Recetas habituales (con salvedades sinceras)
Los patrones más buscados, escritos para que sean legibles y no sufran backtracking catastrófico. Cada uno indica lo que no hace.
Email (practical)Encontrar cadenas con forma de emailParte local, @ y un dominio con al menos un punto.
/[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g
en “Write to ana.lee+news@example.co.uk or bob@test.dev.”
encuentra “ana.lee+news@example.co.uk” “bob@test.dev”Salvedad: Rechaza direcciones válidas pero poco comunes (partes locales entre comillas, dominios no ASCII) y acepta algunas no válidas (a..b@x.y). Ninguna regex puede decirte si un buzón existe: envía un email de confirmación.
URLEncontrar enlaces http(s) en un textoSe detiene en espacios, comillas y corchetes angulares, y descarta la puntuación final, como un punto o una coma.
/https?://[^\s<>"]*[^\s<>".,;:!?)]/g
en “See https://example.com/a?b=1, or (http://test.dev/x).”
encuentra “https://example.com/a?b=1” “http://test.dev/x”Salvedad: Sirve para convertir texto en enlaces, no para validar. Para comprobar una URL, usa el analizador de URL de tu lenguaje (new URL() en JavaScript) y revisa su protocolo y host.
IPv4 addressCuatro octetos 0–255Cada octeto limitado a 0–255 sin ceros a la izquierda.
/\b(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}\b/g
en “10.0.0.1 256.1.1.1 192.168.1.254”
encuentra “10.0.0.1” “192.168.1.254”Salvedad: No contempla IPv6, sufijos CIDR ni puertos. Para validar, usa un analizador de IP (ipaddress de Python, net/netip de Go, net.isIP de Node).
Date YYYY-MM-DDFecha de calendario ISO 8601Mes 01–12 y día 01–31.
/\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b/g
en “2026-10-18, 2026-13-01, 2026-02-31”
encuentra “2026-10-18” “2026-02-31”Salvedad: Solo la forma: 2026-02-31 pasa. Analiza la fecha con una librería de fechas para rechazar días imposibles.
Date MM/DD/YYYYFecha al estilo de EE. UU.Mes y día de uno o dos dígitos, año de cuatro dígitos.
/\b(?:0?[1-9]|1[0-2])/(?:0?[1-9]|[12]\d|3[01])/\d{4}\b/g
en “Due 10/18/2026 or 1/5/2027, not 13/01/2026”
encuentra “10/18/2026” “1/5/2027”Salvedad: 01/02/2026 es el 2 de enero en EE. UU. y el 1 de febrero casi en todo el resto del mundo; una regex no puede saber cuál se quería decir.
Phone (North America)(416) 555-0199 y variantesDiez dígitos con paréntesis, espacios, puntos o guiones opcionales.
/\(?\b\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g
en “(416) 555-0199, 416.555.0199, 4165550199”
encuentra “(416) 555-0199” “416.555.0199” “4165550199”Salvedad: Solo números de Norteamérica. Para números internacionales usa una librería como libphonenumber; guarda los números en formato E.164 (siguiente fila).
Phone (E.164)Formato internacional +CC…Un signo más, un código de país que no empieza por 0 y hasta 15 dígitos en total.
/^\+[1-9]\d{1,14}$/gm
en “+14165550199↵+447911123456↵0044791112”
encuentra “+14165550199” “+447911123456”Salvedad: Comprueba la forma E.164, no si el número está asignado ni si tiene la longitud correcta para su país.
Hex colour#rgb, #rgba, #rrggbb, #rrggbbaaLas cuatro longitudes que acepta CSS.
/#(?:[\da-fA-F]{8}|[\da-fA-F]{6}|[\da-fA-F]{3,4})\b/g
en “#fff #244b3f #12345 #ff000080 #1234567”
encuentra “#fff” “#244b3f” “#ff000080”Salvedad: También coincide dentro de textos más largos, como URL con #fragmentos; ánclalo con ^…$ para validar un único valor.
URL slugpalabras-en-minusculas-con-guionesLetras minúsculas y dígitos separados por guiones simples.
/^[a-z0-9]+(?:-[a-z0-9]+)*$/gm
en “my-post-2026↵My Post↵-bad-↵good”
encuentra “my-post-2026” “good”Salvedad: Solo ASCII. Para crear slugs a partir de títulos, usa el generador de slugs de URL en lugar de una regex.
Trim whitespaceEspacios al principio y al finalReemplaza por una cadena vacía. Sin el flag m, ^ y $ son los extremos de todo el texto.
/^\s+|\s+$/g
en “ padded text ”
reemplazar por “” → “padded text”Salvedad: Todos los lenguajes modernos tienen un trim() integrado más rápido y claro; usa la regex solo donde no puedas llamar a código (editores, archivos de configuración).
Collapse spacesVarios espacios en unoReemplaza dos o más espacios o tabulaciones por un solo espacio.
/[ \t]{2,}/g
en “too many ⇥ spaces”
reemplazar por “ ” → “too many spaces”Duplicate wordsthe the, is isUna palabra seguida de sí misma. Con i también detecta "The the".
/\b(\w+)\s+\1\b/gi
en “This is is a test test of The the editor”
encuentra “is is” “test test” “The the”Salvedad: Necesita referencias inversas, así que no funciona en Go. En inglés, "had had" y "that that" a veces son correctos.
Password rulesMinúscula, mayúscula, dígito, 12+ caracteresCada lookahead comprueba una regla desde el inicio; .{12,} fija la longitud.
/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{12,}$/gm
en “short1A↵alllowercase123↵GoodPassword42”
encuentra “GoodPassword42”Salvedad: NIST SP 800-63B desaconseja las reglas de composición: exige longitud y comprueba la contraseña contra listas de contraseñas filtradas.
UUID8-4-4-4-12 hexadecimalVersiones 1–8 con los bits de variante de RFC 9562.
/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi
en “id 3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b and 00000000-0000-0000-0000-000000000000”
encuentra “3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b”Salvedad: Rechaza el UUID nil (todo ceros) y el UUID max (todo f), que son valores especiales válidos.
Una referencia estática: la búsqueda y el filtrado se hacen en tu navegador, y los enlaces Pruébalo abren nuestro probador de regex, que funciona en el navegador. Ver todas las herramientas gratis.
¿Encontraste un problema o algo que podría mejorar? Leemos todos los mensajes y lo arreglamos rápido.
Esta guía rápida de regex recoge todos los tokens de expresiones regulares que probablemente vayas a necesitar, desde \d y \b hasta lookbehind, cuantificadores posesivos y \p{Script=Greek}, cada uno con una explicación breve y un ejemplo que muestra exactamente qué encuentra. Cada ejemplo tiene un enlace Pruébalo que abre nuestro probador de regex con el patrón, los flags y el texto de ejemplo ya rellenos, para que lo cambies y veas cómo se mueven las coincidencias.
Las regex parecen iguales en todas partes, pero no lo son. El lookbehind no tiene límite en JavaScript y .NET, es de ancho fijo en Python, acotado en Java y PCRE, y no existe en Go. Python escribe los grupos con nombre como (?P<name>…), PHP no puede usar nombres en un reemplazo y solo algunos motores conocen \A, \K o (?R). El selector de dialecto muestra la compatibilidad de cada token en JavaScript, PCRE/PHP, Python, Go, Java y .NET, con la sintaxis alternativa cuando existe. Los ejemplos en sí se ejecutan en JavaScript; para los demás lenguajes, lee las notas y prueba en ese lenguaje antes de publicar.
Cómo usarla
- Busca un token (\b, lookahead) o una tarea (email, trim, duplicate words), o salta a una sección desde los chips de arriba.
- Elige tu lenguaje en la barra de dialectos. Los tokens que no admite aparecen atenuados, y la nota bajo cada entrada indica la sintaxis que usa tu lenguaje en su lugar.
- Haz clic en Pruébalo en el probador de regex para ejecutar el ejemplo en vivo y luego edita allí el patrón o el texto.
- Usa el # junto a una entrada para enlazar directamente a ella, o Imprimir / Guardar como PDF para obtener una copia compacta a dos columnas.
Preguntas frecuentes
¿Qué diferencia hay entre cuantificadores codiciosos y perezosos?
Un cuantificador codicioso (*, +, {n,m}) toma tantos caracteres como puede y luego devuelve algunos si el resto del patrón falla; uno perezoso (*?, +?, {n,m}?) toma los menos posibles. En <b>bold</b>, <.+> encuentra toda la cadena, mientras que <.+?> encuentra <b> y </b> por separado. Los cuantificadores posesivos (*+, ++) son codiciosos y nunca devuelven caracteres; JavaScript, Go y .NET no los tienen.
¿Qué lenguajes admiten lookbehind?
JavaScript (desde ES2018) y .NET permiten lookbehind de cualquier longitud. Java exige una longitud máxima acotada, así que nada de * o + dentro. El módulo re de Python solo acepta lookbehind de ancho fijo. PCRE2 exigía que cada alternativa tuviera una longitud fija hasta la versión 10.43, que añadió lookbehind de longitud variable hasta un límite (255 caracteres por defecto). El motor RE2 de Go no tiene ni lookahead ni lookbehind.
¿Cómo encuentro cualquier letra, incluidas las acentuadas y las no latinas?
Usa la propiedad Unicode \p{L}. En JavaScript necesita el flag u o v (/\p{L}+/u); PCRE, Go, Java y .NET la admiten directamente. [a-zA-Z] se salta é, ß y cualquier escritura no latina, y \w solo cubre ASCII en JavaScript y Go. El re integrado de Python no tiene \p{…}; usa el módulo de terceros regex, o [^\W\d_], que en Python 3 encuentra letras Unicode.
¿Cómo uso un grupo capturado en el reemplazo?
Depende del lenguaje: $1 en JavaScript, Java, .NET, Go y PHP; \1 o \g<1> en Python. Los grupos con nombre son $<name> en JavaScript, ${name} en Java, .NET y Go, y \g<name> en Python; preg_replace de PHP no tiene forma con nombre, así que usa el número. La coincidencia completa es $& en JavaScript y .NET, $0 en Java y PHP, y \g<0> en Python.
¿Por qué mi regex funciona en JavaScript pero no en Python (o al revés)?
Los culpables habituales: los grupos con nombre ((?<name>) en JavaScript, (?P<name>) en Python), las propiedades \p{…} (JavaScript sí, re de Python no), la longitud del lookbehind (cualquiera en JavaScript, fija en Python), los flags en línea ((?i) al principio funciona en Python, pero es un error en JavaScript, que solo tiene la forma acotada (?i:…)), y que \d o \w encuentran dígitos y letras Unicode en Python pero solo ASCII en JavaScript. Recuerda también el escape de cadenas en Python: escribe los patrones como cadenas raw, r"\d+".
¿Es seguro validar direcciones de email con una regex?
Solo como comprobación de forma. Un patrón práctico como [\w.+-]+@[\w-]+(?:\.[\w-]+)+ detecta erratas, pero rechaza algunas direcciones válidas (partes locales entre comillas, dominios internacionalizados) y acepta algunas no válidas. Ningún patrón puede decirte que un buzón existe, así que comprueba la forma de manera laxa y después envía un email de confirmación.
Escribir patrones que funcionen en más de un lenguaje
Si un patrón tiene que ejecutarse en varios motores (una regla de validación compartida, un archivo de configuración que leen servicios en distintos lenguajes), quédate dentro del subconjunto común. Esto se comporta igual en los seis motores de esta página:
• Caracteres literales, escapes como \. y \$, y las clases [abc], [^abc] y [a-z].
• \d, \s y \w, siempre que tu entrada sea ASCII (Python y .NET también encuentran dígitos y letras Unicode).
• ^ y $, \b, la alternancia y los grupos de captura y sin captura.
• Cuantificadores codiciosos y perezosos: *, +, ?, {n}, {n,m} y sus formas con ?.
Deja fuera el lookaround (Go no tiene), las referencias inversas (Go), los cuantificadores posesivos y los grupos atómicos (a JavaScript, Go y .NET les falta uno de ellos o ambos), los grupos con nombre (la sintaxis de Python es distinta) y \p{…} (el re de Python no lo tiene). Cuando necesites alguno, mantén una copia del patrón por lenguaje y prueba cada una.
Cómo evitar el backtracking catastrófico
Los motores con backtracking (JavaScript, PCRE, Python, Java, .NET) pueden tardar un tiempo exponencial con patrones en los que un grupo cuantificado puede encontrar el mismo texto de muchas formas, como (a+)+$ o (\w|\d)*x. Con una entrada larga que casi coincide, el motor prueba todas las divisiones antes de fallar, y un servidor web puede quedarse colgado con una sola petición. Es el problema de la denegación de servicio por expresiones regulares (ReDoS).
Las soluciones son mecánicas: evita anidar cuantificadores sobre los mismos caracteres; haz que las alternativas sean mutuamente excluyentes; usa una clase negada como [^"]* en lugar de .*? cuando conozcas el delimitador; usa cuantificadores posesivos o grupos atómicos donde tu motor los tenga, y limita la longitud de la entrada antes de buscar. .NET también ofrece RegexOptions.NonBacktracking y un tiempo de espera para la búsqueda, PCRE tiene límites de búsqueda configurables y el motor RE2 de Go garantiza tiempo lineal al no admitir las funciones que requieren backtracking.
Escapar regex dentro de cadenas
La mayoría de los errores de regex en código real son errores de escape de cadenas, no de regex. La barra invertida es especial tanto para el literal de cadena del lenguaje como para el motor de regex, así que un patrón escrito como cadena normal necesita barras invertidas dobles.
• JavaScript: un literal /\d+/ necesita una barra invertida; new RegExp("\\d+") necesita dos. String.raw`\d+` evita duplicarlas.
• Python: usa siempre cadenas raw, r"\d+"; si no, "\b" es un carácter de retroceso, no un límite de palabra.
• Java y C#: "\\d+" en cadenas normales (los bloques de texto de Java también procesan escapes); las cadenas literales textuales de C#, @"\d+", mantienen las barras invertidas tal cual.
• Go: las cadenas raw entre acentos graves, `\d+`, son lo habitual con regexp.MustCompile.
• PHP: los patrones incluyen delimitadores, '/\d+/', y las cadenas entre comillas simples mantienen tal cual la mayoría de las barras invertidas.
Herramientas gratis relacionadas
- Probador de regex — Prueba una expresión regular con un texto de ejemplo, con resaltado de coincidencias en vivo, grupos de captura y vista previa de reemplazo. Gratis, en tu navegador.
- Guía rápida de Git — Comandos de Git organizados según lo que quieres hacer: deshacer el último commit, renombrar una rama, eliminar una rama remota. Los comandos modernos switch/restore con sus equivalentes clásicos y avisos de peligro.
- Guía rápida de Markdown — Todos los elementos de Markdown con su código y su vista previa, la sintaxis extendida (tablas, listas de tareas, notas al pie, fórmulas matemáticas, Mermaid, alertas), una tabla de compatibilidad con 9 plataformas y un editor de prueba en vivo.
- Generador de expresiones cron — Crea una programación cron con menús desplegables o pega una, léela en lenguaje claro y ve las 10 próximas ejecuciones en tu zona horaria y en UTC. Gratis, en tu navegador.
- Comparador de textos — Compara dos versiones de un texto, código o archivo JSON y ve exactamente qué líneas, palabras y caracteres cambiaron.