Objeto RegExp: Expressões Regulares - JavaScript

Expressões regulares representam um padrão usado para buscar ou modificar uma string. Para trabalhar com strings, podemos, claro, usar um conjunto padrão de métodos do tipo String. No entanto, as expressões regulares oferecem uma ferramenta mais flexível.

Para trabalhar com expressões regulares em JavaScript, o objeto RegExp é definido.

Você pode definir uma expressão regular de duas maneiras:

const myExp1 = /hello/;
const myExp2 = new RegExp("hello");

A expressão regular usada aqui é bastante simples: consiste na palavra "hello". No primeiro caso, a expressão é colocada entre duas barras (notação literal), enquanto no segundo caso, usa-se o construtor RegExp, onde a expressão é passada como uma string.

Geralmente, se a expressão regular é definida dinamicamente (por exemplo, através da entrada do usuário), então o construtor é usado. Se a expressão é estática e imutável, usa-se a notação literal, como no primeiro caso.

Após definir uma expressão regular para processar strings, podemos usar um dos métodos RegExp:

• test(): verifica se um padrão específico está presente na string. Se a string corresponder ao padrão, esse método retorna verdadeiro, caso contrário, retorna falso.

• exec(): procura ocorrências de um padrão específico na string e retorna essas ocorrências como um array.

Além disso, para trabalhar com expressões regulares, podemos usar uma série de métodos do tipo String:

• match(): também procura ocorrências de um padrão específico na string e retorna essas ocorrências como um array.

• replace(): substitui ocorrências de um padrão específico na string.

• search(): procura ocorrências de um padrão específico na string e retorna o índice da primeira ocorrência.

• split(): divide a string de acordo com um padrão específico e retorna as partes obtidas como um array.

Verificação de Correspondência da String com o Padrão

test()

Para verificar se um texto na string corresponde a uma expressão regular, o método test() do objeto RegExp é usado. Este método retorna verdadeiro se a string contém texto que corresponde à expressão regular, e falso se não contém.

const initialText = "hello world!";     // string para busca
const exp = /hello/;    // expressão regular
const result = exp.test(initialText);   // verifica a presença da expressão exp na string
console.log(result); // true

const initialText2 = "Hi all";
const result2 = exp.test(initialText2);
console.log(result2); // false - não há "hello" na string "Hi all"

Neste caso, verificamos se nas strings initialText ("hello world!") e initialText2 ("Hi all") existe a expressão exp (/hello/). Como o texto está presente na primeira string, exp.test(initialText) retorna verdadeiro. No caso da segunda string, como o texto está ausente, retorna-se falso.

exec()

O método exec() funciona de maneira similar - ele também verifica se há texto na string que satisfaz a expressão regular. Se houver tal texto, o método retorna a parte da string que corresponde à expressão. Se não houver correspondências, o valor null é retornado.

const initialText = "hello world!";     // string para busca
const exp = /hello/;    // expressão regular
const result = exp.exec(initialText);   // verifica a presença da expressão exp na string
console.log(result); // ['hello', index: 0, input: 'hello world!', groups: undefined]

const initialText2 = "Hi all";
const result2 = exp.exec(initialText2);
console.log(result2); // null - não há "hello" na string "Hi all"

Assim, na string "hello world!" há texto que corresponde ao padrão /hello/, portanto a chamada do método exp.exec(initialText) retorna ocorrências do texto que corresponde à expressão na string. E pelo output no console, podemos ver que não é apenas texto, mas um array de valores:

O primeiro elemento do array é o texto que corresponde à expressão (no nosso caso "hello"). O segundo elemento é o índice desse texto na string (no nosso caso, índice 0 - início da string). O terceiro elemento representa a string de entrada. O quarto elemento representa um grupo, que no exemplo acima é indefinido (grupos serão discutidos mais adiante).

Grupos de Caracteres

No exemplo anterior, utilizamos a string "hello" como uma expressão regular. Na realidade, para verificar a presença dessa substring numa string, poderíamos usar os métodos padrão do tipo String. No entanto, não se trata apenas de uma string, mas de um padrão que também pode incluir elementos especiais da sintaxe das expressões regulares. Vamos considerar os padrões mais básicos:

• . (ponto) corresponde a qualquer caractere.

• a (caractere único) corresponde ao caractere "a".

• ab (união de caracteres) corresponde à sequência de caracteres "ab".

• a|b corresponde a "a" ou "b", e o caractere | pode ser visto como um análogo da operação OR.

Por exemplo, para verificar se a senha tem pelo menos 8 caracteres:

const exp = /......../;    // expressão regular - 8 caracteres

const password1 = "1234567890";
const password2 = "qwery5";
// verificando a primeira senha
console.log(exp.test(password1));   // true - password1 corresponde à expressão exp
// verificando a segunda senha
console.log(exp.test(password2));   // false - password2 não corresponde à expressão exp

Aqui, a expressão regular /......../ tem 8 pontos, significando que, para corresponder a essa expressão, a string deve ter pelo menos 8 caracteres.

Outro exemplo:

const exp = /word|work/;    // corresponde a "word" ou "work"

const str1 = "hello world";
const str2 = "hello work";
const str3 = "hello word";
console.log(exp.test(str1));   // false
console.log(exp.test(str2));   // true
console.log(exp.test(str3));   // true

Neste caso, a expressão /word|work/ corresponde ao texto que contém "word" ou "work". No entanto, essa expressão não é ótima - em ambos os casos, o grupo de caracteres "wor" se repete. Para otimizar podemos incluir o grupo comum entre parênteses: /(wor)d|k/. O resultado será o mesmo:

const exp = /(wor)d|k/;    // corresponde a "word" ou "work"

const str1 = "hello world";
const str2 = "hello work";
const str3 = "hello word";
console.log(exp.test(str1));   // false
console.log(exp.test(str2));   // true
console.log(exp.test(str3));   // true

Outro exemplo - verificar se um endereço de e-mail pertence a "gmail.com" ou "yahoo.com":

const exp = /@yahoo|@gmail(.com)/;    // corresponde a "@yahoo.com" ou "@gmail.com"

const email1 = "tom@outlook.com";
const email2 = "tom@gmail.com";
const email3 = "tom@yandex.ru";
const email4 = "tom@yahoo.com";
console.log(exp.test(email1));   // false
console.log(exp.test(email2));   // true
console.log(exp.test(email3));   // false
console.log(exp.test(email4));   // true