FreeToolsForWeb
AjudaMe paga um café

Guia rápido de regex — todos os tokens com exemplos

Todos os tokens de expressões regulares com um exemplo que funciona, suporte em JavaScript, PCRE/PHP, Python, Go, Java e .NET, e um link “Teste no testador de regex” que abre o testador de regex já preenchido.

Última verificação: 2026-10-18, conferido com ECMAScript 2025 (MDN), PCRE2 10.45, re do Python 3.14, regexp/syntax do Go 1.27, Pattern do Java 25 e a referência de regex do .NET. Fontes: MDN regular expressions, PCRE2 pattern syntax, Python re, Go regexp/syntax, Java Pattern, .NET regex quick reference.

82 itens
Variante de regex

✓ mesma sintaxe · ~ sintaxe diferente ou limitada · ✗ não suportado. Os exemplos rodam em JavaScript; as observações dão a sintaxe para outras linguagens.

Caracteres e escapes

A maioria dos caracteres corresponde a si mesma. Estes doze têm significado especial e precisam de barra invertida para serem encontrados literalmente: \ ^ $ . | ? * + ( ) [ { (e ] } em algumas posições).

.Qualquer caractere#

Qualquer caractere único, exceto quebra de linha. Adicione a flag s (dotAll) para incluir quebras de linha.

/h.t/g em “hat hot h t hit h↵t” corresponde a “hat” “hot” “h t” “hit”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: Exclui só \n; o JavaScript também exclui \r, \u2028 e \u2029.
  • Go RE2: Exclui só \n.
Teste no testador de regex →
\. \$ \(Escapar um metacaractere#

Uma barra invertida torna literal o próximo caractere especial: \. é um ponto de verdade, \$ um cifrão.

/\$\d+\.\d{2}/g em “Total $45.00, tax $3.15, tip 5” corresponde a “$45.00” “$3.15”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
\t \n \rTabulação, nova linha, retorno de carro#

Caracteres de controle pelo nome. As quebras de linha do Windows são \r\n; \r?\n corresponde aos dois estilos.

/\w+\t\w+/g em “name⇥age↵ana⇥31” corresponde a “name⇥age” “ana⇥31”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
\xhhCaractere por código hexadecimal#

Exatamente dois dígitos hexadecimais: \x41 é A, \x20 um espaço.

/\x41/g em “A b A” corresponde a “A” “A”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
\uhhhhCaractere por unidade de código Unicode#

Quatro dígitos hexadecimais para um caractere do Plano Multilíngue Básico: \u00e9 é é.

/\u00e9/g em “café résumé” corresponde a “é” “é” “é”
✓ JS✗ PCRE✓ Py✗ Go✓ Java✓ .NET
  • PCRE / PHP: Use \x{e9}.
  • Go RE2: Use \x{e9}.
Teste no testador de regex →
\u{1F600}Qualquer code point (astrais também)#

Code point entre chaves, necessário para emojis e outros caracteres acima de U+FFFF. O JavaScript exige a flag u ou v.

/\u{1F600}/gu em “Hi 😀 there 😀” corresponde a “😀” “😀”
✓ JS~ PCRE~ Py~ Go~ Java✗ .NET
  • PCRE / PHP: Escreva \x{1F600} (o PHP precisa do modificador u).
  • Python re: Escreva \U0001F600 (oito dígitos hexadecimais).
  • Go RE2: Escreva \x{1F600}.
  • Java: Escreva \x{1F600}.
  • .NET: Só \uhhhh; um emoji são duas unidades de código UTF-16, ex.: \uD83D\uDE00.
Teste no testador de regex →

Classes de caracteres

Uma classe corresponde a exatamente um caractere de um conjunto. Dentro de [ ], a maioria dos metacaracteres perde o significado; só ] \ ^ e - exigem cuidado.

[abc]Qualquer um de#

Um caractere da lista.

/gr[ae]y/g em “gray grey groy” corresponde a “gray” “grey”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
[^abc]Nenhum de#

Um caractere que não está na lista (um ^ em qualquer posição que não a primeira é literal). Também corresponde a quebras de linha.

/[^aeiou\s]/g em “regex” corresponde a “r” “g” “x”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
[a-z]Intervalo#

Caracteres entre dois code points. Combine intervalos: [A-Fa-f0-9] é um dígito hexadecimal. Um - no início ou no fim é literal.

/[A-Fa-f0-9]+/g em “x: 3fA9 zz” corresponde a “3fA9”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
\d \DDígito / não dígito#

\d é um dígito, \D qualquer outra coisa.

/\d+/g em “Order 66, room 101” corresponde a “66” “101”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: Em padrões str, \d corresponde a qualquer dígito Unicode (ex.: ٣); use re.ASCII para só 0-9.
  • .NET: Corresponde a qualquer dígito Unicode, a menos que RegexOptions.ECMAScript esteja definido.
Teste no testador de regex →
\w \WCaractere de palavra / não palavra#

Letras, dígitos e sublinhado. Em JavaScript e Go, isso significa só ASCII: \w não corresponde a é.

/\w+/g em “snake_case and kebab-case” corresponde a “snake_case” “and” “kebab” “case”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: ASCII, a menos que PCRE2_UCP esteja ativo (PHP: modificador u mais (*UCP)).
  • Python re: Letras e dígitos Unicode por padrão em padrões str.
  • Java: ASCII, a menos que a flag U (UNICODE_CHARACTER_CLASS) esteja ativa.
  • .NET: Letras, dígitos e pontuação conectora Unicode.
Teste no testador de regex →
\s \SEspaço em branco / não espaço#

Espaço, tabulação, quebras de linha e (na maioria dos motores) outros espaços Unicode.

/\s+/g em “a b⇥c” corresponde a “ ” “⇥”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Go RE2: Só espaços em branco ASCII: \t \n \f \r e espaço.
Teste no testador de regex →
[[:alpha:]]Classe POSIX entre colchetes#

Classes nomeadas como [:alpha:], [:digit:], [:space:], [:punct:], usadas dentro de colchetes.

Sintaxe (fora do JavaScript): [[:alpha:]]+
✗ JS✓ PCRE✗ Py✓ Go~ Java✗ .NET
  • JavaScript: Use [A-Za-z] ou \p{L} com a flag u.
  • Java: Use \p{Alpha}, \p{Digit}, \p{Punct}.
[\p{L}--[a-z]]Subtração / interseção de classes#

Operações de conjunto dentro de uma classe. O JavaScript precisa da flag v (ES2024): -- subtrai, && faz a interseção.

/[\p{L}--[a-z]]+/gv em “abcÉtéXYZ” corresponde a “É” “éXYZ”
✓ JS~ PCRE✗ Py✗ Go~ Java~ .NET
  • PCRE / PHP: Só PCRE2 10.45+, com a sintaxe de classe estendida (?[ … ]).
  • Java: Interseção [a-z&&[^aeiou]]; a subtração é escrita como interseção com uma negação.
  • .NET: Subtração [a-z-[aeiou]]; sem interseção.
Teste no testador de regex →

Âncoras e limites

Âncoras correspondem a uma posição, não a um caractere, então nunca consomem texto.

^ $Início / fim da string (ou da linha com m)#

Sem a flag m, ^ e $ são o início e o fim da entrada inteira; com ela, de cada linha.

/^\w+/gm em “first line↵second line” corresponde a “first” “second”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: $ também corresponde antes de um \n final.
  • Python re: $ também corresponde antes de um \n final.
  • Java: $ também corresponde antes de um terminador de linha final.
  • .NET: $ também corresponde antes de um \n final.
Teste no testador de regex →
\bLimite de palavra#

Entre um caractere de palavra e um que não é de palavra (ou a borda da entrada). Use para encontrar palavras inteiras.

/\bcat\b/g em “cat concat cats cat.” corresponde a “cat” “cat”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • JavaScript: Só caracteres de palavra ASCII, mesmo com a flag u.
  • Go RE2: Só caracteres de palavra ASCII.
Teste no testador de regex →
\BNão é limite de palavra#

Dentro de uma palavra, ex.: "cat" só quando faz parte de uma palavra maior.

/\Bcat/g em “concat cat bobcat” corresponde a “cat” “cat”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
\A \z \ZInício / fim absolutos#

Início e fim da entrada, independentemente do modo multilinha. \Z também permite uma nova linha final (exceto em Python, onde é sinônimo de \z).

Sintaxe (fora do JavaScript): \A\d+\z
✗ JS✓ PCRE~ Py~ Go✓ Java✓ .NET
  • JavaScript: Use ^ e $ sem a flag m.
  • Python re: \A e \z (3.14+); \Z significa fim absoluto, como \z nas outras.
  • Go RE2: \A e \z; sem \Z.
\GFim da correspondência anterior#

Posição onde terminou a última correspondência; usada para encontrar sequências contíguas.

Sintaxe (fora do JavaScript): \G\d
~ JS✓ PCRE✗ Py✗ Go✓ Java✓ .NET
  • JavaScript: Sem \G; a flag y (sticky) dá o mesmo comportamento de "começar exatamente aqui".

Quantificadores: guloso, preguiçoso, possessivo

Um quantificador repete o item anterior. O guloso (padrão) pega o máximo possível e depois recua; o preguiçoso (adicione ?) pega o mínimo possível; o possessivo (adicione +) nunca recua.

*Zero ou mais#

Repete de 0 a ilimitadas vezes.

/ba*/g em “b ba baaa” corresponde a “b” “ba” “baaa”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
+Um ou mais#

Repete de 1 a ilimitadas vezes.

/lo+l/g em “lol loool ll” corresponde a “lol” “loool”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
?Opcional#

Zero ou uma vez.

/colou?r/g em “color colour colouur” corresponde a “color” “colour”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
{n}Exatamente n#

Exatamente n repetições.

/\d{3}/g em “12 345 6789” corresponde a “345” “678”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
{n,}n ou mais#

Pelo menos n repetições.

/\d{2,}/g em “1 22 333” corresponde a “22” “333”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
{n,m}Entre n e m#

De n a m repetições, o máximo possível.

/\d{2,3}/g em “1 22 4444” corresponde a “22” “444”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Go RE2: Contagens acima de 1000 são rejeitadas.
Teste no testador de regex →
{,m}Até m#

De zero a m repetições. Só alguns motores aceitam; nos demais, é o texto literal "{,m}" ou um erro. {0,m} funciona em todos.

Sintaxe (fora do JavaScript): \d{,3}
✗ JS~ PCRE✓ Py✗ Go✗ Java✗ .NET
  • JavaScript: Texto literal sem u, erro de sintaxe com u; escreva {0,3}.
  • PCRE / PHP: Só PCRE2 10.43+.
  • Go RE2: Escreva {0,3}.
  • Java: Escreva {0,3}.
  • .NET: Tratado como texto literal; escreva {0,3}.
.* .+Guloso (padrão)#

Pega a maior correspondência possível e depois devolve caracteres até o resto caber. Aqui ele engole as duas tags.

/<.+>/g em “<b>bold</b>” corresponde a “<b>bold</b>”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
*? +? ?? {n,m}?Preguiçoso (não guloso)#

Pega a menor correspondência possível. Geralmente é a solução quando um padrão "pega demais".

/<.+?>/g em “<b>bold</b>” corresponde a “<b>” “</b>”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Go RE2: Também disponível como a flag U, que inverte guloso e preguiçoso.
Teste no testador de regex →
*+ ++ ?+Possessivo#

Guloso sem backtracking: depois de encontrados, os caracteres nunca são devolvidos. Falha mais rápido e protege contra backtracking catastrófico.

Sintaxe (fora do JavaScript): "[^"]*+"
✗ JS✓ PCRE~ Py✗ Go✓ Java✗ .NET
  • JavaScript: Sem quantificadores possessivos nem grupos atômicos; emule com (?=(…))\1.
  • Python re: Python 3.11+.
  • Go RE2: Não é necessário: o RE2 nunca faz backtracking.
  • .NET: Use um grupo atômico (?>…).

Grupos e retrorreferências

Parênteses agrupam itens para quantificadores e alternância e (a menos que sejam marcados como não capturantes) guardam o que encontraram.

( … )Grupo de captura#

Agrupa e captura; numerado a partir de 1 pela ordem do parêntese de abertura.

/(\d{3})-(\d{4})/g em “Call 555-0199 or 555-0123” corresponde a “555-0199” “555-0123”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
(?: … )Grupo sem captura#

Agrupa sem guardar, então a numeração dos grupos se mantém estável e a busca fica um pouco mais leve.

/(?:ab)+/g em “ababab ab a” corresponde a “ababab” “ab”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
(?<name> … )Grupo nomeado#

Captura com um nome que você pode ler depois (match.groups.name em JavaScript).

/(?<year>\d{4})-(?<month>\d{2})/g em “Released 2026-10” corresponde a “2026-10”
✓ JS✓ PCRE~ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: Também (?'name'…) e (?P<name>…).
  • Python re: Só (?P<name>…).
  • Go RE2: (?P<name>…); (?<name>…) também é aceito desde o Go 1.22.
  • .NET: Também (?'name'…).
Teste no testador de regex →
\1Retrorreferência por número#

Corresponde ao mesmo texto que um grupo capturou antes.

/(\w)\1/g em “bookkeeper” corresponde a “oo” “kk” “ee”
✓ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
  • Go RE2: O RE2 não tem retrorreferências (elas quebrariam sua garantia de tempo linear).
Teste no testador de regex →
\k<name>Retrorreferência por nome#

Igual a \1, mas pelo nome. O exemplo encontra texto entre aspas do mesmo tipo.

/(?<q>['"]).*?\k<q>/g em “say "hi" or 'yo'” corresponde a “"hi"” “'yo'”
✓ JS✓ PCRE~ Py✗ Go✓ Java✓ .NET
  • PCRE / PHP: Também \k{name}, \g{name} e (?P=name).
  • Python re: Escreva (?P=name).
Teste no testador de regex →
a|bAlternância (ou)#

Um lado ou o outro. As alternativas são testadas da esquerda para a direita, então coloque as mais longas primeiro quando uma for prefixo de outra.

/cat|dog/g em “hotdog catalog” corresponde a “dog” “cat”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
(?> … )Grupo atômico#

Depois que o grupo encontra correspondência, o motor não volta atrás dentro dele.

Sintaxe (fora do JavaScript): (?>a|ab)c
✗ JS✓ PCRE~ Py✗ Go✓ Java✓ .NET
  • Python re: Python 3.11+.
  • Go RE2: Não é necessário: o RE2 nunca faz backtracking.
(?i) (?i: … )Flags inline#

Ativam ou desativam flags dentro do padrão. (?i) vale para o resto do padrão; (?i:…) só para o grupo; (?-i:…) desativa uma flag.

/(?i:hello) world/g em “HELLO world HELLO WORLD” corresponde a “HELLO world”
~ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • JavaScript: Só a forma com escopo (?i:…) / (?-i:…), para i, m e s (ES2025). (?i) no início é erro de sintaxe.
  • Python re: O (?i) global deve ficar bem no início do padrão (em outro lugar é erro desde o 3.11); (?i:…) funciona em qualquer lugar.
Teste no testador de regex →
(?(1)yes|no)Condicional#

Corresponde a "yes" se o grupo 1 participou; caso contrário, a "no".

Sintaxe (fora do JavaScript): (<)?\w+(?(1)>)
✗ JS✓ PCRE✓ Py✗ Go✗ Java✓ .NET
(?R) (?1)Recursão / sub-rotina#

Reentra no padrão inteiro ou em um grupo, para estruturas aninhadas como parênteses balanceados.

Sintaxe (fora do JavaScript): \((?:[^()]|(?R))*\)
✗ JS✓ PCRE✗ Py✗ Go✗ Java~ .NET
  • Python re: Disponível no módulo de terceiros regex.
  • .NET: Sem recursão; grupos de balanceamento (?<open-close>…) lidam com aninhamento.
(?# … )Comentário inline#

Ignorado pelo motor. Para comentários mais longos, use a flag x (estendida).

Sintaxe (fora do JavaScript): \d{3}(?#area code)
✗ JS✓ PCRE✓ Py✗ Go✗ Java✓ .NET

Lookahead e lookbehind

Lookarounds verificam o que está ao lado da posição atual sem incluir isso na correspondência. Têm largura zero, como as âncoras.

(?= … )Lookahead positivo#

Seguido de … (não incluído na correspondência).

/\d+(?=px)/g em “10px 20em 30px” corresponde a “10” “30”
✓ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
  • Go RE2: O RE2 não tem nenhum tipo de lookaround.
Teste no testador de regex →
(?! … )Lookahead negativo#

Não seguido de …. O \d dentro impede que o motor devolva dígitos para fazer a verificação passar.

/\d+(?!px|\d)/g em “10px 20em” corresponde a “20”
✓ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
Teste no testador de regex →
(?<= … )Lookbehind positivo#

Precedido de … (não incluído na correspondência).

/(?<=\$)\d+(?:\.\d\d)?/g em “Cost: $42.50 or 42” corresponde a “42.50”
✓ JS~ PCRE~ Py✗ Go~ Java✓ .NET
  • JavaScript: Qualquer comprimento (ES2018).
  • PCRE / PHP: Cada alternativa precisa ter comprimento limitado; comprimento variável (máx. 255 por padrão) desde o PCRE2 10.43.
  • Python re: Só largura fixa: (?<=ab|cd) funciona, (?<=a+) é erro.
  • Java: Só comprimento limitado: sem * ou + dentro.
  • .NET: Qualquer comprimento.
Teste no testador de regex →
(?<! … )Lookbehind negativo#

Não precedido de ….

/(?<!\$)\b\d+\b/g em “$30 and 45” corresponde a “45”
✓ JS~ PCRE~ Py✗ Go~ Java✓ .NET
  • PCRE / PHP: Mesmas regras de comprimento do lookbehind positivo.
  • Python re: Só largura fixa.
  • Java: Só comprimento limitado.
Teste no testador de regex →
\KRedefinir o início da correspondência#

Descarta do resultado tudo o que foi encontrado até ali; um lookbehind sem limite de comprimento.

Sintaxe (fora do JavaScript): price: \K\d+
✗ JS✓ PCRE✗ Py✗ Go✗ Java✗ .NET
  • JavaScript: Use (?<=…) ou um grupo de captura.

Flags (modificadores)

O JavaScript escreve as flags depois da barra de fechamento (/x/gi). Outras linguagens passam constantes (re.I, Pattern.CASE_INSENSITIVE, RegexOptions.IgnoreCase) ou usam (?i) inline.

gGlobal (todas as correspondências)#

Encontra todas as correspondências em vez de parar na primeira. Exigida por matchAll e replaceAll.

/o/g em “foo boo” corresponde a “o” “o” “o” “o”
✓ JS~ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: Sem flag: use preg_match_all() / preg_replace().
  • Python re: Sem flag: use re.findall(), re.finditer(), re.sub().
  • Go RE2: Sem flag: use os métodos FindAll….
  • Java: Sem flag: faça um loop com matcher.find().
  • .NET: Sem flag: use Regex.Matches().
Teste no testador de regex →
iIgnorar maiúsculas/minúsculas#

Busca sem diferenciar maiúsculas de minúsculas.

/hello/gi em “Hello HELLO hello” corresponde a “Hello” “HELLO” “hello”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: re.I / re.IGNORECASE ou (?i).
  • Java: CASE_INSENSITIVE (ASCII, a menos que UNICODE_CASE) ou (?i).
  • .NET: RegexOptions.IgnoreCase ou (?i).
Teste no testador de regex →
mMultilinha#

^ e $ correspondem ao início e ao fim de cada linha, não só às pontas da entrada.

/^-\s.+$/gm em “- one↵- two↵three” corresponde a “- one” “- two”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: re.M / re.MULTILINE.
  • .NET: RegexOptions.Multiline.
Teste no testador de regex →
sPonto inclui nova linha#

Faz o . corresponder também a quebras de linha. Sem ela, [\s\S] é o "qualquer coisa" portável.

/<p>.*?</p>/gs em “<p>a↵b</p>” corresponde a “<p>a↵b</p>”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
  • Python re: re.S / re.DOTALL.
  • Java: Pattern.DOTALL.
  • .NET: Chamada de RegexOptions.Singleline.
Teste no testador de regex →
xEstendida (espaçamento livre)#

Espaços em branco no padrão são ignorados e # inicia um comentário, então padrões longos podem ser distribuídos em várias linhas.

Sintaxe (fora do JavaScript): (?x) \d{3} - \d{4} # local number
✗ JS✓ PCRE✓ Py✗ Go✓ Java✓ .NET
  • Python re: re.X / re.VERBOSE.
  • Java: Pattern.COMMENTS.
  • .NET: RegexOptions.IgnorePatternWhitespace.
uUnicode#

Trata a entrada como code points (então . corresponde a um emoji inteiro), habilita \p{…} e \u{…} e transforma escapes inválidos em erros.

/^.$/gu em “😀” corresponde a “😀”
✓ JS~ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: Modificador u do PHP (modo UTF-8); adicione (*UCP) para \w e \d Unicode.
  • Python re: Nenhuma flag necessária: padrões str são Unicode; re.ASCII desativa.
  • Go RE2: Sem flag: o Go sempre trabalha com code points UTF-8.
  • Java: UNICODE_CASE e UNICODE_CHARACTER_CLASS (U).
  • .NET: Sem flag: sempre unidades de código UTF-16 (um emoji são duas).
Teste no testador de regex →
vConjuntos Unicode#

Evolução do u no ES2024: operações de conjunto em classes (--, &&), classes aninhadas e propriedades de strings como \p{RGI_Emoji}. Não pode ser combinada com u.

/[\p{L}&&\p{ASCII}]+/gv em “Ünïcode text” corresponde a “n” “code” “text”
✓ JS✗ PCRE✗ Py✗ Go✗ Java✗ .NET
Teste no testador de regex →
ySticky#

Cada correspondência precisa começar exatamente onde a anterior terminou (lastIndex). Útil para tokenizadores.

/\d/gy em “12a3” corresponde a “1” “2”
✓ JS~ PCRE~ Py✗ Go~ Java~ .NET
  • PCRE / PHP: Use \G.
  • Python re: Use pattern.match(text, pos).
  • Java: Use \G ou matcher.lookingAt().
  • .NET: Use \G.
Teste no testador de regex →
dÍndices das correspondências#

Adiciona match.indices com o início e o fim de cada grupo de captura (ES2022).

Sintaxe (fora do JavaScript): /(?<y>\d{4})/d
✓ JS~ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: Posições sempre disponíveis (PREG_OFFSET_CAPTURE).
  • Python re: Sempre disponível: m.span(n).
  • Go RE2: Sempre disponível: FindStringSubmatchIndex.
  • Java: Sempre disponível: matcher.start(n) / end(n).
  • .NET: Sempre disponível: Group.Index / Length.

Propriedades Unicode \p{…}

Os escapes de propriedade encontram caracteres pela categoria ou pelo sistema de escrita Unicode, a única forma confiável de corresponder a "qualquer letra" em vários idiomas. Em JavaScript, exigem a flag u ou v.

\p{L}Qualquer letra#

Letras de todos os sistemas de escrita: é, ß, 東, д.

/\p{L}+/gu em “naïve café 東京 123” corresponde a “naïve” “café” “東京”
✓ JS✓ PCRE✗ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: O PHP precisa do modificador u para entrada UTF-8.
  • Python re: Use o módulo de terceiros regex, ou [^\W\d_] para "letras".
Teste no testador de regex →
\p{Lu} \p{Ll}Letra maiúscula / minúscula#

Categorias gerais: Lu maiúscula, Ll minúscula, N número, P pontuação, S símbolo, Z separador.

/\p{Lu}/gu em “Élan Vital” corresponde a “É” “V”
✓ JS✓ PCRE✗ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
\P{…}Fora da propriedade#

P maiúsculo nega: \P{L} é qualquer coisa que não seja letra.

/\P{L}+/gu em “abc-123” corresponde a “-123”
✓ JS✓ PCRE✗ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
\pLAbreviação de uma letra#

Categorias de uma letra só, sem chaves.

Sintaxe (fora do JavaScript): \pL+
✗ JS✓ PCRE✗ Py✓ Go✓ Java✗ .NET
  • JavaScript: As chaves são obrigatórias: \p{L}.
  • .NET: As chaves são obrigatórias: \p{L}.
\p{Script=Greek}Sistema de escrita#

Caracteres de um sistema de escrita. sc= é a forma curta; Script_Extensions (scx=) também inclui caracteres compartilhados entre sistemas.

/\p{Script=Greek}+/gu em “alpha α, beta β” corresponde a “α” “β”
✓ JS~ PCRE✗ Py~ Go✓ Java✗ .NET
  • PCRE / PHP: \p{Greek}, \p{sc:Greek} ou \p{scx:Greek}.
  • Go RE2: \p{Greek}.
  • Java: Escreva \p{script=Greek}, \p{sc=Greek} ou \p{IsGreek}.
  • .NET: Só blocos nomeados como \p{IsGreek} (um intervalo de códigos, não o sistema de escrita).
Teste no testador de regex →
\p{sc=Han}Ideogramas chineses / kanji japonês#

Ideogramas Han. Para os kana japoneses, adicione \p{sc=Hiragana} e \p{sc=Katakana}.

/\p{sc=Han}+/gu em “Tokyo 東京 2026 中文” corresponde a “東京” “中文”
✓ JS~ PCRE✗ Py~ Go✓ Java~ .NET
  • PCRE / PHP: \p{Han}.
  • Python re: Use um intervalo como [\u4e00-\u9fff] (cobre só o bloco principal).
  • Go RE2: \p{Han}.
  • Java: Também \p{IsHan}.
  • .NET: Só blocos, ex.: \p{IsCJKUnifiedIdeographs}.
Teste no testador de regex →
\p{RGI_Emoji}Emoji (sequências inteiras)#

Com a flag v, corresponde a emojis completos, incluindo tons de pele e sequências de família. Com u, \p{Extended_Pictographic} corresponde só a pictogramas isolados.

/\p{RGI_Emoji}/gv em “Go 👍🏽 team 👨‍👩‍👧!” corresponde a “👍🏽” “👨‍👩‍👧”
✓ JS~ PCRE✗ Py✗ Go~ Java✗ .NET
  • PCRE / PHP: Code points isolados via propriedades booleanas no PCRE2 recente (10.40+); sem propriedade de sequência.
  • Java: \p{IsEmoji} corresponde a code points isolados (Java 21+).
Teste no testador de regex →
\XCluster de grafemas#

Um caractere como o usuário o percebe, ex.: e + acento combinante, ou um emoji de bandeira.

Sintaxe (fora do JavaScript): \X
✗ JS✓ PCRE✗ Py✗ Go✓ Java✗ .NET
  • JavaScript: Use Intl.Segmenter para dividir em grafemas.
  • Python re: Disponível no módulo regex.

Sintaxe de substituição

O que digitar na string de substituição. É onde as linguagens mais diferem, então a coluna da sua linguagem importa mais que o exemplo em JavaScript.

$&Correspondência inteira#

Insere todo o texto encontrado.

/\d+/g em “3 apples, 12 pears” substituir por “[$&]” → “[3] apples, [12] pears”
✓ JS~ PCRE~ Py~ Go~ Java✓ .NET
  • PCRE / PHP: $0 ou \0 no preg_replace.
  • Python re: \g<0>.
  • Go RE2: ${0} ou $0 (Expand / ReplaceAllString).
  • Java: $0.
  • .NET: Também $0.
Teste no testador de regex →
$1Grupo numerado#

Insere o que o grupo 1 capturou. Trocar duas palavras de lugar:

/(\w+)\s(\w+)/g em “hello world” substituir por “$2 $1” → “world hello”
✓ JS✓ PCRE~ Py✓ Go✓ Java✓ .NET
  • PCRE / PHP: Também \1 e ${1}.
  • Python re: \1 ou \g<1> (use uma raw string r"\1").
  • Go RE2: Use ${1}x quando vier uma letra ou dígito em seguida, senão o Go lê $1x como um grupo chamado "1x".
Teste no testador de regex →
$<name>Grupo nomeado#

Insere um grupo nomeado. Reformatar uma data ISO como dia/mês/ano:

/(?<y>\d{4})-(?<m>\d{2})-(?<d>\d{2})/g em “2026-10-18” substituir por “$<d>/$<m>/$<y>” → “18/10/2026”
✓ JS✗ PCRE~ Py~ Go~ Java~ .NET
  • PCRE / PHP: O preg_replace não tem referências por nome; use o número do grupo ou preg_replace_callback().
  • Python re: \g<name>.
  • Go RE2: ${name} (ou $name).
  • Java: ${name}.
  • .NET: ${name}.
Teste no testador de regex →
$$Cifrão literal#

Escapa o $ na substituição.

/(\d+)/g em “Price: 20” substituir por “$$$1” → “Price: $20”
✓ JS~ PCRE~ Py✓ Go~ Java✓ .NET
  • PCRE / PHP: Um $ que não é seguido de dígito ou { já é literal; escreva ${1} depois dele.
  • Python re: $ não é especial; escape barras invertidas como \\.
  • Java: \$ (Matcher.quoteReplacement() escapa uma string inteira).
Teste no testador de regex →
$` $'Texto antes / depois da correspondência#

Insere a parte da entrada antes ou depois da correspondência. Raramente necessário, mas às vezes útil.

/=/ em “key=value” substituir por “ is set ($') and was ($`) ” → “key is set (value) and was (key) value”
✓ JS✗ PCRE✗ Py✗ Go✗ Java✓ .NET
Teste no testador de regex →

Receitas comuns (com ressalvas honestas)

Os padrões mais procurados, escritos para serem legíveis e livres de backtracking catastrófico. Cada um diz o que não faz.

Email (practical)Encontrar textos com cara de e-mail#

Parte local, @ e um domínio com pelo menos um ponto.

/[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g em “Write to ana.lee+news@example.co.uk or bob@test.dev.” corresponde a “ana.lee+news@example.co.uk” “bob@test.dev”

Ressalva: Rejeita endereços válidos mas raros (partes locais entre aspas, domínios não ASCII) e aceita alguns inválidos (a..b@x.y). Nenhuma regex consegue dizer se uma caixa de e-mail existe: envie um e-mail de confirmação.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
URLEncontrar links http(s) em um texto#

Para em espaços em branco, aspas e sinais de menor/maior, e descarta a pontuação final, como ponto ou vírgula.

/https?://[^\s<>"]*[^\s<>".,;:!?)]/g em “See https://example.com/a?b=1, or (http://test.dev/x).” corresponde a “https://example.com/a?b=1” “http://test.dev/x”

Ressalva: Bom para transformar texto em links, não para validar. Para conferir um URL, use o parser de URL da sua linguagem (new URL() em JavaScript) e teste o protocolo e o host.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
IPv4 addressQuatro octetos 0–255#

Cada octeto limitado a 0–255, sem zeros à esquerda.

/\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 em “10.0.0.1 256.1.1.1 192.168.1.254” corresponde a “10.0.0.1” “192.168.1.254”

Ressalva: Não trata IPv6, sufixos CIDR nem portas. Para validar, use um parser de IP (ipaddress do Python, net/netip do Go, net.isIP do Node).

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Date YYYY-MM-DDData de calendário ISO 8601#

Mês 01–12 e dia 01–31.

/\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b/g em “2026-10-18, 2026-13-01, 2026-02-31” corresponde a “2026-10-18” “2026-02-31”

Ressalva: Só o formato: 2026-02-31 passa. Interprete a data com uma biblioteca de datas para rejeitar dias impossíveis.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Date MM/DD/YYYYData no formato americano#

Mês e dia com um ou dois dígitos, ano com quatro dígitos.

/\b(?:0?[1-9]|1[0-2])/(?:0?[1-9]|[12]\d|3[01])/\d{4}\b/g em “Due 10/18/2026 or 1/5/2027, not 13/01/2026” corresponde a “10/18/2026” “1/5/2027”

Ressalva: 01/02/2026 é 2 de janeiro nos EUA e 1º de fevereiro em quase todo o resto do mundo; uma regex não tem como saber qual era a intenção.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Phone (North America)(416) 555-0199 e variações#

Dez dígitos com parênteses, espaços, pontos ou hifens opcionais.

/\(?\b\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}\b/g em “(416) 555-0199, 416.555.0199, 4165550199” corresponde a “(416) 555-0199” “416.555.0199” “4165550199”

Ressalva: Só números da América do Norte. Para números internacionais, use uma biblioteca como a libphonenumber; armazene os números no formato E.164 (próxima linha).

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Phone (E.164)Formato internacional +CC…#

Um sinal de mais, um código de país que não começa com 0, até 15 dígitos no total.

/^\+[1-9]\d{1,14}$/gm em “+14165550199↵+447911123456↵0044791112” corresponde a “+14165550199” “+447911123456”

Ressalva: Verifica o formato E.164, não se o número está atribuído ou se tem o comprimento certo para o país.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Hex colour#rgb, #rgba, #rrggbb, #rrggbbaa#

Os quatro comprimentos que o CSS aceita.

/#(?:[\da-fA-F]{8}|[\da-fA-F]{6}|[\da-fA-F]{3,4})\b/g em “#fff #244b3f #12345 #ff000080 #1234567” corresponde a “#fff” “#244b3f” “#ff000080”

Ressalva: Também encontra correspondências dentro de textos maiores, como URLs com #fragmentos; use ^…$ para validar um único valor.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
URL slugpalavras-minusculas-com-hifens#

Letras minúsculas e dígitos separados por um único hífen.

/^[a-z0-9]+(?:-[a-z0-9]+)*$/gm em “my-post-2026↵My Post↵-bad-↵good” corresponde a “my-post-2026” “good”

Ressalva: Só ASCII. Para criar slugs a partir de títulos, use o gerador de slug de URL em vez de uma regex.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Trim whitespaceEspaços no início e no fim#

Substitua por uma string vazia. Sem a flag m, ^ e $ são as pontas do texto inteiro.

/^\s+|\s+$/g em “ padded text ” substituir por “” → “padded text”

Ressalva: Toda linguagem moderna tem um trim() nativo, mais rápido e mais claro; use a regex só onde não dá para chamar código (editores, arquivos de configuração).

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Collapse spacesVários espaços viram um#

Substitua dois ou mais espaços ou tabulações por um único espaço.

/[ \t]{2,}/g em “too many ⇥ spaces” substituir por “ ” → “too many spaces”
✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Duplicate wordspalavras repetidas: de de, o o#

Uma palavra seguida dela mesma. Com i, "O o" também é encontrado.

/\b(\w+)\s+\1\b/gi em “This is is a test test of The the editor” corresponde a “is is” “test test” “The the”

Ressalva: Precisa de retrorreferências, então não funciona em Go. Em inglês, "had had" e "that that" às vezes estão corretos.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Password rulesMinúscula, maiúscula, dígito, 12+ caracteres#

Cada lookahead verifica uma regra a partir do início; .{12,} define o comprimento.

/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d).{12,}$/gm em “short1A↵alllowercase123↵GoodPassword42” corresponde a “GoodPassword42”

Ressalva: O NIST SP 800-63B desaconselha regras de composição: exija comprimento e verifique contra listas de senhas vazadas.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
UUID8-4-4-4-12 hexadecimal#

Versões 1–8 com os bits de variante da 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 em “id 3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b and 00000000-0000-0000-0000-000000000000” corresponde a “3f2b8c1e-9d4a-4b7e-8f6a-1c2d3e4f5a6b”

Ressalva: Rejeita o UUID nulo (só zeros) e o UUID máximo (só f), que são valores especiais válidos.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →
Strip HTML tagsRemover <tags>#

Substitua por uma string vazia para obter um texto simples aproximado.

/<[^>]+>/g em “<p>Hello <b>world</b></p>” substituir por “” → “Hello world”

Ressalva: Falha com > dentro de atributos, comentários e scripts, e não decodifica entidades como &amp;. Nunca use para sanitizar HTML não confiável; use DOMParser ou um sanitizador como o DOMPurify.

✓ JS✓ PCRE✓ Py✓ Go✓ Java✓ .NET
Teste no testador de regex →

Uma referência estática: a busca e os filtros funcionam no seu navegador, e os links “Teste” abrem nosso testador de regex no navegador. Ver todas as ferramentas grátis.

Encontrou um problema ou algo que poderia ser melhor? Lemos todas as mensagens e corrigimos rápido.

Este guia rápido de regex lista todos os tokens de expressões regulares de que você provavelmente vai precisar, de \d e \b a lookbehind, quantificadores possessivos e \p{Script=Greek}, cada um com uma explicação curta e um exemplo que mostra exatamente o que ele encontra. Todo exemplo tem um link “Teste no testador de regex” que abre o nosso testador de regex com o padrão, as flags e o texto de exemplo já preenchidos, para você alterar e ver as correspondências mudarem.

Regex parece igual em todo lugar, mas não é. O lookbehind é ilimitado em JavaScript e .NET, de largura fixa em Python, limitado em Java e PCRE e inexistente em Go. Python escreve grupos nomeados como (?P<name>…), PHP não aceita nomes em uma substituição, e só alguns motores conhecem \A, \K ou (?R). O seletor de variante mostra o suporte de cada token em JavaScript, PCRE/PHP, Python, Go, Java e .NET, com a sintaxe alternativa quando ela existe. Os exemplos rodam em JavaScript; para as outras linguagens, leia as observações e teste na própria linguagem antes de colocar em produção.

Como usar

  1. Pesquise um token (\b, lookahead) ou uma tarefa (e-mail, trim, palavras repetidas), ou pule para uma seção pelos chips no topo.
  2. Escolha a sua linguagem na barra de variantes. Os tokens que ela não suporta ficam esmaecidos, e a observação abaixo de cada item mostra a sintaxe que a sua linguagem usa no lugar.
  3. Clique em Teste no testador de regex para rodar o exemplo ao vivo e depois edite o padrão ou o texto lá.
  4. Use o # ao lado de um item para criar um link direto para ele, ou Imprimir / Salvar como PDF para uma cópia compacta em duas colunas.

Perguntas frequentes

Qual a diferença entre quantificadores gulosos e preguiçosos?

Um quantificador guloso (*, +, {n,m}) pega o máximo de caracteres possível e depois devolve alguns se o resto do padrão falhar; um preguiçoso (*?, +?, {n,m}?) pega o mínimo possível. Em <b>bold</b>, <.+> encontra a string inteira, enquanto <.+?> encontra <b> e </b> separadamente. Quantificadores possessivos (*+, ++) são gulosos e nunca devolvem caracteres; JavaScript, Go e .NET não os têm.

Quais linguagens suportam lookbehind?

JavaScript (desde o ES2018) e .NET permitem lookbehind de qualquer comprimento. Java exige um comprimento máximo limitado, então nada de * ou + dentro dele. O módulo re do Python aceita apenas lookbehind de largura fixa. O PCRE2 exigia que cada alternativa tivesse comprimento fixo até a versão 10.43, que acrescentou lookbehind de comprimento variável até um limite (255 caracteres por padrão). O motor RE2 do Go não tem lookahead nem lookbehind.

Como encontro qualquer letra, inclusive acentuadas e não latinas?

Use a propriedade Unicode \p{L}. Em JavaScript ela exige a flag u ou v (/\p{L}+/u); PCRE, Go, Java e .NET a suportam diretamente. [a-zA-Z] deixa de fora é, ß e todos os alfabetos não latinos, e \w só aceita ASCII em JavaScript e Go. O re nativo do Python não tem \p{…}; use o módulo de terceiros regex, ou [^\W\d_], que no Python 3 encontra letras Unicode.

Como uso um grupo capturado na substituição?

Depende da linguagem: $1 em JavaScript, Java, .NET, Go e PHP; \1 ou \g<1> em Python. Grupos nomeados são $<name> em JavaScript, ${name} em Java, .NET e Go, e \g<name> em Python; o preg_replace do PHP não tem forma nomeada, então use o número. A correspondência inteira é $& em JavaScript e .NET, $0 em Java e PHP, e \g<0> em Python.

Por que minha regex funciona em JavaScript mas não em Python (ou vice-versa)?

Os culpados de sempre: grupos nomeados ((?<name>) em JavaScript, (?P<name>) em Python), propriedades \p{…} (JavaScript sim, re do Python não), comprimento do lookbehind (qualquer um em JavaScript, fixo em Python), flags inline ((?i) no início funciona em Python, mas é erro em JavaScript, que só tem a forma com escopo (?i:…)) e \d ou \w encontrando dígitos e letras Unicode em Python, mas só ASCII em JavaScript. Lembre-se também do escape de strings em Python: escreva os padrões como raw strings, r"\d+".

É seguro validar endereços de e-mail com regex?

Só como verificação de formato. Um padrão prático como [\w.+-]+@[\w-]+(?:\.[\w-]+)+ pega erros de digitação, mas rejeita alguns endereços válidos (partes locais entre aspas, domínios internacionalizados) e aceita alguns inválidos. Nenhum padrão consegue dizer se uma caixa de e-mail existe, então verifique o formato de forma flexível e depois envie um e-mail de confirmação.

Escrevendo padrões que funcionam em mais de uma linguagem

Se um padrão precisa rodar em vários motores (uma regra de validação compartilhada, um arquivo de configuração lido por serviços em linguagens diferentes), fique dentro do subconjunto comum. Estes se comportam igual nos seis motores desta página:

• Caracteres literais, escapes como \. e \$, e as classes [abc], [^abc] e [a-z].

• \d, \s e \w, desde que a entrada seja ASCII (Python e .NET também encontram dígitos e letras Unicode).

• ^ e $, \b, alternância, grupos de captura e de não captura.

• Quantificadores gulosos e preguiçosos: *, +, ?, {n}, {n,m} e suas formas com ?.

Deixe de fora lookaround (o Go não tem), retrorreferências (Go), quantificadores possessivos e grupos atômicos (JavaScript, Go e .NET não têm um ou outro), grupos nomeados (a sintaxe do Python é diferente) e \p{…} (o re do Python não tem). Quando precisar de algum deles, mantenha uma cópia do padrão por linguagem e teste cada uma.

Como evitar o backtracking catastrófico

Motores com backtracking (JavaScript, PCRE, Python, Java, .NET) podem levar tempo exponencial em padrões nos quais um grupo quantificado consegue encontrar o mesmo texto de muitas formas, como (a+)+$ ou (\w|\d)*x. Em uma entrada longa que quase corresponde, o motor tenta todas as divisões antes de falhar, e um servidor web pode travar com uma única requisição. Esse é o problema de negação de serviço por expressão regular (ReDoS).

As correções são mecânicas: evite aninhar quantificadores sobre os mesmos caracteres; torne as alternativas mutuamente exclusivas; prefira uma classe negada como [^"]* a .*? quando conhecer o delimitador; use quantificadores possessivos ou grupos atômicos quando o seu motor os tiver; e limite o tamanho da entrada antes de testar. O .NET também oferece RegexOptions.NonBacktracking e um tempo limite de correspondência, o PCRE tem limites de correspondência configuráveis, e o motor RE2 do Go garante tempo linear por não suportar os recursos que exigem backtracking.

Escapando regex dentro de strings

A maioria dos bugs de regex em código real são bugs de escape de string, não de regex. A barra invertida é especial tanto para o literal de string da linguagem quanto para o motor de regex, então um padrão escrito como string normal precisa de barras invertidas duplas.

• JavaScript: um literal /\d+/ precisa de uma barra invertida; new RegExp("\\d+") precisa de duas. String.raw`\d+` evita a duplicação.

• Python: use sempre raw strings, r"\d+"; caso contrário, "\b" é um caractere de backspace, não um limite de palavra.

• Java e C#: "\\d+" em strings comuns (os text blocks do Java também processam escapes); as strings verbatim do C#, @"\d+", mantêm as barras invertidas como digitadas.

• Go: raw strings com crase, `\d+`, são o padrão com regexp.MustCompile.

• PHP: os padrões incluem delimitadores, '/\d+/', e strings entre aspas simples mantêm a maioria das barras invertidas como digitadas.

Ferramentas grátis relacionadas

  • Testador de regex — Teste uma expressão regular num texto de exemplo, com destaque das correspondências ao vivo, grupos de captura e prévia de substituição. Grátis, no navegador.
  • Guia rápido de Git — Comandos do Git organizados pelo que você quer fazer: desfazer o último commit, renomear uma branch, apagar uma branch remota. switch/restore modernos com os equivalentes clássicos e alertas de perigo.
  • Guia rápido de Markdown — Todos os elementos do Markdown com código e prévia renderizada, sintaxe estendida (tabelas, listas de tarefas, notas de rodapé, matemática, Mermaid, alertas), uma tabela de compatibilidade com 9 plataformas e um playground ao vivo.
  • Gerador de expressões cron — Monte um agendamento cron com menus ou cole um pronto, leia-o em português e veja as próximas 10 execuções no seu fuso e em UTC. Grátis, no navegador.
  • Comparador de textos — Compare duas versões de um texto, código ou arquivo JSON e veja exatamente quais linhas, palavras e caracteres mudaram.