Introdução ao Regex

• Introdução ao Regex

Resumo

• ^: Indicates the start of a line.
• $: Indicates the end of a line.
• .: Matches any character except a newline.
• : Matches the preceding element 0 or more times.
• +: Matches the preceding element 1 or more times.
• {n}: Matches exactly n occurrences of the preceding element.
• [abc]: Matches any one of the characters a, b, or c.
• (abc): Groups the expression inside the parentheses and treats them as a single element.

Explicação

• começo de uma regex sempre / no começo e no final

  • / valor da regex /

• g indica achar todas as ocorrências da regex

  • /ontem/g

• i ignora case sensitive

  • /ontem/i

Operador pipe

• operador pipe |
  • Algumas vezes precisamos dar match em mais de um termo, para isso usamos o operador pipe | . Ele funciona basicamente como nosso operador lógico OR || . Assim podemos escrever
  • /ver|distrai/gi

Conjuntos

• conjuntos []

  • Com os conjuntos dizemos a regex que uma determinada casa pode ter diversos valores para dar match. Vejamos o seu uso:

    pattern: /[a-z]/
    string:  João de Santo Cristo
    matches:  ^ ^ ^^  ^^^^  ^^^^^
    
    pattern: /[A-Za-z]/
    string:  Açucar e Café
    matches: ^ ^^^^ ^  ^^
    
    pattern: /[0-9.,]/
    string:  Um ps4 custa R$ 1.600,00
    matches:      ^          ^^^^^^^^

• conjuntos negação [^]

  • Temos também os conjuntos negados, que como o nome sugere, dar match em tudo que não faça parte do conjunto. Para definí-lo iniciamos a regra do conjunto com ^ , por exemplo [^a-z] que aceita tudo que não seja entre a à z. Vejamos um exemplo:

  pattern: /[^aeiouí]/gi
  string:  Paralelepípedo
  matches: ^ ^ ^ ^ ^ ^ ^

Metacaracteres

.

Nas regex existem duas formas de caracteres, os literais, que representam o valor literal do caractere como abc123 e os metacaracteres que possuem funções distintas dentro de um contexto na regex. Dois exemplos que acabamos de ver são o uso do ^ iniciando um conjunto negado e o uso do - em uma regra de conjunto com range[1-9] . Um metacaractere bastante recorrente é o ponto . , ele funciona como um coringa, sendo capaz de dar match em qualquer caractere, vejamos um exemplo:

pattern: /cas./gi
string:  Casa, caso, case
matches: ^^^^  ^^^^  ^^^^

\

Visto isso, você deve estar se perguntando: Como pegar a forma literal do ponto? Eis que é muito simples bastando usar um escape \ mais o metacaractere desejado. Vejamos um exemplo:

pattern: /[a\-o]/gi
string:  cachorro-quente.
matches:  ^  ^  ^^

shorthands

Para simplificar a escrita e leitura das regex, possuímos algumas shorthands que são extremamente úteis para deixar ainda mais claro nosso código. Veja como podemos escrever esse conjunto [0-9] para \d ,[a-zA-Z0-9_] para \w ou para tratar espaços em branco [\r\n\t\f\v ] para \s simplificando ainda mais nossas regras. Vejamos alguns exemplos:

pattern: /\(\d\d\)\s\d\d\d\d\d-\d\d\d\d/
string:  (86) 95262-7297
matches: ^^^^^^^^^^^^^^^pattern: /\w\w\w\w\w@\w\w\.com/
string:  ax_a5@5x.com
matches: ^^^^^^^^^^^^

Quantificadores

Uma maneira de deixar suas regras ainda mais simples é com o uso dos quantificadores. Com eles podemos dizer quantas vezes uma mesma regra pode aparecer em sequência. Vejamos elas:

• ? - zero ou um ocorrência;
• • zero ou mais ocorrências;
• + - uma ou mais ocorrências;
• {n, m} - de n até m.

Seu uso é simples, basta adicionar o quantificador após um caractere, metacaractere, conjunto ou mesmo um grupo (ainda veremos abaixo). Exemplo [0-9]? \w* a+ e (\d)3 .

Digamos que queremos pegar um documento como o cpf, que contêm muitos números e pontuações(. e -) onde a validação pode aceitar o cpf com e sem pontuação, ficando deste modo:

pattern: /\d{3}\.?\d{3}\.?\d{3}-?\d{2}/
string:  825.531.760-07
matches: ^^^^^^^^^^^^^^
string:  18646661024
matches: ^^^^^^^^^^^

Como podemos pegar uma repetição de caractere sem estipular algum limite, vejamos:

pattern: /go+l+/gi
string:  Goolllll da Alemanha!!!
matches: ^^^^^^^^

Âncoras

Muitas vezes vamos precisar delimitar a ação da nossa regex. Desse modo podemos usar três metas para nos auxiliar nessa função.

Quando queremos tratar uma palavra que em suas extremidades não possua outra letra ou palavra, usamos a shorthands \b.

pattern: /\bpar\b/gi
string:  Parcela par Parcial paraíso
matches:         ^^^pattern: /\bpar[a-z]+/gi
string:  Parei parque topar
matches: ^^^^^ ^^^^^^  pattern: /[a-z]+par\b/gi
string:  parodiado escapar equipar parasitar
matches:           ^^^^^^^ ^^^^^^^pattern: /\b[a-z]+par[a-z]+\b/gi
string:  limpar aparto aparta
matches:        ^^^^^^ ^^^^^^

Vale notar que caracteres com acentos ou - são considerados bordas.

Podemos lidar com o início e fim de uma linha. Usamos a meta ^ para indicar o início de uma linha e $ indicando o fim de uma linha. Algo importante a se notar é que para as âncoras funcionarem a cada quebra de linha \n a flag m tem que estar habilitada. Segue uma estrofe usando a meta ^:

pattern: /^[a-z]*\b/gmi
Quantas chances desperdicei
^^^^^^^
Quando o que eu mais queria
^^^^^^
Era provar pra todo o mundo
^^^
Que eu não precisava provar nada pra ninguém
^^^

Confira também o uso do meta *$ em uma estrofe:*

pattern: /[a-z]+nto$/gmi
O tempo cobre o chão de verde manto
                              ^^^^^
Que já coberto foi de neve fria,
E em mim converte em choro o doce canto
                                  ^^^^^

Conseguimos tratar início e final de um texto ao mesmo tempo. Confira um exemplo:

pattern: /^https:\/\/w{3}\.[a-z]+\.com$/gmi
https://google.com.br
https://www.facebook.com
^^^^^^^^^^^^^^^^^^^^^^^^
https://www.voxel.com.br

Grupos

Por fim, temos os grupos que facilita ainda mais nossas regras. Eles nos possibilita a criação de regras isoladas, possibilita a criação de referencias (retrovisores) para o reuso da mesma regra em outro local dentro de uma mesmo regex e ainda cria a possibilidade de validações dentro da regex. Seu uso é muito diverso, dando muito poder ao programador na hora de escrever suas regras. Veja um exemplo:

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

Uma função muito interessante dos grupos é que quando criamos algum grupo, este grupo é criando uma referência, que podemos acessa-lo em funções como o método replace (que vamos ver a frente) ou usar como retrovisores (mirror words) para fazer reuso de algum grupo que deu match anteriormente. Vejamos um exemplo baseado no exemplo anterior:

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

No exemplo acima, veja que criamos o grupo (\/?) e para não repetí-lo em outro momento que necessitamos da mesma regra, usamos o retrovisor \1 sendo 1 é ligado a ordem em que esse grupo foi criado. Podemos criar diversas referências para o reuso de regras.

Uma dica é se por exemplo usamos um grupo (\w) o seu retrovisor será o caractere que deu match com \w. Ex: \w = R seu \1 sera R.

Podemos definir grupos que podem ser ignorados (non-capturing groups) na hora do match usando a sintaxe (?:). Vejamos um exemplo:

pattern: /([a-z]*)\s(?:ronaldo)/gi
string:  Cristiano Ronaldo
matches: ^^^^^^^^^^^^^^^^^

No exemplo acima, só foi nomeado um grupo, no caso *([a-z]*) pois o grupo (?:ronaldo) foi definido usando* (?:) e com isso não conseguimos manipulá-lo.

Com os grupos podemos criar grupos aninhados (grupos dentro de grupos). Vejamos um exemplo:

pattern: /((d[io])|(co))([a-z]{2})(do)/gi
string:  ditado colado dosado
matches: ^^^^^^ ^^^^^^ ^^^^^^

Os grupos possuem grupos especiais. Como o positive lookahead (?=) e o seu oposto, negative lookahead (?!). Com o positive lookahead podemos verificar se existe um grupo a frente de uma expressão ou grupo. Vejamos um exemplo:

pattern: /([a-z]+)(?=,)/gi
string:  Penso, logo existo
matches: ^^^^^

Falamos acima que a regex só dá match em palavras que à sua frente possuam virgula. Já o negative lookahead é exatamente o contrário do positive lookahed, ele pegará todos que não fazem parte do grupo especial. Vejamos um exemplo:

pattern: /([a-z]+)(?!,)\b/gi
string:  Penso, logo existo
matches:        ^^^^ ^^^^^^

Dentro dos grupos especiais ainda temos os positive lookbehind e negative lookbehind, porém como eles não possuem um bom suporte nos browsers decidi deixá-lo de fora deste post, porém pretendo abordá-los em post futuros.

Resumo

Representantes

Meta	Nome	Função
.	ponto	um caractere qualquer
[]	conjunto	conjunto de caracteres permitidos
[^]	conjunto negado	conjunto de caracteres proibidos

Quantificadores

Meta	Nome	Função
?	opcional	zero ou um
*	asterisco	zero ou mais
+	mais	um ou mais
{n, m}	chaves	de n até m

Âncoras

Meta	Nome	Função
^	circunflexo	inicio da linha
$	cifrao	fim da linha
\b	borda	inicio ou fim de palavra

Outros Metacaracteres

Meta	Nome	Função
\	escape	uso de metacaracteres com literal
`	`	ou
()	grupo	define um grupo
\1...\9	retrovisor	regata grupos ja definidos

Descrição ou shorthands

Meta	Função
\A	Corresponde somente ao início de uma sequência.
\b	Corresponde a um limite de palavras, isto é, a posição entre uma palavra e um espaço.
\B	Corresponde a um limite.
\d	Corresponde a um caractere de dígito.
\D	Corresponde a um caractere diferente de dígito.
\f	Corresponde a um caractere de alimentação de formulário.
\n	Corresponde a um caractere de nova linha.
\r	Corresponde a um caractere de retorno de linha.
\s	Corresponde a qualquer espaço em branco, incluindo espaços, tabulações, caracteres de alimentação de formulário, e assim por diante.
\S	Corresponde a qualquer caractere diferente de espaço em branco.
\t	Corresponde a um caractere de tabulação.
\v	Corresponde a um caractere de tabulação vertical.
\w	Corresponde a qualquer caractere de texto, incluindo sublinhado. Essa expressão é equivalente a [A-Za-z0-9_].
\W	Corresponde a qualquer caractere diferente de palavra. Essa expressão é equivalente a [^A-Za-z0-9_].
\z	Corresponde somente ao fim de uma sequência.
\Z	Corresponder somente ao fim de uma sequência ou antes de um caractere de nova linha no final.