Cheatsheet Regex

abc        # corresponde a "abc"
123        # corresponde a "123"
Olá Mundo  # corresponde a "Olá Mundo"

# A correspondência é sequencial:
# "abc" encontra em "xabcx" na posição 1

Caracteres literais correspondem exactamente ao texto. A pesquisa é sequencial e sensível a maiúsculas por defeito. Sem metacaracteres, cada letra é um token individual.

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

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

# Dentro de [...], só ] \ ^ - precisam escape

Estes caracteres controlam a lógica do padrão. ^ e $ são âncoras, * e + quantificadores. Dentro de [...], a maioria perde o significado especial. Use \Q...\E para escapar blocos inteiros.

.          # qualquer caractere (exceto \n)
a.c        # "abc", "a1c", "a c", "a-c"
...        # qualquer sequência de 3 chars
a.c.e      # "abcde", "a1c2e"

# Com flag s (dotall):
# . também corresponde a \n

O . é o curinga universal — corresponde a qualquer caractere excepto nova linha. Com a flag s (dotall), inclui também \n. Use com moderação para evitar matches indesejados.

\p{L}      # qualquer letra (Unicode)
\p{Lu}     # letra maiúscula
\p{Ll}     # letra minúscula
\p{N}      # qualquer número
\p{P}      # pontuação
\p{Sc}     # símbolo de moeda (€, $, £)

\P{L}      # NÃO letra (negado)

# Exemplo: nome com acentos
^[\p{L}\s]+$

\p{...} acede a propriedades Unicode. \p{L} inclui letras acentuadas (á, ã, ç). \P (maiúsculo) nega a propriedade. Essencial para textos em português. Requer flag u na maioria das linguagens.

\d    # dígito [0-9]
\D    # NÃO dígito (equivalente a [^\d])
\w    # palavra [a-zA-Z0-9_]
\W    # NÃO palavra
\s    # espaço em branco (espaço, tab, \n, \r)
\S    # NÃO espaço em branco

Atalhos para conjuntos comuns. \d equivale a [0-9], \w a [a-zA-Z0-9_]. A versão maiúscula é sempre a negação. Prefira estes atalhos a classes manuais pela legibilidade.

\t     # tab
\n     # nova linha (LF)
\r     # retorno de carro (CR)
\0     # caractere nulo

# Escapar metacaracteres:
\.     # ponto literal
\\     # barra invertida literal
\(     # parêntesis literal
\[     # parêntesis recto literal

A barra invertida \ escapa metacaracteres para os tornar literais. \t, \n e \r são caracteres de controlo. Sempre que precisar de ., *, ? literais, escape com \.

*       # 0 ou mais vezes
+       # 1 ou mais vezes
?       # 0 ou 1 (opcional)

a*      # "", "a", "aa", "aaa"
a+      # "a", "aa" (não corresponde a "")
colou?r # "color" ou "colour"
https?  # "http" ou "https"

* aceita zero ocorrências, + exige pelo menos uma. ? torna o elemento opcional. São os quantificadores mais usados. Aplique a caracteres, classes ou grupos.

# Quantificadores possessivos (Java, PCRE):
*+    # 0 ou mais, sem backtrack
++    # 1 ou mais, sem backtrack
?+    # 0 ou 1, sem backtrack
{n,m}+

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

# Exemplo:
"a++a"    # NUNCA casa "aa"
          # (o ++ não devolve o "a")

Quantificadores possessivos (++, *+) nunca recuam — mais rápidos mas menos flexíveis. (?>...) cria grupo atómico. Evita catastrophic backtracking. Suportado em Java, PCRE e .NET (não em JS).

{n}      # exatamente n vezes
{n,}     # n ou mais vezes
{n,m}    # entre n e m vezes

\d{4}       # exatamente 4 dígitos (ano)
\d{2,4}     # 2 a 4 dígitos
\w{3,}      # 3 ou mais caracteres de palavra
[A-Z]{1,3}  # 1 a 3 maiúsculas (iniciais)

{n} fixa a quantidade exacta. {n,} define mínimo sem limite. {n,m} define intervalo. Mais preciso que * ou + quando sabe os limites. Ideal para códigos, datas e IDs.

\d{1,3}        # 1 a 3 dígitos (octeto IP)
[a-z]+         # uma ou mais minúsculas
\s*            # zero ou mais espaços
ba(na)*        # "ba", "bana", "banana"
(\d{2}[./-]){2}\d{4}  # data com separadores
\w+@\w+        # user@host (simplificado)

Combine quantificadores com classes para padrões reais. \s* aceita espaços opcionais. (na)* repete um grupo. Use {1,3} para octetos de IP. A prática é combinar estas peças em padrões compostos.

# Por defeito, quantificadores são gulosos:
# tentam corresponder ao MÁXIMO possível

<.+>       # em "<b>texto</b>"
           # pega "<b>texto</b>" (tudo!)

".+"       # em 'diz "olá" e "adeus"'
           # pega '"olá" e "adeus"' (tudo!)

# O guloso avança até ao fim e recua
# (backtracking) para encontrar match

Modo guloso (default) consome o máximo possível. O motor avança até ao fim e faz backtracking para satisfazer o resto do padrão. Pode causar resultados inesperados com múltiplas ocorrências na mesma linha.

# Adicionar ? torna o quantificador preguiçoso:
# corresponde ao MÍNIMO possível

<.+?>      # em "<b>texto</b>"
           # pega "<b>" (só o primeiro!)

".+?"      # em 'diz "olá" e "adeus"'
           # pega '"olá"' (só o primeiro!)

# Versões lazy: *?  +?  ??  {n,m}?

O modo lazy (? após quantificador) para na primeira correspondência válida. .+? é essencial para extrair conteúdo entre delimitadores. Mais previsível que o guloso para HTML e strings com aspas.

^          # início da string (ou linha com flag m)
$          # fim da string (ou linha com flag m)

^Olá       # começa com "Olá"
mundo$     # termina com "mundo"
^\d+$      # string inteira são só dígitos
^$         # string vazia

^ ancora no início, $ no fim. Sem estas âncoras, o padrão casa em qualquer posição. ^\d+$ valida que a string inteira são dígitos. Essenciais para validação de inputs completos.

# Âncoras são "zero-width assertions":
# correspondem a uma POSIÇÃO, não a um char

^    # posição antes do 1º char
$    # posição após o último char
\b   # posição entre \w e \W

# Todas podem ser combinadas:
^\b[A-Z]\w+\b$   # palavra capitalizada
                  # (string inteira)

Âncoras não consomem caracteres — verificam apenas a posição. São zero-width assertions, tal como lookarounds. Combine ^ + \b + $ para validações rigorosas. Não confundir posição com conteúdo.

\b         # limite de palavra (transição \w / \W)
\B         # posição que NÃO é limite

\bgato\b   # "gato" isolado (não "gatos")
\b\d+\b    # número inteiro isolado
\Bcat      # "cat" no meio: "concat"
\b[A-Z]    # palavra que começa com maiúscula

\b detecta a fronteira entre \w e \W (ou início/fim). Não consome caracteres — é zero-width. \bgato\b evita falsos positivos em "gatos" ou "migato". \B é o inverso.

# Sem flag m: ^ e $ = início/fim da string
# Com flag m: ^ e $ = início/fim de cada linha

# Com flag m activada:
^#         # linhas que começam com #
\.$        # linhas que terminam em ponto
^$         # linhas vazias

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

A flag m (multiline) faz ^ e $ actuarem em cada linha, não só na string inteira. Ideal para processar ficheiros de configuração ou logs. Sem m, ^ só casa no início absoluto.

\A         # início absoluto da string
\Z         # fim absoluto (antes de \n final)
\z         # fim absoluto (sem excepções)

# Diferença com ^ e $:
# \A e \z ignoram a flag m
# Sempre = string inteira

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

\A e \z são âncoras absolutas — não são afectadas pela flag m. \Z aceita um \n final opcional. Use quando precisa de garantir validação total mesmo com multiline activo. Suportado em Ruby, Python, PCRE e Java.

[abc]       # a, b ou c
[a-z]       # letra minúscula
[A-Z]       # letra maiúscula
[0-9]       # dígito
[a-zA-Z0-9] # qualquer alfanumérico
[aeiou]     # vogais minúsculas

Colchetes [...] definem um conjunto — corresponde a UM caractere do conjunto. [a-z] é um intervalo. Combine intervalos: [a-zA-Z]. Dentro de [], a maioria dos metacaracteres perde o significado.

# POSIX (usado em grep, sed, awk):
[[:alpha:]]   # letras (= [a-zA-Z])
[[:digit:]]   # dígitos (= [0-9])
[[:alnum:]]   # alfanumérico
[[:space:]]   # espaços
[[:upper:]]   # maiúsculas
[[:lower:]]   # minúsculas
[[:punct:]]   # pontuação

# Exemplo: grep "[[:upper:]]" ficheiro.txt

Classes POSIX são usadas em ferramentas Unix (grep, sed, awk). Sintaxe: [[:nome:]] (duplo colchete). [[:alpha:]] equivale a [a-zA-Z]. Não suportadas em JavaScript. Em PCRE, prefira \p{L}.

[^abc]      # qualquer char EXCEPTO a, b, c
[^0-9]      # não dígito (= \D)
[^a-z]      # não minúscula
[^aeiou]    # consoantes (e outros chars)
[^\s]       # não espaço (= \S)

# ^ só nega se for o 1º char dentro de []

^ como primeiro caractere dentro de [...] nega o conjunto. [^0-9] equivale a \D. Atenção: [^abc] ainda corresponde a nova linha — use [^abc\n] se quiser excluir. A negação aplica-se a um único caractere.

# Java suporta operações em classes:
[a-z&&[^aeiou]]    # consoantes minúsculas
[\w&&[^_]]         # \w sem underscore
[0-9&&[^0]]        # dígitos 1-9

# .NET suporta subtracção:
[\w-[0-9]]         # \w sem dígitos

# Em PCRE/JS, simular com negação:
(?![aeiou])[a-z]   # consoante minúscula

Java permite && (intersecção) e [^...] interno para subtracção. .NET usa [-...]. Em JavaScript e PCRE, simule com lookahead negativo. Útil para filtrar subconjuntos de classes amplas.

[0-9a-fA-F]   # hexadecimal
[a-z0-9_]     # slug (minúsculas, números, _)
[\w.-]        # palavra com ponto e hífen
[\p{L}\s]     # letras Unicode e espaços
[^\s<>]       # chars que não são espaço nem tags

# Hífen no fim/início é literal:
[-abc] ou [abc-]  # hífen literal

Intervalos usam - entre dois chars (a-z). Para hífen literal, coloque no início ou fim: [-abc]. Combine múltiplos intervalos: [0-9a-fA-F]. \w dentro de [] expande para [a-zA-Z0-9_].

gato|cão        # "gato" ou "cão"
sim|não|talvez  # três opções
(jpg|png|gif)   # extensões de imagem

# | tem a MENOR precedência:
# "gra|eta" casa "gra" OU "eta"
# NÃO "gr(a|e)ta"

# Use grupos para limitar:
gr(a|e)ta       # "grata" ou "greta"

O pipe | funciona como OR lógico. Tem a menor precedência — separa tudo à esquerda de tudo à direita. Use (...) para limitar o âmbito. (jpg|png|gif) é mais eficiente que [jpg] para strings completas.

(\d{2})/(\d{2})/(\d{4})
# Captura: dia=$1, mês=$2, ano=$3

# Em substituição:
# $1-$2-$3  →  "25-12-2024"

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

Parênteses (...) capturam o texto correspondente. Cada grupo recebe um número ($1, $2...). Use em substituições para reorganizar. $0 é sempre o match completo. A numeração segue a ordem dos parênteses abertos.

# (?(condição)sim|não) — PCRE e .NET

# Se grupo 1 capturou, exigir fecho:
(<)?(\w+)(?(1)>)
# Casa "abc" ou "<abc>" mas não "<abc"

# Se lookahead passou:
(?=(\d))\1+[a-z]
# Só se começar com dígito

# Pouco usado — prefira lógica separada

Grupos condicionais (?(cond)sim|não) ramificam conforme uma captura ou asserção. (?(1)...) verifica se o grupo 1 capturou. Suportado em PCRE e .NET, não em JavaScript. Raramente necessário — prefira padrões separados pela clareza.

(?:...)       # agrupa SEM capturar

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

# Vantagens:
# - Mais rápido (não guarda em memória)
# - Não desloca a numeração dos $n

(?:...) agrupa para aplicar quantificadores ou alternância sem criar captura. Mais eficiente em memória. Não afecta a numeração de $1, $2. Use sempre que não precisa de referenciar o conteúdo do grupo.

# (?|...) — PCRE e Perl
# Reinicia numeração em cada alternativa:

(?|(\d{4})-(\d{2})|(\d{2})/(\d{4}))
# $1 e $2 em ambas as alternativas
# Sem branch reset: $1,$2 ou $3,$4

# Útil para múltiplos formatos:
(?|cat|dog|bird)  # todos são $1

(?|...) (branch reset) reinicia a numeração dos grupos em cada alternativa. Sem ele, alternativas criam grupos sequenciais. Suportado em PCRE e Perl. Simplifica substituições quando múltiplos formatos produzem o mesmo resultado.

(?<nome>...)        # sintaxe PCRE/JS/.NET
(?P<nome>...)       # sintaxe Python

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

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

Grupos nomeados ((?<nome>...)) são mais legíveis que $1, $2. Python usa (?P<nome>...). Aceda por nome em vez de número. Ideal para padrões complexos com muitas capturas. Funciona em substituições: ${nome}.

# Referenciar captura anterior no padrão:
\1 \2 \3       # (PCRE, Python, Java)
$1 $2 $3       # (JavaScript no padrão: \1)

(\w+) \1       # palavra repetida: "ola ola"
(["']).*?\1    # aspas casadas: "texto" ou 'texto'
<(\w+)>.*?</\1> # tag HTML casada: <b>...</b>

\1 referencia o texto capturado pelo grupo 1. Garante que o mesmo delimitador fecha. (["']).*?\1 casa aspas do mesmo tipo. <(\w+)>.*?</\1> valida tags HTML casadas. Só funciona dentro do mesmo padrão.

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

\d+(?=€)      # número antes de €: "100" em "100€"
\w+(?=\()     # nome de função antes de (
(?=.*\d)      # string que contém um dígito

# Não consome: o match é só o número
# "100€" → match = "100" (€ não incluído)

(?=...) verifica que o texto à frente corresponde, sem o incluir no match. É zero-width. Ideal para validações: (?=.*\d)(?=.*[A-Z]) exige dígito E maiúscula. O cursor não avança — a próxima parte do padrão começa na mesma posição.

(?=X)    X à frente       (positivo)
(?!X)    X NÃO à frente   (negativo)
(?<=X)   X atrás          (positivo)
(?<!X)   X NÃO atrás      (negativo)

# Todos são zero-width (não consomem)
# Podem ser combinados:
^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,}$
# Password: dígito + min + mai + 8+ chars

Os 4 lookarounds são asserções zero-width. Não capturam nem consomem caracteres. Combine para validações multi-critério (passwords). (?=.*X) é o padrão "deve conter X". Suporte: PCRE, Java, .NET, Python 3; JS só lookahead e lookbehind desde ES2018.

(?!...)       # NÃO seguido de...

foo(?!bar)    # "foo" sem "bar" a seguir
\d+(?!€)      # número sem € depois
(?!.*admin)^.*$  # linha sem "admin"

# Password sem sequências:
^(?!.*123)(?!.*abc).+$

(?!...) rejeita se o texto à frente corresponder. foo(?!bar) casa "foobar"? Não! Casa "foo" em "foobaz". Útil para excluir padrões específicos. Combine múltiplos para validações complexas (passwords, filtros).

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

(?<=R\$)\d+      # valor após "R$": "50" em "R$50"
(?<=@)\w+        # domínio após @
(?<=https://).+  # URL sem o protocolo

# Em JS (ES2018+):
/(?<=€)\d+/.exec("100€")  // ERRO!
/(?<=€)\d+/.exec("€100")  // "100"

(?<=...) verifica o texto ANTES da posição actual. O match não inclui o prefixo. Em JavaScript, requer ES2018+. O lookbehind deve ter comprimento fixo em Java. Ideal para extrair valores após símbolos ou prefixos.

(?<!...)      # NÃO precedido de...

(?<!un)happy   # "happy" sem "un" antes
(?<!\d)\d{3}   # 3 dígitos sem dígito antes
(?<![/\w])\.   # ponto não em caminho/URL

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

(?<!...) rejeita se o texto anterior corresponder. (?<!un)happy casa "happy" mas não "unhappy". Útil para evitar falsos positivos. Tal como lookbehind positivo, deve ter comprimento fixo em Java e .NET.

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

# Aceita: nome@dominio.com
#         nome.tag@sub.dominio.pt
#         user+tag@gmail.com

# Versão mais restritiva:
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$

Padrão prático para validação de email. [\w.+-]+ cobre o local part. [\w.-]+ o domínio. Não tente validar 100% da RFC 5322 — use confirmação por email. A versão restritiva limita caracteres especiais.

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

# NIF com validação de check digit:
# (requer algoritmo mod 11 — não só regex)

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

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

[123568]\d{8} cobre os primeiros dígitos válidos de NIF. A validação completa exige algoritmo mod 11 (não é possível só com regex). Código postal é \d{4}-\d{3}. Para IBAN, o padrão é longo — valide também o checksum.

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

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

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

+?351 torna o indicativo opcional. 9\d{2} para telemóveis (começam por 9). [\s]? aceita espaços opcionais entre grupos. Fixos começam por 2. Para validação real, use a biblioteca libphonenumber.

# Versão 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

# Versão simples (sem validação de range):
\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} repete os primeiros 3 octetos com ponto. A versão simples aceita 999.999.999.999 — use a completa para validação. IPv6 real é muito mais complexo (compressão ::).

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

# Aceita:
# https://exemplo.com
# http://sub.dominio.pt/pagina?q=1

# Versão simples (detecção):
\bhttps?://\S+\b

https? cobre http e https. [\w.-]+ é o domínio. A versão simples \bhttps?://\S+\b basta para detecção. Para parsing real, use funções nativas (parse_url, new URL()). Regex não é ideal para URLs complexas.

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

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

Cada (?=.*X) é um lookahead que exige um critério. Todos devem passar (AND lógico). O padrão final [A-Za-z\d@$!%*?&]{8,} limita os caracteres aceites. Adicione mais lookaheads para mais regras. Teste sempre com casos limite.

# Data DD/MM/AAAA (com validação):
\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

# Data 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 dias 01-31. [01]\d|2[0-3] limita horas a 00-23. Não valida dias por mês (Fev 30 passa). Para validação real, combine com DateTime ou checkdate(). Formato ISO é o mais seguro.

# Extrair conteúdo de uma tag:
<(h[1-6])>(.*?)</\1>

# Remover todas as tags:
<[^>]+>

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

# Comentário HTML:
<!--[\s\S]*?-->

# ATENÇÃO: regex NÃO é parser HTML!
# Use DOMDocument / cheerio / BeautifulSoup

<(h[1-6])>(.*?)</\1> extrai headings com backreference. <[^>]+> remove tags (simplificado). Regex falha em HTML aninhado ou malformado. Para parsing real, use um parser DOM. Regex serve para tarefas simples e controladas.

g    # global — todas as ocorrências (não só 1ª)
i    # case-insensitive (ignora maiúsculas)
m    # multiline (^ e $ por linha)
s    # dotall (. inclui \n)
u    # Unicode (UTF-8)
x    # extended (ignora espaços e # comentários)

# Combinações: /padrão/gim
# Em Python: re.IGNORECASE | re.MULTILINE

g retorna todos os matches, não só o primeiro. i torna case-insensitive. m faz ^/$ actuar por linha. s faz . incluir nova linha. x permite padrões legíveis com comentários. Combine conforme necessário.

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

# 2. Ancorar quando possível (^...$)
# 3. Usar \d \w \s em vez de [0-9] etc.
# 4. Testar em regex101.com
# 5. Cuidado com catastrophic backtracking:
#    Mau:  (a+)+$
#    Bom:  a+$
# 6. Documentar padrões complexos
# 7. Usar flag x para padrões longos

Evite .* quando pode ser específico. (a+)+ causa backtracking catastrófico — simplifique. Teste em regex101.com com explicação passo a passo. Use flag x para documentar inline. Para validação de inputs, sempre ancore com ^ e $.

const re = /\d+/g;
"a1b22".match(re);          // ["1", "22"]
/olá/i.test("OLÁ");         // true
texto.replace(/\s+/g, " "); // colapsar espaços

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

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

Em JavaScript, regex vai entre /.../flags. .match() retorna array, .test() retorna boolean. .replace() substitui. new RegExp() para padrões dinâmicos (escape \). Named groups via match.groups.

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

// Delimitadores: / # ~
// Flags após delimitador: "/padrão/gi"

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

PHP usa funções preg_* com delimitadores (/, #, ~). preg_match retorna 1 ou 0. preg_match_all preenche array com todos os matches. Named groups acedidos por chave. Sempre escape o delimitador dentro do padrão.

import re

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

# Raw string r"..." evita escape duplo
# Flags: re.IGNORECASE, re.MULTILINE, re.DOTALL

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

Python usa módulo re com raw strings r"..." (evita \). re.search para o primeiro, re.findall para todos. re.compile optimiza padrões reutilizados. Flags como constantes: re.I, re.M, re.S.