Expressões Regulares em JavaScript

Quando se trata de expressões regulares (Regex) em JavaScript, é fundamental compreender não apenas os conceitos básicos, mas também as técnicas avançadas para manipular e validar padrões complexos de texto. As expressões regulares são sequências de caracteres que formam um padrão de pesquisa, permitindo a correspondência flexível de texto em uma variedade de cenários. No JavaScript, elas são implementadas por meio do objeto RegExp ou pelo uso de literais de expressão regular entre barras.

Para criar expressões regulares mais avançadas em JavaScript, é essencial entender os diversos metacaracteres e construções especiais que estão à disposição. Além disso, o uso de quantificadores, agrupamentos, classes de caracteres e âncoras pode ser extremamente útil para alcançar uma maior precisão na correspondência de padrões.

Vamos explorar alguns exemplos de expressões regulares avançadas em JavaScript:

1. Quantificadores:

   • *: Correspondência de zero ou mais ocorrências do caractere anterior.
   • +: Correspondência de uma ou mais ocorrências do caractere anterior.
   • ?: Correspondência de zero ou uma ocorrência do caractere anterior.
   • {n}: Correspondência exatamente n ocorrências do caractere anterior.
   • {n,}: Correspondência de no mínimo n ocorrências do caractere anterior.
   • {n,m}: Correspondência de pelo menos n e no máximo m ocorrências do caractere anterior.

   Exemplo: /a+/ corresponde a uma ou mais ocorrências do caractere “a”.

2. Agrupamentos:

   • ( ): Define um grupo de caracteres.
   • (?: ): Define um grupo de não captura.
   • |: Define uma alternância entre padrões.

   Exemplo: /(\d{3})-(\d{4})/ corresponde a um padrão de telefone no formato “ddd-dddd”.

3. Classes de Caracteres:

   • [ ]: Define um conjunto de caracteres.
   • [^ ]: Define um conjunto de caracteres que não devem ser correspondidos.
   • \d: Corresponde a qualquer dígito decimal.
   • \w: Corresponde a qualquer caractere alfanumérico.
   • \s: Corresponde a qualquer caractere de espaço em branco.

   Exemplo: /\b[a-zA-Z]+\b/ corresponde a palavras que contenham apenas letras.

4. Âncoras:

   • ^: Corresponde ao início de uma string.
   • $: Corresponde ao final de uma string.
   • \b: Corresponde a uma fronteira de palavra.

   Exemplo: /^\d{4}$/ corresponde a números de telefone de exatamente 4 dígitos.

5. Modificadores:

   • i: Realiza uma correspondência sem diferenciação entre maiúsculas e minúsculas.
   • g: Realiza uma correspondência global em toda a string (não apenas na primeira ocorrência).

   Exemplo: /javascript/i corresponde a “JavaScript”, “javascript”, “JAVAscript”, etc.

Ao usar expressões regulares em JavaScript, é importante testar e depurar os padrões cuidadosamente, especialmente em situações mais complexas. Ferramentas online de teste de Regex, como o Regex101 ou o RegExr, podem ser extremamente úteis para experimentar e validar padrões de expressões regulares antes de implementá-los em seu código JavaScript. Além disso, documentações e recursos online, como o MDN Web Docs, oferecem uma referência completa sobre a sintaxe e os recursos das expressões regulares em JavaScript.

Claro! Vamos aprofundar ainda mais nosso conhecimento sobre expressões regulares (Regex) em JavaScript, abordando tópicos adicionais e exemplos práticos para ilustrar seu uso em situações do mundo real.

Caracteres de Escape:

Em expressões regulares, alguns caracteres têm significados especiais, como . (ponto), * (asterisco) e + (sinal de mais). Se precisar corresponder a esses caracteres literalmente, é necessário escapá-los com uma barra invertida \. Por exemplo, /a\+/ corresponde a “a+”.

Âncoras de Fronteira de Palavra:

As âncoras \b correspondem a uma fronteira de palavra, o que significa que correspondem a uma posição onde o caractere anterior é uma letra, número ou sublinhado, e o caractere seguinte não é, ou vice-versa. Por exemplo, /java\b/ corresponde a “java” em “java script”, mas não em “javascript”.

Captura e Grupos de Não Captura:

Os parênteses () são usados para definir grupos de captura em uma expressão regular. Isso permite extrair partes específicas do texto correspondido. Por exemplo, /(\d{2})-(\d{2})-(\d{4})/ corresponde a datas no formato “dd-mm-yyyy” e captura o dia, mês e ano separadamente.

Por outro lado, (?: ) define um grupo de não captura, o que significa que o texto correspondido dentro desse grupo não será capturado. Isso pode ser útil em situações em que você precisa agrupar partes da expressão regular, mas não deseja extrair essas partes posteriormente.

Substituição de Texto:

Além de encontrar padrões em texto, as expressões regulares também podem ser usadas para substituir texto por outro padrão. O método replace() em strings JavaScript permite fazer isso. Por exemplo:

javascriptCopy code
let texto = "Eu amo maçãs e bananas.";
let novoTexto = texto.replace(/maçãs|bananas/g, "laranjas");
// novoTexto agora é "Eu amo laranjas e laranjas."

Funções de Pesquisa:

O objeto RegExp em JavaScript fornece várias funções para pesquisar padrões em strings:

• test(): Verifica se há uma correspondência em uma string e retorna true ou false.
• exec(): Retorna informações sobre a primeira correspondência encontrada em uma string como um array, incluindo o texto correspondido e grupos de captura.

Modificadores:

Além dos modificadores i (ignorar maiúsculas/minúsculas) e g (correspondência global), há também o modificador m que permite corresponder a padrões em várias linhas (^ e $ correspondem ao início/final de cada linha).

Exemplo de Uso em JavaScript:

Vamos considerar um exemplo prático onde podemos utilizar expressões regulares em JavaScript. Suponha que precisamos validar se um endereço de e-mail é válido:

javascriptCopy code
function validarEmail(email) {
    let regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
    return regex.test(email);
}

console.log(validarEmail("[email protected]")); // Retorna true
console.log(validarEmail("[email protected]")); // Retorna false

Neste exemplo, a expressão regular /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/ valida se o formato do endereço de e-mail está correto, correspondendo a uma sequência de caracteres seguida por @, seguida por outra sequência de caracteres, seguida por um ponto e um domínio com pelo menos dois caracteres.

Essas são apenas algumas das muitas maneiras de usar expressões regulares em JavaScript. Com prática e experimentação, você pode dominar a arte de criar e aplicar padrões de texto complexos em suas aplicações web.