Cheatsheet Regex

abc         # coincide con "abc"
123         # coincide con "123"
Hola Mundo  # coincide con "Hola Mundo"

# La coincidencia es secuencial:
# "abc" se encuentra en "xabcx" en la posición 1

Los caracteres literales coinciden exactamente con el texto. La búsqueda es secuencial y sensible a mayúsculas por defecto. Sin metacaracteres, cada letra es un token individual.

# Metacaracteres (tienen significado especial):
. \ + * ? [ ] ( ) { } ^ $ | /

# Para usar como literal, escapar:
\.  \+  \*  \?  \[  \]  \(  \)
\{  \}  \^  \$  \|  \/  \\

# Dentro de [...], solo ] \ ^ - necesitan escape

Estos caracteres controlan la lógica del patrón. ^ y $ son anclas, * y + cuantificadores. Dentro de [...], la mayoría pierde el significado especial. Usa \Q...\E para escapar bloques enteros.

.          # cualquier carácter (excepto \n)
a.c        # "abc", "a1c", "a c", "a-c"
...        # cualquier secuencia de 3 chars
a.c.e      # "abcde", "a1c2e"

# Con flag s (dotall):
# . también coincide con \n

El . es el comodín universal — coincide con cualquier carácter excepto salto de línea. Con la flag s (dotall), incluye también \n. Úsalo con moderación para evitar coincidencias no deseadas.

\p{L}      # cualquier letra (Unicode)
\p{Lu}     # letra mayúscula
\p{Ll}     # letra minúscula
\p{N}      # cualquier número
\p{P}      # puntuación
\p{Sc}     # símbolo de moneda (€, $, £)

\P{L}      # NO letra (negado)

# Ejemplo: nombre con acentos
^[\p{L}\s]+$

\p{...} accede a propiedades Unicode. \p{L} incluye letras acentuadas (á, ã, ç). \P (mayúscula) niega la propiedad. Esencial para texto con acentos. Requiere la flag u en la mayoría de los lenguajes.

\d    # dígito [0-9]
\D    # NO dígito (equivalente a [^\d])
\w    # palabra [a-zA-Z0-9_]
\W    # NO palabra
\s    # espacio en blanco (espacio, tab, \n, \r)
\S    # NO espacio en blanco

Atajos para conjuntos comunes. \d equivale a [0-9], \w a [a-zA-Z0-9_]. La versión en mayúscula es siempre la negación. Prefiere estos atajos a las clases manuales por legibilidad.

\t     # tab
\n     # salto de línea (LF)
\r     # retorno de carro (CR)
\0     # carácter nulo

# Escapar metacaracteres:
\.     # punto literal
\\     # barra invertida literal
\(     # paréntesis literal
\[     # corchete literal

La barra invertida \ escapa metacaracteres para volverlos literales. \t, \n y \r son caracteres de control. Siempre que necesites un ., * o ? literal, escápalo con \.

*       # 0 o más veces
+       # 1 o más veces
?       # 0 o 1 (opcional)

a*      # "", "a", "aa", "aaa"
a+      # "a", "aa" (no coincide con "")
colou?r # "color" o "colour"
https?  # "http" o "https"

* acepta cero ocurrencias, + exige al menos una. ? hace el elemento opcional. Son los cuantificadores más usados. Aplícalos a caracteres, clases o grupos.

# Cuantificadores posesivos (Java, PCRE):
*+    # 0 o más, sin backtrack
++    # 1 o más, sin backtrack
?+    # 0 o 1, sin backtrack
{n,m}+

# Grupo atómico (alternativa universal):
(?>...)

# Ejemplo:
"a++a"    # NUNCA coincide con "aa"
          # (el ++ no devuelve la "a")

Los cuantificadores posesivos (++, *+) nunca retroceden — más rápidos pero menos flexibles. (?>...) crea un grupo atómico. Evita el catastrophic backtracking. Soportado en Java, PCRE y .NET (no en JS).

{n}      # exactamente n veces
{n,}     # n o más veces
{n,m}    # entre n y m veces

\d{4}       # exactamente 4 dígitos (año)
\d{2,4}     # 2 a 4 dígitos
\w{3,}      # 3 o más caracteres de palabra
[A-Z]{1,3}  # 1 a 3 mayúsculas (iniciales)

{n} fija la cantidad exacta. {n,} define un mínimo sin límite. {n,m} define un intervalo. Más preciso que * o + cuando conoces los límites. Ideal para códigos, fechas e IDs.

\d{1,3}        # 1 a 3 dígitos (octeto IP)
[a-z]+         # una o más minúsculas
\s*            # cero o más espacios
ba(na)*        # "ba", "bana", "banana"
(\d{2}[./-]){2}\d{4}  # fecha con separadores
\w+@\w+        # user@host (simplificado)

Combina cuantificadores con clases para patrones reales. \s* acepta espacios opcionales. (na)* repite un grupo. Usa {1,3} para octetos de IP. La práctica es combinar estas piezas en patrones compuestos.

# Por defecto, los cuantificadores son voraces:
# intentan coincidir con el MÁXIMO posible

<.+>       # en "<b>texto</b>"
           # toma "<b>texto</b>" (¡todo!)

".+"       # en 'dice "hola" y "adiós"'
           # toma '"hola" y "adiós"' (¡todo!)

# El voraz avanza hasta el final y retrocede
# (backtracking) para encontrar coincidencia

El modo voraz (predeterminado) consume lo máximo posible. El motor avanza hasta el final y hace backtracking para satisfacer el resto del patrón. Puede causar resultados inesperados con múltiples ocurrencias en la misma línea.

# Añadir ? hace el cuantificador perezoso:
# coincide con el MÍNIMO posible

<.+?>      # en "<b>texto</b>"
           # toma "<b>" (¡solo el primero!)

".+?"      # en 'dice "hola" y "adiós"'
           # toma '"hola"' (¡solo el primero!)

# Versiones perezosas: *?  +?  ??  {n,m}?

El modo perezoso (? tras el cuantificador) se detiene en la primera coincidencia válida. .+? es esencial para extraer contenido entre delimitadores. Más predecible que el voraz para HTML y cadenas con comillas.

^          # inicio de la cadena (o línea con flag m)
$          # fin de la cadena (o línea con flag m)

^Hola      # empieza con "Hola"
mundo$     # termina con "mundo"
^\d+$      # toda la cadena son solo dígitos
^$         # cadena vacía

^ ancla al inicio, $ al final. Sin estas anclas, el patrón coincide en cualquier posición. ^\d+$ valida que toda la cadena son dígitos. Esencial para validar entradas completas.

# Las anclas son "zero-width assertions":
# coinciden con una POSICIÓN, no con un char

^    # posición antes del 1er char
$    # posición tras el último char
\b   # posición entre \w y \W

# Todas pueden combinarse:
^\b[A-Z]\w+\b$   # palabra capitalizada
                  # (toda la cadena)

Las anclas no consumen caracteres — solo verifican la posición. Son zero-width assertions, igual que los lookarounds. Combina ^ + \b + $ para validaciones rigurosas. No confundas posición con contenido.

\b         # límite de palabra (transición \w / \W)
\B         # posición que NO es límite

\bgato\b   # "gato" aislado (no "gatos")
\b\d+\b    # número entero aislado
\Bcat      # "cat" en el medio: "concat"
\b[A-Z]    # palabra que empieza con mayúscula

\b detecta la frontera entre \w y \W (o inicio/fin). No consume caracteres — es zero-width. \bgato\b evita falsos positivos en "gatos" o "migato". \B es el inverso.

# Sin flag m: ^ y $ = inicio/fin de la cadena
# Con flag m: ^ y $ = inicio/fin de cada línea

# Con flag m activada:
^#         # líneas que empiezan con #
\.$        # líneas que terminan en punto
^$         # líneas vacías

# En JS: /^#/m
# En PHP: "/^#/m"
# En Python: re.M

La flag m (multiline) hace que ^ y $ actúen en cada línea, no solo en toda la cadena. Ideal para procesar archivos de configuración o logs. Sin m, ^ solo coincide en el inicio absoluto.

\A         # inicio absoluto de la cadena
\Z         # fin absoluto (antes del \n final)
\z         # fin absoluto (sin excepciones)

# Diferencia con ^ y $:
# \A y \z ignoran la flag m
# Siempre = toda la cadena

# Ejemplo: validar token completo
\A[a-f0-9]{32}\z

\A y \z son anclas absolutas — no se ven afectadas por la flag m. \Z acepta un \n final opcional. Úsalas cuando necesites garantizar validación total incluso con multiline activo. Soportado en Ruby, Python, PCRE y Java.

[abc]       # a, b o c
[a-z]       # letra minúscula
[A-Z]       # letra mayúscula
[0-9]       # dígito
[a-zA-Z0-9] # cualquier alfanumérico
[aeiou]     # vocales minúsculas

Los corchetes [...] definen un conjunto — coincide con UN carácter del conjunto. [a-z] es un intervalo. Combina intervalos: [a-zA-Z]. Dentro de [], la mayoría de los metacaracteres pierde el significado.

# POSIX (usado en grep, sed, awk):
[[:alpha:]]   # letras (= [a-zA-Z])
[[:digit:]]   # dígitos (= [0-9])
[[:alnum:]]   # alfanumérico
[[:space:]]   # espacios
[[:upper:]]   # mayúsculas
[[:lower:]]   # minúsculas
[[:punct:]]   # puntuación

# Ejemplo: grep "[[:upper:]]" archivo.txt

Las clases POSIX se usan en herramientas Unix (grep, sed, awk). Sintaxis: [[:nombre:]] (doble corchete). [[:alpha:]] equivale a [a-zA-Z]. No soportadas en JavaScript. En PCRE, prefiere \p{L}.

[^abc]      # cualquier char EXCEPTO a, b, c
[^0-9]      # no dígito (= \D)
[^a-z]      # no minúscula
[^aeiou]    # consonantes (y otros chars)
[^\s]       # no espacio (= \S)

# ^ solo niega si es el 1er char dentro de []

^ como primer carácter dentro de [...] niega el conjunto. [^0-9] equivale a \D. Atención: [^abc] aún coincide con salto de línea — usa [^abc\n] si quieres excluirlo. La negación se aplica a un único carácter.

# Java soporta operaciones en clases:
[a-z&&[^aeiou]]    # consonantes minúsculas
[\w&&[^_]]         # \w sin underscore
[0-9&&[^0]]        # dígitos 1-9

# .NET soporta sustracción:
[\w-[0-9]]         # \w sin dígitos

# En PCRE/JS, simular con negación:
(?![aeiou])[a-z]   # consonante minúscula

Java permite && (intersección) y [^...] interno para sustracción. .NET usa [-...]. En JavaScript y PCRE, simula con lookahead negativo. Útil para filtrar subconjuntos de clases amplias.

[0-9a-fA-F]   # hexadecimal
[a-z0-9_]     # slug (minúsculas, números, _)
[\w.-]        # palabra con punto y guion
[\p{L}\s]     # letras Unicode y espacios
[^\s<>]       # chars que no son espacio ni tags

# El guion al final/inicio es literal:
[-abc] o [abc-]   # guion literal

Los intervalos usan - entre dos chars (a-z). Para un guion literal, colócalo al inicio o al final: [-abc]. Combina múltiples intervalos: [0-9a-fA-F]. \w dentro de [] se expande a [a-zA-Z0-9_].

gato|perro      # "gato" o "perro"
sí|no|quizás    # tres opciones
(jpg|png|gif)   # extensiones de imagen

# | tiene la MENOR precedencia:
# "gra|eta" coincide con "gra" O "eta"
# NO "gr(a|e)ta"

# Usa grupos para limitar:
gr(a|e)ta       # "grata" o "greta"

El pipe | funciona como un OR lógico. Tiene la menor precedencia — separa todo lo de la izquierda de todo lo de la derecha. Usa (...) para limitar el ámbito. (jpg|png|gif) es más eficiente que [jpg] para cadenas completas.

(\d{2})/(\d{2})/(\d{4})
# Captura: día=$1, mes=$2, año=$3

# En sustitución:
# $1-$2-$3  →  "25-12-2024"

# En JS: match[1], match[2], match[3]
# En PHP: $m[1], $m[2], $m[3]
# En Python: group(1), group(2)

Los paréntesis (...) capturan el texto coincidente. Cada grupo recibe un número ($1, $2...). Úsalos en sustituciones para reorganizar. $0 es siempre la coincidencia completa. La numeración sigue el orden de los paréntesis abiertos.

# (?(condición)sí|no) — PCRE y .NET

# Si el grupo 1 capturó, exigir cierre:
(<)?(\w+)(?(1)>)
# Coincide con "abc" o "<abc>" pero no "<abc"

# Si el lookahead pasó:
(?=(\d))\1+[a-z]
# Solo si empieza con dígito

# Poco usado — prefiere lógica separada

Los grupos condicionales (?(cond)sí|no) se ramifican según una captura o aserción. (?(1)...) verifica si el grupo 1 capturó. Soportado en PCRE y .NET, no en JavaScript. Rara vez necesario — prefiere patrones separados por claridad.

(?:...)       # agrupa SIN capturar

(?:ha)+       # "ha", "haha", "hahaha"
(?:https?|ftp)://   # protocolo sin capturar
(?:\d{2}[./-]){2}\d{4}  # fecha (sin grupos)

# Ventajas:
# - Más rápido (no guarda en memoria)
# - No desplaza la numeración de los $n

(?:...) agrupa para aplicar cuantificadores o alternancia sin crear captura. Más eficiente en memoria. No afecta la numeración de $1, $2. Úsalo siempre que no necesites referenciar el contenido del grupo.

# (?|...) — PCRE y Perl
# Reinicia la numeración en cada alternativa:

(?|(\d{4})-(\d{2})|(\d{2})/(\d{4}))
# $1 y $2 en ambas alternativas
# Sin branch reset: $1,$2 o $3,$4

# Útil para múltiples formatos:
(?|cat|dog|bird)  # todos son $1

(?|...) (branch reset) reinicia la numeración de los grupos en cada alternativa. Sin él, las alternativas crean grupos secuenciales. Soportado en PCRE y Perl. Simplifica sustituciones cuando múltiples formatos producen el mismo resultado.

(?<nombre>...)      # sintaxis PCRE/JS/.NET
(?P<nombre>...)     # sintaxis Python

(?<dia>\d{2})/(?<mes>\d{2})/(?<anio>\d{4})

# Acceder:
# JS:     match.groups.dia
# PHP:    $m['dia']
# Python: group('dia')
# Subst:  ${dia}-${mes}-${anio}

Los grupos nombrados ((?<nombre>...)) son más legibles que $1, $2. Python usa (?P<nombre>...). Accede por nombre en vez de número. Ideal para patrones complejos con muchas capturas. Funciona en sustituciones: ${nombre}.

# Referenciar una captura anterior en el patrón:
\1 \2 \3       # (PCRE, Python, Java)
$1 $2 $3       # (JavaScript en el patrón: \1)

(\w+) \1       # palabra repetida: "hola hola"
(["']).*?\1    # comillas emparejadas: "texto" o 'texto'
<(\w+)>.*?</\1> # etiqueta HTML emparejada: <b>...</b>

\1 referencia el texto capturado por el grupo 1. Garantiza que cierre el mismo delimitador. (["']).*?\1 coincide con comillas del mismo tipo. <(\w+)>.*?</\1> valida etiquetas HTML emparejadas. Solo funciona dentro del mismo patrón.

(?=...)       # seguido de... (sin consumir)

\d+(?=€)      # número antes de €: "100" en "100€"
\w+(?=\()     # nombre de función antes de (
(?=.*\d)      # cadena que contiene un dígito

# No consume: la coincidencia es solo el número
# "100€" → coincidencia = "100" (€ no incluido)

(?=...) verifica que el texto siguiente coincide, sin incluirlo en la coincidencia. Es zero-width. Ideal para validaciones: (?=.*\d)(?=.*[A-Z]) exige un dígito Y una mayúscula. El cursor no avanza — la siguiente parte del patrón empieza en la misma posición.

(?=X)    X delante        (positivo)
(?!X)    X NO delante     (negativo)
(?<=X)   X detrás         (positivo)
(?<!X)   X NO detrás      (negativo)

# Todos son zero-width (no consumen)
# Pueden combinarse:
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}$
# Contraseña: dígito + min + may + 8+ chars

Los 4 lookarounds son aserciones zero-width. No capturan ni consumen caracteres. Combínalos para validaciones multicriterio (contraseñas). (?=.*X) es el patrón "debe contener X". Soporte: PCRE, Java, .NET, Python 3; JS solo lookahead, y lookbehind desde ES2018.

(?!...)       # NO seguido de...

foo(?!bar)    # "foo" sin "bar" después
\d+(?!€)      # número sin € después
(?!.*admin)^.*$  # línea sin "admin"

# Contraseña sin secuencias:
^(?!.*123)(?!.*abc).+$

(?!...) rechaza si el texto siguiente coincide. ¿foo(?!bar) coincide con "foobar"? ¡No! Coincide con "foo" en "foobaz". Útil para excluir patrones específicos. Combina varios para validaciones complejas (contraseñas, filtros).

(?<=...)      # precedido de... (sin consumir)

(?<=R\$)\d+      # valor tras "R$": "50" en "R$50"
(?<=@)\w+        # dominio tras @
(?<=https://).+  # URL sin el protocolo

# En JS (ES2018+):
/(?<=€)\d+/.exec("100€")  // ¡ERROR!
/(?<=€)\d+/.exec("€100")  // "100"

(?<=...) verifica el texto ANTES de la posición actual. La coincidencia no incluye el prefijo. En JavaScript, requiere ES2018+. El lookbehind debe tener longitud fija en Java. Ideal para extraer valores tras símbolos o prefijos.

(?<!...)      # NO precedido de...

(?<!un)happy   # "happy" sin "un" antes
(?<!\d)\d{3}   # 3 dígitos sin dígito antes
(?<![/\w])\.   # punto que no está en ruta/URL

# Excluir subdominios:
(?<!www\.)\b[\w.]+\b

(?<!...) rechaza si el texto anterior coincide. (?<!un)happy coincide con "happy" pero no con "unhappy". Útil para evitar falsos positivos. Igual que el lookbehind positivo, debe tener longitud fija en Java y .NET.

^[\w.+-]+@[\w-]+\.[\w.-]+$

# Acepta: nombre@dominio.com
#         nombre.etiqueta@sub.dominio.com
#         user+tag@gmail.com

# Versión más restrictiva:
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Patrón práctico para validación de email. [\w.+-]+ cubre el local part. [\w.-]+ el dominio. No intentes validar el 100% de la RFC 5322 — usa confirmación por email. La versión restrictiva limita los caracteres especiales.

# NIF portugués (9 dígitos, empieza 1-3,5,6,8):
\b[123568]\d{8}\b

# NIF con validación de dígito de control:
# (requiere algoritmo mod 11 — no solo regex)

# Código postal PT:
\b\d{4}-\d{3}\b
# Acepta: 1000-001, 4400-123

# IBAN PT:
\bPT50\s?(\d{4}\s?){5}\d{1}\b

[123568]\d{8} cubre los primeros dígitos válidos de un NIF. La validación completa exige el algoritmo mod 11 (no es posible solo con regex). El código postal es \d{4}-\d{3}. Para IBAN, el patrón es largo — valida también el checksum.

# Móvil PT:
^(\+?351)?[\s]?9\d{2}[\s]?\d{3}[\s]?\d{3}$

# Acepta: 912345678
#         +351 912 345 678
#         351912345678

# Fijo PT:
^(\+?351)?[\s]?2\d{2}[\s]?\d{3}[\s]?\d{3}$

+?351 hace el prefijo opcional. 9\d{2} para móviles (empiezan por 9). [\s]? acepta espacios opcionales entre grupos. Los fijos empiezan por 2. Para validación real, usa la biblioteca libphonenumber.

# Versión completa (0-255 por octeto):
\b((25[0-5]|2[0-4]\d|1?\d?\d)\.){3}(25[0-5]|2[0-4]\d|1?\d?\d)\b

# Versión simple (sin validación de rango):
\b\d{1,3}(\.\d{1,3}){3}\b

# IPv6 simplificado:
\b([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b

25[0-5]|2[0-4]\d|1?\d?\d valida cada octeto (0-255). (...){3} repite los primeros 3 octetos con punto. La versión simple acepta 999.999.999.999 — usa la completa para validar. El IPv6 real es mucho más complejo (compresión ::).

https?://[\w.-]+(?:\.[\w]{2,})+[/\w\-._~:/?#\[\]@!$&'()*+,;=%]*

# Acepta:
# https://ejemplo.com
# http://sub.dominio.com/pagina?q=1

# Versión simple (detección):
\bhttps?://\S+\b

https? cubre http y https. [\w.-]+ es el dominio. La versión simple \bhttps?://\S+\b basta para detección. Para parsing real, usa funciones nativas (parse_url, new URL()). Regex no es ideal para URLs complejas.

^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$

# Criterios:
# (?=.*[a-z])   → al menos 1 minúscula
# (?=.*[A-Z])   → al menos 1 mayúscula
# (?=.*\d)      → al menos 1 dígito
# (?=.*[@$!%*?&]) → al menos 1 especial
# {8,}          → mínimo 8 caracteres

Cada (?=.*X) es un lookahead que exige un criterio. Todos deben pasar (AND lógico). El patrón final [A-Za-z\d@$!%*?&]{8,} limita los caracteres aceptados. Añade más lookaheads para más reglas. Prueba siempre con casos límite.

# Fecha DD/MM/AAAA (con validación):
\b(0[1-9]|[12]\d|3[01])/(0[1-9]|1[0-2])/\d{4}\b

# Hora HH:MM (24h):
\b([01]\d|2[0-3]):[0-5]\d\b

# Fecha ISO:
\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])

# Timestamp completo:
\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}

0[1-9]|[12]\d|3[01] valida días 01-31. [01]\d|2[0-3] limita las horas a 00-23. No valida días por mes (Feb 30 pasa). Para validación real, combina con DateTime o checkdate(). El formato ISO es el más seguro.

# Extraer el contenido de una etiqueta:
<(h[1-6])>(.*?)</\1>

# Eliminar todas las etiquetas:
<[^>]+>

# Atributo específico:
href=["']([^"']+)["']

# Comentario HTML:
<!--[\s\S]*?-->

# ATENCIÓN: ¡regex NO es un parser HTML!
# Usa DOMDocument / cheerio / BeautifulSoup

<(h[1-6])>(.*?)</\1> extrae encabezados con retrorreferencia. <[^>]+> elimina etiquetas (simplificado). Regex falla con HTML anidado o mal formado. Para parsing real, usa un parser DOM. Regex sirve para tareas simples y controladas.

g    # global — todas las ocurrencias (no solo la 1ª)
i    # case-insensitive (ignora mayúsculas)
m    # multiline (^ y $ por línea)
s    # dotall (. incluye \n)
u    # Unicode (UTF-8)
x    # extended (ignora espacios y # comentarios)

# Combinaciones: /patrón/gim
# En Python: re.IGNORECASE | re.MULTILINE

g devuelve todas las coincidencias, no solo la primera. i la hace case-insensitive. m hace que ^/$ actúen por línea. s hace que . incluya nueva línea. x permite patrones legibles con comentarios. Combina según necesites.

# 1. Ser específico (evitar .* genérico)
#    Malo:  <.*>
#    Bueno: <[a-z]+>[^<]*</[a-z]+>

# 2. Anclar cuando sea posible (^...$)
# 3. Usar \d \w \s en vez de [0-9] etc.
# 4. Probar en regex101.com
# 5. Cuidado con el backtracking catastrófico:
#    Malo:  (a+)+$
#    Bueno: a+$
# 6. Documentar patrones complejos
# 7. Usar la flag x para patrones anchos

Evita .* cuando puedas ser específico. (a+)+ causa backtracking catastrófico — simplifícalo. Prueba en regex101.com con explicación paso a paso. Usa la flag x para documentar en línea. Para validación de entradas, ancla siempre con ^ y $.

const re = /\d+/g;
"a1b22".match(re);          // ["1", "22"]
/hola/i.test("HOLA");       // true
texto.replace(/\s+/g, " "); // colapsar espacios

// Con constructor:
new RegExp("\\d+", "g");

// Named groups (ES2018):
/(?<anio>\d{4})-(?<mes>\d{2})/
// match.groups.anio

En JavaScript, una regex va entre /.../flags. .match() devuelve un array, .test() devuelve un booleano. .replace() sustituye. new RegExp() para patrones dinámicos (escapa \). Named groups mediante match.groups.

preg_match("/\d+/", $txt, $m);       // 1er match
preg_match_all("/\w+/", $txt, $m);   // todos
preg_replace("/\s+/", " ", $txt);    // reemplazar
preg_split("/[,;\s]+/", $txt);       // dividir

// Delimitadores: / # ~
// Flags tras el delimitador: "/patrón/gi"

// Named groups:
preg_match('/(?<anio>\d{4})/', $txt, $m);
echo $m['anio'];

PHP usa funciones preg_* con delimitadores (/, #, ~). preg_match devuelve 1 o 0. preg_match_all rellena un array con todas las coincidencias. Los named groups se acceden por clave. Escapa siempre el delimitador dentro del patrón.

import re

re.search(r"\d+", texto)         # 1er match
re.findall(r"\w+", texto)        # lista de todos
re.sub(r"\s+", " ", texto)       # reemplazar
re.split(r"[,;]", texto)         # dividir

# La raw string r"..." evita el escape doble
# Flags: re.IGNORECASE, re.MULTILINE, re.DOTALL

# Compilar para reutilizar:
patron = re.compile(r"\d+", re.IGNORECASE)
patron.findall(texto)

Python usa el módulo re con raw strings r"..." (evita \). re.search para el primero, re.findall para todos. re.compile optimiza patrones reutilizados. Flags como constantes: re.I, re.M, re.S.