O que é uma expressão regular

Uma expressão regular (regular expression, ou regex) é uma forma compacta e formal de descrever um padrão de texto. Em vez de procurar uma palavra exata, você descreve a forma do que procura, por exemplo “dois dígitos, uma barra, dois dígitos, outra barra e quatro dígitos”, e o programa encontra tudo o que se encaixa. ^{[1] [3]}

A ideia vem da teoria da computação: o matemático Stephen Kleene formalizou as “linguagens regulares” nos anos 1950, e Ken Thompson levou a notação para o editor de texto QED em 1968 e, depois, para ferramentas do Unix como o grep. Hoje quase toda linguagem de programação tem um motor de regex. ^{[5] [6]}

Usos típicos:

• busca: encontrar todas as datas de um documento;
• substituição: trocar dd/mm/aaaa por aaaa-mm-dd;
• validação: conferir se um CEP ou um horário tem o formato certo;
• extração e filtragem: tirar de um log só as linhas com erro.

Existem vários “sabores” (flavors) de regex, e eles não são idênticos. Os exemplos deste tutorial usam a sintaxe do JavaScript e foram testados no Node.js 22; quando um recurso só existe em outros motores, como PCRE (PHP), .NET ou Python, isso está indicado. ^{[2] [7] [8]}

Anatomia de um padrão

O padrão (pattern) é a sequência de caracteres que forma a expressão. Em JavaScript ele fica entre barras, e as flags vêm depois da barra final: /padrão/flags. A maioria dos caracteres casa com ele mesmo; alguns, os metacaracteres, têm significado especial.

padrão:  /a/
texto:   A casa está limpa.
casa:       ^

padrão:  /celular/
texto:   O celular está tocando.
casa:      ^^^^^^^

No primeiro exemplo, o A maiúsculo não casa, porque a busca diferencia maiúsculas de minúsculas, e sem a flag g só a primeira ocorrência é devolvida. A figura mostra um padrão completo, peça por peça.

Flags

As flags mudam o comportamento do motor para o padrão inteiro. Estas são as do JavaScript: ^[4]

Duas correções em relação ao texto original: ^[1]

• A flag s não quer dizer “linha única” no sentido de desligar o modo multilinha: ela faz o ponto aceitar \n. O nome “single line” vem do Perl e confunde muita gente. ^[3]
• A flag x (extended) existe em PCRE, Perl, .NET e Python (re.X): ela ignora espaços no padrão e permite comentários com #. O JavaScript não tem essa flag e dá erro ao recebê-la. ^{[7] [8]}

Alternância e conjuntos

Ou: |

A barra vertical separa alternativas: o motor aceita o que estiver à esquerda ou à direita.

padrão:  /ver|distrai/gi
texto:   Ver a linha do horizonte me distrai
casa:    ^^^                         ^^^^^^^

padrão:  /20|nove/gi
texto:   Perdi 20 em 20 e nove amizades
casa:          ^^    ^^   ^^^^

Conjunto: [ ]

Os colchetes definem uma classe de caracteres: uma única posição que aceita qualquer um dos caracteres listados. /[em²]/gi e /e|m|²/gi dão o mesmo resultado em E = mc², mas o conjunto é mais curto e mais rápido.

Intervalos: [a-z]

Dentro de um conjunto, o hífen indica um intervalo na ordem da tabela Unicode: [a-z], [A-Z], [0-9]. Por isso [a-Z] e [4-1] são erros: o início vem depois do fim na tabela.

padrão:  /[a-z]/g
texto:   João de Santo Cristo
casa:     ^ ^ ^^  ^^^^  ^^^^^

padrão:  /[0-9.,]/g
texto:   Um ps4 custa R$ 1.600,00
casa:         ^          ^^^^^^^^

No original, estes dois padrões aparecem sem a flag g, mas com todas as ocorrências marcadas; sem g, só a primeira seria encontrada (o o de “João” e o 4 de “ps4”). Repare também que o ã não casa com [a-z]: letras acentuadas estão fora desse intervalo.

Para aceitar letras acentuadas, o original sugere [À-ü]. Funciona para o português, mas o intervalo de U+00C0 a U+00FC também inclui os sinais × e ÷. Com a flag u, a forma robusta é \p{L}, “qualquer letra de qualquer alfabeto”. ^{[19] [3]}

Negação: [^ ]

Um ^ logo depois do [ inverte o conjunto: casa com tudo o que não está listado.

padrão:  /[^aeiouí]/gi
texto:   Paralelepípedo
casa:    ^ ^ ^ ^ ^ ^ ^

Metacaracteres e escape

Os metacaracteres são . ^ $ * + ? ( ) [ ] { } | \ /. Para usar qualquer um deles como caractere comum, coloque uma barra invertida antes: \. casa com um ponto, \/ com uma barra. ^[3]

padrão:  /cas./gi
texto:   Casa, caso, case
casa:    ^^^^  ^^^^  ^^^^

padrão:  /[a\-o]/gi     // a, hífen ou o; não o intervalo de a até o
texto:   cachorro-quente.
casa:     ^  ^  ^^

Quantificadores

Um quantificador diz quantas vezes o elemento anterior pode se repetir.

O quantificador guloso pega o máximo que consegue e só devolve caracteres se o resto do padrão precisar. O preguiçoso, com um ? no fim, faz o contrário: pega o mínimo e só avança se precisar. ^{[3] [15]}

Âncoras

Âncoras não casam com caracteres, e sim com posições. Elas servem para exigir que o padrão esteja num certo lugar. ^[3]

Em validações, use ^ e $ juntos: sem eles, /\d{5}-\d{3}/ aceitaria “abc90050-170xyz”, porque o CEP aparece dentro do texto.

Atalhos (shorthands)

Os atalhos são abreviações de classes e caracteres comuns. A tabela do original foi tirada da referência do .NET; a coluna “JS” diz se o atalho também funciona no JavaScript. ^{[2] [3]}

Grupos e retrovisores

Os parênteses ( ) agrupam parte do padrão. Isso tem três usos: aplicar um quantificador a vários caracteres de uma vez, capturar o trecho para usá-lo depois e criar retrovisores (backreferences), que exigem repetir o que já foi capturado. O original chama esta seção de “Conjunto”, o mesmo nome dos colchetes; o nome certo é grupo. ^[1]

padrão:  /(\d{2})\/?(\d{2})?\/(\d{4})/
texto:   Hoje é dia 20/01/2020
casa:               ^^^^^^^^^^

padrão:  /\d{2}(\/?)\d{2}\1\d{4}/g
texto:   20/01/2020 25091991 25-09/2000
casa:    ^^^^^^^^^^ ^^^^^^^^

No segundo exemplo, \1 repete o separador capturado: barra com barra, ou nada com nada. Por isso “25-09/2000” fica de fora. O original escreve \d{2}? no meio; isso não torna os dígitos opcionais, é só a versão preguiçosa de {2}, que continua exigindo dois dígitos, então o ? pode ser removido.

O JavaScript rejeita as quatro últimas sintaxes com o erro “Invalid group”. Também há os lookarounds, que olham para a frente ou para trás sem consumir caracteres: (?=…), (?!…), (?<=…) e (?<!…). Eles funcionam no JavaScript. ^[3]

Classes POSIX

As classes POSIX são nomes para conjuntos comuns e só valem dentro de colchetes: [[:digit:]]. Funcionam em PCRE (PHP), Perl, grep e sed, mas não em JavaScript, .NET ou Python. No JavaScript, [[:alpha:]] nem dá erro: vira um conjunto com os caracteres [ : a l p h, seguido de um ] literal. ^[7]

Exemplos práticos

Os padrões do original, testados e, quando necessário, corrigidos. Em validação, todos levam ^ e $ para exigir o texto inteiro. ^[1]

Data dd/mm/aaaa

^(0[1-9]|[12][0-9]|3[01])[-\/.](0[1-9]|1[0-2])[-\/.]((19|20)\d{2})$

Aceita 25/09/2026 e 31.12.1999 e rejeita 32/01/2020. Mas regex só confere o formato: 31/04/2026 e 29/02/2021, que não existem, também passam. Para validar a data de verdade, converta e confira no código.

Hora hh:mm

^([01]?\d|2[0-3]):([0-5]\d)$

Aceita 7:05 e 23:59 e rejeita 24:00. Sem o $ final, que falta no original, “12:345” também passaria.

Data e hora ISO 8601 (AAAA-MM-DDTHH:MM:SS)

^(?<ano>\d{4})-(?<mes>0[1-9]|1[0-2])-(?<dia>0[1-9]|[12]\d|3[01])T(?<hora>[01]\d|2[0-3]):(?<min>[0-5]\d):(?<seg>[0-5]\d)(?:Z|\.(?<ms>\d{2,3}))$

Duas correções: o original usa 1[1-2] para o mês, o que exclui outubro (o certo é 1[0-2]), e usa um ponto sem escape antes dos milissegundos, que aceitaria qualquer caractere. O formato completo da norma também admite fusos como -03:00. ^[12]

CEP

^\d{2}\.?\d{3}-?\d{3}$

O original aceita “90.050-170” e “90050170”, mas rejeita a forma mais comum, “90050-170”. Com o ponto e o hífen opcionais, as três formas passam.

E-mail

^[^\s@]+@[^\s@]+\.[^\s@]+$

É uma checagem simples de “algo@algo.algo”, e é o bastante para um formulário. A sintaxe completa de endereços (RFC 5322) é tão ampla que nenhuma regex curta a cobre; a única validação real é enviar uma mensagem de confirmação. ^[11]

IPv4

^(?:(?:25[0-5]|2[0-4]\d|1?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|1?\d\d?)$

Correto: aceita 192.168.0.1 e rejeita 256.1.1.1. Repare na alternância que limita cada número a no máximo 255.

URL simples

^([a-z]+):\/\/([^\/:]+)(?::(\d+))?(\/[^?#]*)?$

O padrão original, ^([a-z]+):\/\/([^\/]+)\/?([^:]+):?(\d+)?$, quebra quando não há caminho: em “https://example.com” o host sai “example.co” e o caminho “m”, porque ([^:]+) exige pelo menos um caractere. A versão acima separa esquema, host, porta e caminho.

Nome de arquivo PDF

^[\w-]+\.pdf$

Equivale ao ^(\w*)(-\w*)*\.pdf original, mais curto e sem aceitar um “.pdf” sem nome. Nos dois, “relatório.pdf” é rejeitado por causa do ó; com a flag u, use [\p{L}\d_-].

Separadores e telefones

Os padrões de hífen e telefone do original usam \040 para o espaço, uma forma octal antiga, e o último usa [[:punct:]], que não funciona em JavaScript. Uma versão mais legível para telefones brasileiros com DDD:

^\(?(\d{2})\)?[ .-]?(9?\d{4})[ .-]?(\d{4})$

Aceita “(51) 99999-8888”, “51 3333.4444” e “51999998888”.

Ferramentas

• regex101: testa o padrão em tempo real, explica cada pedaço e permite trocar o sabor (PCRE, JavaScript, Python, .NET, Java). ^[13]
• Regexper: desenha o padrão como um diagrama de trilhos, ótimo para entender expressões longas. ^[14]
• Code Beautify: gera dados aleatórios a partir de uma regex, útil para testes. ^[18]
• RexEgg e o guia de Alexandre Servian: textos para se aprofundar, incluindo técnicas avançadas. ^{[15] [16]}
• Para ir além, o livro de referência sobre o assunto é Mastering Regular Expressions, de Jeffrey Friedl. ^[17]

Revisão rápida

Tente responder antes de abrir cada pergunta.

Referências

1. Giovani Perotto Mesquita, “Regular Expression”, GitHub Gist, texto original deste tutorial, gist.github.com/GiovaniPM/04efc466d19ccc8d112d036c48de4a5c.
2. Microsoft Learn, “Linguagem de expressões regulares – referência rápida”, acesso em 25/09/2026, learn.microsoft.com/pt-br/dotnet/standard/base-types/regular-expression-language-quick-reference.
3. MDN Web Docs, “Expressões regulares”, acesso em 25/09/2026, developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_expressions.
4. MDN Web Docs, “RegExp.prototype.flags”, acesso em 25/09/2026, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags.
5. Wikipedia (em inglês), “Regular expression”, acesso em 25/09/2026, en.wikipedia.org/wiki/Regular_expression.
6. Wikipedia (em inglês), “Stephen Cole Kleene”, acesso em 25/09/2026, en.wikipedia.org/wiki/Stephen_Cole_Kleene.
7. PCRE2, “pcre2pattern”, documentação da sintaxe de padrões, acesso em 25/09/2026, pcre.org/current/doc/html/pcre2pattern.html.
8. Python Software Foundation, “re — Regular expression operations”, acesso em 25/09/2026, docs.python.org/3/library/re.html.
9. Jan Goyvaerts, “Atomic Grouping”, Regular-Expressions.info, acesso em 25/09/2026, regular-expressions.info/atomic.html.
10. Jan Goyvaerts, “Branch Reset Groups”, Regular-Expressions.info, acesso em 25/09/2026, regular-expressions.info/branchreset.html.
11. P. Resnick (ed.), RFC 5322: Internet Message Format, IETF, 2008, acesso em 25/09/2026, rfc-editor.org/rfc/rfc5322.
12. Wikipedia (em inglês), “ISO 8601”, acesso em 25/09/2026, en.wikipedia.org/wiki/ISO_8601.
13. regex101, site oficial, acesso em 25/09/2026, regex101.com.
14. Jeff Avallone, Regexper, site oficial, acesso em 25/09/2026, regexper.com.
15. RexEgg, “Rex Eats Regular Expressions for Breakfast”, acesso em 25/09/2026, rexegg.com.
16. Alexandre Servian, “Regex: um guia prático para expressões regulares”, Medium, acesso em 25/09/2026, medium.com/@alexandreservian/regex-um-guia-pratico-para-expressões-regulares-1ac5fa4dd39f.
17. Jeffrey E. F. Friedl, Mastering Regular Expressions, 3. ed., O’Reilly Media, 2006.
18. Code Beautify, “Generate Random Data from Regular Expression”, acesso em 25/09/2026, codebeautify.org/generate-random-data-from-regexp.
19. Wikipedia (em inglês), “Latin-1 Supplement”, acesso em 25/09/2026, en.wikipedia.org/wiki/Latin-1_Supplement.
20. MDN Web Docs, “Named capturing group”, acesso em 25/09/2026, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Named_capturing_group.

What a regular expression is

A regular expression (regex) is a compact, formal way to describe a text pattern. Instead of searching for an exact word, you describe the shape of what you are looking for, such as “two digits, a slash, two digits, another slash and four digits”, and the program finds everything that fits. ^{[1] [3]}

The idea comes from the theory of computation: mathematician Stephen Kleene formalised “regular languages” in the 1950s, and Ken Thompson brought the notation to the QED text editor in 1968 and later to Unix tools such as grep. Today almost every programming language ships a regex engine. ^{[5] [6]}

Typical uses:

• searching: finding every date in a document;
• replacing: turning dd/mm/yyyy into yyyy-mm-dd;
• validating: checking that a postcode or a time has the right format;
• extracting and filtering: keeping only the error lines of a log.

There are several regex flavours, and they are not identical. The examples in this tutorial use JavaScript syntax and were tested on Node.js 22; when a feature exists only in other engines, such as PCRE (PHP), .NET or Python, the text says so. ^{[2] [7] [8]}

Anatomy of a pattern

The pattern is the sequence of characters that makes up the expression. In JavaScript it sits between slashes, and the flags come after the closing slash: /pattern/flags. Most characters match themselves; a few, the metacharacters, have a special meaning.

pattern: /a/
text:    A casa está limpa.
match:      ^

pattern: /celular/
text:    O celular está tocando.
match:     ^^^^^^^

In the first example the capital A does not match, because the search is case-sensitive, and without the g flag only the first occurrence is returned. The figure breaks a complete pattern into its pieces.

Flags

Flags change how the engine treats the whole pattern. These are JavaScript’s: ^[4]

Two corrections to the original text: ^[1]

• The s flag does not mean “single line” in the sense of switching multiline mode off: it lets the dot accept \n. The name “single line” comes from Perl and confuses many people. ^[3]
• The x (extended) flag exists in PCRE, Perl, .NET and Python (re.X): it ignores whitespace in the pattern and allows # comments. JavaScript does not have it and throws an error if you pass it. ^{[7] [8]}

Alternation and sets

Or: |

The vertical bar separates alternatives: the engine accepts whatever is on the left or on the right.

pattern: /ver|distrai/gi
text:    Ver a linha do horizonte me distrai
match:   ^^^                         ^^^^^^^

pattern: /20|nove/gi
text:    Perdi 20 em 20 e nove amizades
match:         ^^    ^^   ^^^^

Set: [ ]

Square brackets define a character class: a single position that accepts any of the listed characters. /[em²]/gi and /e|m|²/gi give the same result on E = mc², but the set is shorter and faster.

Ranges: [a-z]

Inside a set, a hyphen marks a range in Unicode order: [a-z], [A-Z], [0-9]. That is why [a-Z] and [4-1] are errors: the start comes after the end in the table.

pattern: /[a-z]/g
text:    João de Santo Cristo
match:    ^ ^ ^^  ^^^^  ^^^^^

pattern: /[0-9.,]/g
text:    Um ps4 custa R$ 1.600,00
match:        ^          ^^^^^^^^

In the original these two patterns appear without the g flag, yet with every occurrence marked; without g, only the first would be found (the o in “João” and the 4 in “ps4”). Note also that ã does not match [a-z]: accented letters are outside that range.

To accept accented letters, the original suggests [À-ü]. It works for Portuguese, but the range U+00C0 to U+00FC also contains the signs × and ÷. With the u flag, the robust form is \p{L}, “any letter in any script”. ^{[19] [3]}

Negation: [^ ]

A ^ right after [ inverts the set: it matches anything that is not listed.

pattern: /[^aeiouí]/gi
text:    Paralelepípedo
match:   ^ ^ ^ ^ ^ ^ ^

Metacharacters and escaping

The metacharacters are . ^ $ * + ? ( ) [ ] { } | \ /. To use any of them as an ordinary character, put a backslash before it: \. matches a dot, \/ a slash. ^[3]

pattern: /cas./gi
text:    Casa, caso, case
match:   ^^^^  ^^^^  ^^^^

pattern: /[a\-o]/gi     // a, hyphen or o; not the range a to o
text:    cachorro-quente.
match:    ^  ^  ^^

Quantifiers

A quantifier says how many times the previous element may repeat.

A greedy quantifier takes as much as it can and gives characters back only if the rest of the pattern needs them. A lazy one, with a trailing ?, does the opposite: it takes as little as possible and moves on only when it must. ^{[3] [15]}

Anchors

Anchors do not match characters but positions. They require the pattern to be in a certain place. ^[3]

When validating, use ^ and $ together: without them, /\d{5}-\d{3}/ would accept “abc90050-170xyz”, because the postcode appears inside the text.

Shorthands

Shorthands abbreviate common classes and characters. The original table was taken from the .NET reference; the “JS” column says whether the shorthand also works in JavaScript. ^{[2] [3]}

Groups and backreferences

Parentheses ( ) group part of the pattern. They have three uses: applying a quantifier to several characters at once, capturing the matched text for later use, and creating backreferences, which require repeating what was already captured. The original calls this section “Set” (Conjunto), the same name as the brackets; the right name is group. ^[1]

pattern: /(\d{2})\/?(\d{2})?\/(\d{4})/
text:    Hoje é dia 20/01/2020
match:              ^^^^^^^^^^

pattern: /\d{2}(\/?)\d{2}\1\d{4}/g
text:    20/01/2020 25091991 25-09/2000
match:   ^^^^^^^^^^ ^^^^^^^^

In the second example, \1 repeats the captured separator: slash with slash, or nothing with nothing. That is why “25-09/2000” is left out. The original writes \d{2}? in the middle; that does not make the digits optional, it is just the lazy version of {2}, which still requires two digits, so the ? can be dropped.

JavaScript rejects the last four with an “Invalid group” error. There are also lookarounds, which look ahead or behind without consuming characters: (?=…), (?!…), (?<=…) and (?<!…). These do work in JavaScript. ^[3]

POSIX classes

POSIX classes are names for common sets and are valid only inside brackets: [[:digit:]]. They work in PCRE (PHP), Perl, grep and sed, but not in JavaScript, .NET or Python. In JavaScript, [[:alpha:]] does not even raise an error: it becomes a set of the characters [ : a l p h, followed by a literal ]. ^[7]

Practical examples

The original’s patterns, tested and corrected where needed. For validation, each one uses ^ and $ to require the whole text. ^[1]

Date dd/mm/yyyy

^(0[1-9]|[12][0-9]|3[01])[-\/.](0[1-9]|1[0-2])[-\/.]((19|20)\d{2})$

Accepts 25/09/2026 and 31.12.1999 and rejects 32/01/2020. But a regex checks only the format: 31/04/2026 and 29/02/2021, which do not exist, also pass. To validate a real date, parse it and check it in code.

Time hh:mm

^([01]?\d|2[0-3]):([0-5]\d)$

Accepts 7:05 and 23:59 and rejects 24:00. Without the final $, missing in the original, “12:345” would also pass.

ISO 8601 date and time (YYYY-MM-DDTHH:MM:SS)

^(?<year>\d{4})-(?<month>0[1-9]|1[0-2])-(?<day>0[1-9]|[12]\d|3[01])T(?<hour>[01]\d|2[0-3]):(?<min>[0-5]\d):(?<sec>[0-5]\d)(?:Z|\.(?<ms>\d{2,3}))$

Two corrections: the original uses 1[1-2] for the month, which excludes October (it should be 1[0-2]), and an unescaped dot before the milliseconds, which would accept any character. The full standard also allows offsets such as -03:00. ^[12]

Brazilian postcode (CEP)

^\d{2}\.?\d{3}-?\d{3}$

The original accepts “90.050-170” and “90050170” but rejects the most common form, “90050-170”. With the dot and hyphen optional, all three pass.

Email

^[^\s@]+@[^\s@]+\.[^\s@]+$

This is a simple “something@something.something” check, and that is enough for a form. The full address syntax (RFC 5322) is so broad that no short regex covers it; the only real validation is sending a confirmation message. ^[11]

IPv4

^(?:(?:25[0-5]|2[0-4]\d|1?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|1?\d\d?)$

Correct: accepts 192.168.0.1 and rejects 256.1.1.1. Notice how the alternation caps each number at 255.

Simple URL

^([a-z]+):\/\/([^\/:]+)(?::(\d+))?(\/[^?#]*)?$

The original pattern, ^([a-z]+):\/\/([^\/]+)\/?([^:]+):?(\d+)?$, breaks when there is no path: for “https://example.com” the host comes out as “example.co” and the path as “m”, because ([^:]+) needs at least one character. The version above separates scheme, host, port and path.

PDF file name

^[\w-]+\.pdf$

Equivalent to the original ^(\w*)(-\w*)*\.pdf, shorter and without accepting a bare “.pdf”. Both reject “relatório.pdf” because of the ó; with the u flag, use [\p{L}\d_-].

Separators and phone numbers

The original hyphen and phone patterns use \040 for a space, a legacy octal form, and the last one uses [[:punct:]], which does not work in JavaScript. A more readable version for Brazilian phone numbers with area code:

^\(?(\d{2})\)?[ .-]?(9?\d{4})[ .-]?(\d{4})$

Accepts “(51) 99999-8888”, “51 3333.4444” and “51999998888”.

Tools

• regex101: tests the pattern live, explains each piece and lets you switch flavour (PCRE, JavaScript, Python, .NET, Java). ^[13]
• Regexper: draws the pattern as a railroad diagram, great for understanding long expressions. ^[14]
• Code Beautify: generates random data from a regex, handy for tests. ^[18]
• RexEgg and Alexandre Servian’s guide (in Portuguese): further reading, including advanced techniques. ^{[15] [16]}
• To go further, the standard book on the subject is Jeffrey Friedl’s Mastering Regular Expressions. ^[17]

Quick review

Try to answer before opening each question.

References

1. Giovani Perotto Mesquita, “Regular Expression”, GitHub Gist, original text of this tutorial, gist.github.com/GiovaniPM/04efc466d19ccc8d112d036c48de4a5c.
2. Microsoft Learn, “Regular Expression Language – Quick Reference”, accessed 25 September 2026, learn.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference.
3. MDN Web Docs, “Regular expressions”, accessed 25 September 2026, developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions.
4. MDN Web Docs, “RegExp.prototype.flags”, accessed 25 September 2026, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags.
5. Wikipedia, “Regular expression”, accessed 25 September 2026, en.wikipedia.org/wiki/Regular_expression.
6. Wikipedia, “Stephen Cole Kleene”, accessed 25 September 2026, en.wikipedia.org/wiki/Stephen_Cole_Kleene.
7. PCRE2, “pcre2pattern”, pattern syntax documentation, accessed 25 September 2026, pcre.org/current/doc/html/pcre2pattern.html.
8. Python Software Foundation, “re — Regular expression operations”, accessed 25 September 2026, docs.python.org/3/library/re.html.
9. Jan Goyvaerts, “Atomic Grouping”, Regular-Expressions.info, accessed 25 September 2026, regular-expressions.info/atomic.html.
10. Jan Goyvaerts, “Branch Reset Groups”, Regular-Expressions.info, accessed 25 September 2026, regular-expressions.info/branchreset.html.
11. P. Resnick (ed.), RFC 5322: Internet Message Format, IETF, 2008, accessed 25 September 2026, rfc-editor.org/rfc/rfc5322.
12. Wikipedia, “ISO 8601”, accessed 25 September 2026, en.wikipedia.org/wiki/ISO_8601.
13. regex101, official website, accessed 25 September 2026, regex101.com.
14. Jeff Avallone, Regexper, official website, accessed 25 September 2026, regexper.com.
15. RexEgg, “Rex Eats Regular Expressions for Breakfast”, accessed 25 September 2026, rexegg.com.
16. Alexandre Servian, “Regex: um guia prático para expressões regulares”, Medium, accessed 25 September 2026, medium.com/@alexandreservian/regex-um-guia-pratico-para-expressões-regulares-1ac5fa4dd39f.
17. Jeffrey E. F. Friedl, Mastering Regular Expressions, 3rd ed., O’Reilly Media, 2006.
18. Code Beautify, “Generate Random Data from Regular Expression”, accessed 25 September 2026, codebeautify.org/generate-random-data-from-regexp.
19. Wikipedia, “Latin-1 Supplement”, accessed 25 September 2026, en.wikipedia.org/wiki/Latin-1_Supplement.
20. MDN Web Docs, “Named capturing group”, accessed 25 September 2026, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Named_capturing_group.

Che cos’è un’espressione regolare

Un’espressione regolare (regular expression, o regex) è un modo compatto e formale di descrivere un modello di testo. Invece di cercare una parola esatta, si descrive la forma di ciò che si cerca, per esempio “due cifre, una barra, due cifre, un’altra barra e quattro cifre”, e il programma trova tutto ciò che corrisponde. ^{[1] [3]}

L’idea nasce dalla teoria della computazione: il matematico Stephen Kleene formalizzò i “linguaggi regolari” negli anni ’50, e Ken Thompson portò la notazione nell’editor di testo QED nel 1968 e poi in strumenti Unix come grep. Oggi quasi ogni linguaggio di programmazione ha un motore regex. ^{[5] [6]}

Usi tipici:

• ricerca: trovare tutte le date in un documento;
• sostituzione: trasformare gg/mm/aaaa in aaaa-mm-gg;
• validazione: verificare che un CAP o un orario abbia il formato giusto;
• estrazione e filtro: tenere da un log solo le righe di errore.

Esistono vari “dialetti” (flavor) di regex, e non sono identici. Gli esempi di questo tutorial usano la sintassi di JavaScript e sono stati verificati con Node.js 22; quando una funzione esiste solo in altri motori, come PCRE (PHP), .NET o Python, il testo lo indica. ^{[2] [7] [8]}

Anatomia di un pattern

Il pattern è la sequenza di caratteri che forma l’espressione. In JavaScript sta tra due barre, e le flag vengono dopo la barra finale: /pattern/flag. La maggior parte dei caratteri corrisponde a se stessa; alcuni, i metacaratteri, hanno un significato speciale.

pattern:  /a/
testo:    A casa está limpa.
trovato:     ^

pattern:  /celular/
testo:    O celular está tocando.
trovato:    ^^^^^^^

Nel primo esempio la A maiuscola non corrisponde, perché la ricerca distingue maiuscole e minuscole, e senza la flag g viene restituita solo la prima occorrenza. La figura scompone un pattern completo, pezzo per pezzo.

Flag

Le flag cambiano il comportamento del motore per l’intero pattern. Queste sono quelle di JavaScript: ^[4]

Due correzioni rispetto al testo originale: ^[1]

• La flag s non significa “riga singola” nel senso di disattivare la modalità multiriga: fa accettare \n al punto. Il nome “single line” viene dal Perl e confonde molte persone. ^[3]
• La flag x (extended) esiste in PCRE, Perl, .NET e Python (re.X): ignora gli spazi nel pattern e permette commenti con #. JavaScript non la prevede e dà errore se la si passa. ^{[7] [8]}

Alternanza e insiemi

Oppure: |

La barra verticale separa le alternative: il motore accetta ciò che sta a sinistra oppure a destra.

pattern:  /ver|distrai/gi
testo:    Ver a linha do horizonte me distrai
trovato:  ^^^                         ^^^^^^^

pattern:  /20|nove/gi
testo:    Perdi 20 em 20 e nove amizades
trovato:        ^^    ^^   ^^^^

Insieme: [ ]

Le parentesi quadre definiscono una classe di caratteri: una sola posizione che accetta uno qualsiasi dei caratteri elencati. /[em²]/gi e /e|m|²/gi danno lo stesso risultato su E = mc², ma l’insieme è più breve e più veloce.

Intervalli: [a-z]

Dentro un insieme, il trattino indica un intervallo nell’ordine della tabella Unicode: [a-z], [A-Z], [0-9]. Per questo [a-Z] e [4-1] sono errori: l’inizio viene dopo la fine nella tabella.

pattern:  /[a-z]/g
testo:    João de Santo Cristo
trovato:   ^ ^ ^^  ^^^^  ^^^^^

pattern:  /[0-9.,]/g
testo:    Um ps4 custa R$ 1.600,00
trovato:       ^          ^^^^^^^^

Nell’originale questi due pattern compaiono senza la flag g, ma con tutte le occorrenze segnate; senza g si troverebbe solo la prima (la o di “João” e il 4 di “ps4”). Notate anche che la ã non corrisponde a [a-z]: le lettere accentate sono fuori da quell’intervallo.

Per accettare le lettere accentate, l’originale suggerisce [À-ü]. Funziona per il portoghese e l’italiano, ma l’intervallo da U+00C0 a U+00FC contiene anche i segni × e ÷. Con la flag u, la forma robusta è \p{L}, “qualsiasi lettera di qualsiasi alfabeto”. ^{[19] [3]}

Negazione: [^ ]

Un ^ subito dopo la [ inverte l’insieme: corrisponde a tutto ciò che non è elencato.

pattern:  /[^aeiouí]/gi
testo:    Paralelepípedo
trovato:  ^ ^ ^ ^ ^ ^ ^

Metacaratteri ed escape

I metacaratteri sono . ^ $ * + ? ( ) [ ] { } | \ /. Per usarne uno come carattere normale, lo si fa precedere da una barra rovesciata: \. corrisponde a un punto, \/ a una barra. ^[3]

pattern:  /cas./gi
testo:    Casa, caso, case
trovato:  ^^^^  ^^^^  ^^^^

pattern:  /[a\-o]/gi     // a, trattino oppure o; non l’intervallo da a a o
testo:    cachorro-quente.
trovato:   ^  ^  ^^

Quantificatori

Un quantificatore dice quante volte l’elemento precedente può ripetersi.

Il quantificatore avido (greedy) prende il massimo possibile e restituisce caratteri solo se il resto del pattern ne ha bisogno. Quello pigro (lazy), con un ? finale, fa il contrario: prende il minimo e avanza solo se necessario. ^{[3] [15]}

Ancore

Le ancore non corrispondono a caratteri ma a posizioni. Servono a imporre che il pattern si trovi in un certo punto. ^[3]

Nelle validazioni usate ^ e $ insieme: senza di loro, /\d{5}/ accetterebbe “abc20121xyz”, perché il CAP compare dentro il testo.

Scorciatoie (shorthand)

Le scorciatoie abbreviano classi e caratteri comuni. La tabella dell’originale viene dal riferimento di .NET; la colonna “JS” indica se la scorciatoia funziona anche in JavaScript. ^{[2] [3]}

Gruppi e backreference

Le parentesi tonde ( ) raggruppano parte del pattern. Servono a tre cose: applicare un quantificatore a più caratteri insieme, catturare il testo trovato per usarlo dopo e creare backreference, che impongono di ripetere ciò che è già stato catturato. L’originale chiama questa sezione “Insieme” (Conjunto), lo stesso nome delle parentesi quadre; il nome giusto è gruppo. ^[1]

pattern:  /(\d{2})\/?(\d{2})?\/(\d{4})/
testo:    Hoje é dia 20/01/2020
trovato:             ^^^^^^^^^^

pattern:  /\d{2}(\/?)\d{2}\1\d{4}/g
testo:    20/01/2020 25091991 25-09/2000
trovato:  ^^^^^^^^^^ ^^^^^^^^

Nel secondo esempio, \1 ripete il separatore catturato: barra con barra, oppure niente con niente. Per questo “25-09/2000” resta fuori. L’originale scrive \d{2}? nel mezzo; questo non rende le cifre facoltative, è solo la versione pigra di {2}, che richiede comunque due cifre, quindi il ? si può togliere.

JavaScript rifiuta le ultime quattro sintassi con l’errore “Invalid group”. Esistono anche i lookaround, che guardano avanti o indietro senza consumare caratteri: (?=…), (?!…), (?<=…) e (?<!…). Questi funzionano in JavaScript. ^[3]

Classi POSIX

Le classi POSIX sono nomi per insiemi comuni e valgono solo dentro le parentesi quadre: [[:digit:]]. Funzionano in PCRE (PHP), Perl, grep e sed, ma non in JavaScript, .NET o Python. In JavaScript, [[:alpha:]] non dà nemmeno errore: diventa un insieme con i caratteri [ : a l p h, seguito da una ] letterale. ^[7]

Esempi pratici

I pattern dell’originale, verificati e, dove serve, corretti. Per la validazione, tutti usano ^ e $ per richiedere l’intero testo. ^[1]

Data gg/mm/aaaa

^(0[1-9]|[12][0-9]|3[01])[-\/.](0[1-9]|1[0-2])[-\/.]((19|20)\d{2})$

Accetta 25/09/2026 e 31.12.1999 e rifiuta 32/01/2020. Ma una regex controlla solo il formato: anche 31/04/2026 e 29/02/2021, che non esistono, passano. Per validare davvero una data, convertitela e controllatela nel codice.

Ora hh:mm

^([01]?\d|2[0-3]):([0-5]\d)$

Accetta 7:05 e 23:59 e rifiuta 24:00. Senza il $ finale, che manca nell’originale, passerebbe anche “12:345”.

Data e ora ISO 8601 (AAAA-MM-GGTHH:MM:SS)

^(?<anno>\d{4})-(?<mese>0[1-9]|1[0-2])-(?<giorno>0[1-9]|[12]\d|3[01])T(?<ora>[01]\d|2[0-3]):(?<min>[0-5]\d):(?<sec>[0-5]\d)(?:Z|\.(?<ms>\d{2,3}))$

Due correzioni: l’originale usa 1[1-2] per il mese, che esclude ottobre (deve essere 1[0-2]), e un punto senza escape prima dei millisecondi, che accetterebbe qualsiasi carattere. Lo standard completo ammette anche fusi orari come +02:00. ^[12]

CEP (codice postale brasiliano)

^\d{2}\.?\d{3}-?\d{3}$

L’originale accetta “90.050-170” e “90050170” ma rifiuta la forma più comune, “90050-170”. Con punto e trattino facoltativi, passano tutte e tre. Per il CAP italiano basta ^\d{5}$.

E-mail

^[^\s@]+@[^\s@]+\.[^\s@]+$

È un controllo semplice di “qualcosa@qualcosa.qualcosa”, sufficiente per un modulo. La sintassi completa degli indirizzi (RFC 5322) è così ampia che nessuna regex breve la copre; l’unica validazione reale è inviare un messaggio di conferma. ^[11]

IPv4

^(?:(?:25[0-5]|2[0-4]\d|1?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|1?\d\d?)$

Corretto: accetta 192.168.0.1 e rifiuta 256.1.1.1. Notate come l’alternanza limita ogni numero a 255.

URL semplice

^([a-z]+):\/\/([^\/:]+)(?::(\d+))?(\/[^?#]*)?$

Il pattern originale, ^([a-z]+):\/\/([^\/]+)\/?([^:]+):?(\d+)?$, si rompe quando manca il percorso: con “https://example.com” l’host risulta “example.co” e il percorso “m”, perché ([^:]+) richiede almeno un carattere. La versione sopra separa schema, host, porta e percorso.

Nome di file PDF

^[\w-]+\.pdf$

Equivale all’originale ^(\w*)(-\w*)*\.pdf, più breve e senza accettare un “.pdf” senza nome. Entrambi rifiutano “relazione-attività.pdf” per via della à; con la flag u, usate [\p{L}\d_-].

Separatori e telefoni

I pattern per trattini e telefoni dell’originale usano \040 per lo spazio, una forma ottale antiquata, e l’ultimo usa [[:punct:]], che in JavaScript non funziona. Una versione più leggibile per i telefoni brasiliani con prefisso:

^\(?(\d{2})\)?[ .-]?(9?\d{4})[ .-]?(\d{4})$

Accetta “(51) 99999-8888”, “51 3333.4444” e “51999998888”.

Strumenti

• regex101: prova il pattern in tempo reale, spiega ogni pezzo e permette di cambiare dialetto (PCRE, JavaScript, Python, .NET, Java). ^[13]
• Regexper: disegna il pattern come diagramma a binari, ottimo per capire espressioni lunghe. ^[14]
• Code Beautify: genera dati casuali a partire da una regex, utile per i test. ^[18]
• RexEgg e la guida di Alexandre Servian (in portoghese): letture per approfondire, comprese tecniche avanzate. ^{[15] [16]}
• Per andare oltre, il libro di riferimento sull’argomento è Mastering Regular Expressions di Jeffrey Friedl. ^[17]

Ripasso veloce

Provate a rispondere prima di aprire ogni domanda.

Riferimenti

1. Giovani Perotto Mesquita, “Regular Expression”, GitHub Gist, testo originale di questo tutorial, gist.github.com/GiovaniPM/04efc466d19ccc8d112d036c48de4a5c.
2. Microsoft Learn, “Linguaggio di espressioni regolari - Riferimento rapido”, consultato il 25/09/2026, learn.microsoft.com/it-it/dotnet/standard/base-types/regular-expression-language-quick-reference.
3. MDN Web Docs, “Espressioni regolari”, consultato il 25/09/2026, developer.mozilla.org/it/docs/Web/JavaScript/Guide/Regular_expressions.
4. MDN Web Docs, “RegExp.prototype.flags”, consultato il 25/09/2026, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/flags.
5. Wikipedia (in inglese), “Regular expression”, consultato il 25/09/2026, en.wikipedia.org/wiki/Regular_expression.
6. Wikipedia (in inglese), “Stephen Cole Kleene”, consultato il 25/09/2026, en.wikipedia.org/wiki/Stephen_Cole_Kleene.
7. PCRE2, “pcre2pattern”, documentazione della sintassi dei pattern, consultato il 25/09/2026, pcre.org/current/doc/html/pcre2pattern.html.
8. Python Software Foundation, “re — Regular expression operations”, consultato il 25/09/2026, docs.python.org/3/library/re.html.
9. Jan Goyvaerts, “Atomic Grouping”, Regular-Expressions.info, consultato il 25/09/2026, regular-expressions.info/atomic.html.
10. Jan Goyvaerts, “Branch Reset Groups”, Regular-Expressions.info, consultato il 25/09/2026, regular-expressions.info/branchreset.html.
11. P. Resnick (ed.), RFC 5322: Internet Message Format, IETF, 2008, consultato il 25/09/2026, rfc-editor.org/rfc/rfc5322.
12. Wikipedia (in inglese), “ISO 8601”, consultato il 25/09/2026, en.wikipedia.org/wiki/ISO_8601.
13. regex101, sito ufficiale, consultato il 25/09/2026, regex101.com.
14. Jeff Avallone, Regexper, sito ufficiale, consultato il 25/09/2026, regexper.com.
15. RexEgg, “Rex Eats Regular Expressions for Breakfast”, consultato il 25/09/2026, rexegg.com.
16. Alexandre Servian, “Regex: um guia prático para expressões regulares”, Medium, consultato il 25/09/2026, medium.com/@alexandreservian/regex-um-guia-pratico-para-expressões-regulares-1ac5fa4dd39f.
17. Jeffrey E. F. Friedl, Mastering Regular Expressions, 3ª ed., O’Reilly Media, 2006.
18. Code Beautify, “Generate Random Data from Regular Expression”, consultato il 25/09/2026, codebeautify.org/generate-random-data-from-regexp.
19. Wikipedia (in inglese), “Latin-1 Supplement”, consultato il 25/09/2026, en.wikipedia.org/wiki/Latin-1_Supplement.
20. MDN Web Docs, “Named capturing group”, consultato il 25/09/2026, developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Regular_expressions/Named_capturing_group.