Ferramenta gratuita

    Expressão regular Testador

    Teste, depure e visualize expressões regulares com correspondência em tempo real.

    Expressão regular

    //g
    Bandeiras:
    Predefinições:

    Texto de teste

    O que são expressões regulares?

    As expressões regulares (regex) são padrões utilizados para identificar combinações de caracteres em cadeias de caracteres. São suportadas em praticamente todas as linguagens de programação e são essenciais para o processamento de texto, a validação de entradas, a pesquisa e substituição e a análise de registos.

    Sinalizadores de expressões regulares em JavaScript

    • g — Global: encontra todas as correspondências, não apenas a primeira
    • i — Sem distinção entre maiúsculas e minúsculas
    • m — Multilinha: ^ e $ correspondem a limites de linha
    • s — Dotall: . corresponde a caracteres de quebra de linha

    Casos de utilização comuns

    • Validação de endereços de e-mail, números de telefone e URLs
    • Extração de dados de ficheiros de log e texto estruturado
    • Procurar e substituir em editores de código e IDEs
    • Construção de máscaras de entrada e validadores de formulários
    • Análise e transformação de dados CSV, JSON e XML

    Quando recorrer às expressões regulares

    As expressões regulares destacam-se em padrões curtos e bem definidos, nos quais é necessário corresponder, extrair ou substituir texto — análise de linhas de registo, regras de encaminhamento de URL, validação de campos de formulário e operações de «procurar e substituir» num editor. Tornam-se, porém, um problema quando a entrada é, na verdade, uma linguagem estruturada: HTML, JSON, código-fonte ou qualquer coisa com delimitadores aninhados. Para esses casos, use um analisador de verdade; a expressão regular que escrever hoje irá falhar silenciosamente no próximo caso extremo.

    Expressão regular Perguntas frequentes

    Respostas rápidas às dúvidas sobre expressões regulares com que se depara quando cria padrões manualmente.

    Que variante de expressões regulares utiliza este verificador?
    Expressões regulares ECMAScript / JavaScript (o motor integrado no seu navegador). Os padrões que funcionam aqui funcionarão em `String.prototype.match`, `RegExp.test` e na maioria dos linters ou extensões de editor modernos baseados em JS. Padrões escritos para PCRE (PHP, Perl), `re` do Python ou `regexp` do Go podem comportar-se de forma diferente — lookbehinds, grupos atómicos e sintaxe de grupos nomeados são pontos de divergência comuns.
    Como faço para que o meu padrão não distinga maiúsculas de minúsculas?
    Ative o sinalizador `i` (sem distinção entre maiúsculas e minúsculas). Isto aplica a conversão de maiúsculas e minúsculas a todo o padrão, pelo que `/Hello/i` corresponde a `hello`, `HELLO` e `HeLLo`. Se pretender que apenas uma parte do padrão não distinga entre maiúsculas e minúsculas, terá de enumerar os caracteres explicitamente — as expressões regulares do JavaScript não suportam modificadores em linha como `(?i:...)`.
    Por que é que a minha expressão regular não faz a correspondência em várias linhas?
    Existem duas opções que afetam o comportamento em várias linhas. A opção `m` (Multiline) altera `^` e `$` para que correspondam aos limites das linhas, em vez de apenas ao início/fim da cadeia de caracteres completa — útil para validação linha a linha. Por outro lado, a opção `s` (dotAll) faz com que `.` corresponda também a novas linhas — sem ela, `.*` pára na primeira `\n`. A maioria dos casos de utilização com várias linhas necessita de ambas.
    Qual é a diferença entre quantificadores gananciosos e preguiçosos?
    Por predefinição, quantificadores como «*», «+» e «{n,m}» são «greedy» — consomem o máximo de dados de entrada possível, desde que a correspondência global seja bem-sucedida. Adicionar `?` torna-os preguiçosos: consomem o mínimo e deixam que as partes posteriores do padrão capturem o resto. O quantificador ganancioso `<.+>` contra `` corresponde à string inteira; o quantificador preguiçoso `<.+?>` corresponde apenas a ``. Os quantificadores preguiçosos são geralmente o que se pretende ao extrair campos entre delimitadores.
    Como faço para escapar de caracteres especiais no meu padrão?
    Por que é que a minha expressão regular encontra mais (ou menos) resultados do que o esperado?