Expressões Regulares em JavaScript: Guia Completo

As expressões regulares, também conhecidas como regex, são padrões utilizados para encontrar determinados padrões em strings de texto. Em JavaScript, as expressões regulares são suportadas nativamente e oferecem uma poderosa ferramenta para manipulação e busca de texto.

Para criar uma expressão regular em JavaScript, você pode usar a classe RegExp ou a sintaxe literal entre barras (/). Por exemplo:

javascriptCopy code
// Usando a classe RegExp
let regex1 = new RegExp('padrão');

// Usando a sintaxe literal
let regex2 = /padrão/;

Existem várias formas de utilizar as expressões regulares em JavaScript, algumas das quais são:

1. Testar padrões em uma string:
   Você pode usar o método test() para verificar se um padrão corresponde a uma determinada string.

   javascriptCopy code
   let string = 'Esta é uma string de exemplo.';
   let padrao = /exemplo/;
   console.log(padrao.test(string)); // Saída: true
   

2. Encontrar padrões em uma string:
   O método match() é usado para encontrar padrões em uma string.

   javascriptCopy code
   let string = 'Esta é uma string de exemplo.';
   let padrao = /exemplo/;
   console.log(string.match(padrao)); // Saída: ["exemplo"]
   

3. Substituir padrões em uma string:
   O método replace() permite substituir padrões em uma string por outro valor.

   javascriptCopy code
   let string = 'Esta é uma string de exemplo.';
   let padrao = /exemplo/;
   let novoTexto = string.replace(padrao, 'amostra');
   console.log(novoTexto); // Saída: "Esta é uma string de amostra."
   

4. Dividir uma string com base em um padrão:
   O método split() pode ser usado para dividir uma string em um array de substrings com base em um padrão.

   javascriptCopy code
   let string = 'banana, maçã, uva, abacaxi';
   let padrao = /\s*,\s*/; // Padrão para dividir por vírgulas com ou sem espaços em branco
   console.log(string.split(padrao)); // Saída: ["banana", "maçã", "uva", "abacaxi"]
   

5. Flags:
   As expressões regulares em JavaScript suportam várias flags que podem ser usadas para modificar o comportamento da expressão regular. Alguns exemplos comuns incluem:

   • i: Ignora maiúsculas/minúsculas ao fazer a correspondência.
   • g: Realiza uma correspondência global (encontra todas as correspondências na string, não apenas a primeira).
   • m: Permite a correspondência em várias linhas.

   javascriptCopy code
   let string = 'Maçã, banana, Abacaxi, MORANGO';
   let padrao = /banana/i; // Ignora maiúsculas/minúsculas
   console.log(padrao.test(string)); // Saída: true
   
   let padraoGlobal = /a/g; // Correspondência global
   console.log(string.match(padraoGlobal)); // Saída: ["a", "a", "a", "a"]
   
   let stringMultiLinha = 'linha 1\nlinha 2';
   let padraoMultiLinha = /^linha/m; // Correspondência em várias linhas
   console.log(stringMultiLinha.match(padraoMultiLinha)); // Saída: ["linha"]
   

As expressões regulares em JavaScript são extremamente versáteis e poderosas, permitindo realizar operações complexas de manipulação de strings com facilidade e eficiência. No entanto, elas também podem ser complicadas de entender e criar, especialmente para padrões mais avançados. Dominar expressões regulares é uma habilidade valiosa para qualquer desenvolvedor JavaScript.

Claro! Vamos explorar mais detalhes sobre expressões regulares em JavaScript.

Sintaxe Básica:

A sintaxe básica de uma expressão regular em JavaScript envolve o uso de delimitadores / para indicar o início e o fim do padrão, por exemplo:

javascriptCopy code
let padrao = /exemplo/;

Você também pode criar uma expressão regular usando a classe RegExp, passando o padrão como uma string:

javascriptCopy code
let padrao = new RegExp('exemplo');

Metacaracteres:

Os metacaracteres são caracteres especiais que têm significados especiais em expressões regulares. Alguns dos metacaracteres mais comuns incluem:

• . (ponto): Corresponde a qualquer caractere único, exceto quebras de linha.
• ^ (circunflexo): Corresponde ao início de uma string.
• $ (cifrão): Corresponde ao final de uma string.
• *: Corresponde a zero ou mais ocorrências do caractere anterior.
• +: Corresponde a uma ou mais ocorrências do caractere anterior.
• ?: Torna o caractere anterior opcional (corresponde a zero ou uma ocorrência).
• \: Escapa o próximo caractere, permitindo que você corresponda a caracteres que normalmente seriam interpretados como metacaracteres.

Grupos de Captura:

Você pode usar parênteses () para criar grupos de captura em uma expressão regular. Isso permite que você capture partes específicas de uma correspondência.

javascriptCopy code
let padrao = /(\d+)-(\d+)-(\d+)/; // Padrão para corresponder a uma data no formato AAAA-MM-DD
let string = 'Data de hoje: 2024-02-28';
let resultado = string.match(padrao);
console.log(resultado[1]); // Saída: 2024 (ano)
console.log(resultado[2]); // Saída: 02 (mês)
console.log(resultado[3]); // Saída: 28 (dia)

Classes de Caracteres:

As classes de caracteres permitem corresponder a qualquer caractere dentro de um conjunto específico de caracteres. Por exemplo:

• [abc]: Corresponde a qualquer caractere a, b ou c.
• [0-9]: Corresponde a qualquer dígito de 0 a 9.
• [^abc]: Corresponde a qualquer caractere que não seja a, b ou c.

Quantificadores:

Os quantificadores permitem especificar quantas vezes um elemento pode ocorrer na correspondência.

• {n}: Corresponde exatamente a n ocorrências do elemento anterior.
• {n,}: Corresponde a pelo menos n ocorrências do elemento anterior.
• {n,m}: Corresponde a pelo menos n e no máximo m ocorrências do elemento anterior.

Modificadores:

JavaScript suporta modificadores que podem ser anexados à expressão regular para alterar seu comportamento.

• i: Ignora maiúsculas/minúsculas ao fazer a correspondência.
• g: Realiza uma correspondência global (encontra todas as correspondências na string, não apenas a primeira).
• m: Permite a correspondência em várias linhas.

Funções de Manipulação de Strings:

Além dos métodos test() e match() mencionados anteriormente, existem outras funções que podem ser usadas para manipular strings com expressões regulares em JavaScript, como search(), replace(), split() e exec().

Performance:

Embora as expressões regulares sejam extremamente úteis, é importante ter em mente que expressões regulares complexas podem ter um impacto significativo no desempenho, especialmente quando aplicadas a grandes volumes de texto. Portanto, ao lidar com operações intensivas em termos de CPU ou grandes conjuntos de dados, é importante otimizar suas expressões regulares sempre que possível.

Dominar o uso de expressões regulares em JavaScript pode abrir um vasto leque de possibilidades na manipulação e busca de texto em suas aplicações. Com prática e compreensão dos conceitos fundamentais, você poderá utilizar expressões regulares de forma eficaz para uma ampla gama de cenários de desenvolvimento web e aplicativos.