Regex, abreviação de expressão regular, é frequentemente usado em linguagens de programação para combinar padrões em strings, localizar e substituir, validar entradas e reformatar texto. Aprender a usar corretamente o Regex pode facilitar muito o trabalho com texto.

Sintaxe Regex, explicada

O Regex tem uma reputação de ter uma sintaxe horrenda, mas é muito mais fácil escrever do que ler. Por exemplo, aqui está uma regex geral para um validador de e-mail compatível com RFC 5322:

(? :( a-z0-9! # $% & '* + / =? ^ _ `{|} ~ -) + (?: . (a-z0-9! # $% &' * + / =? ^ _ `{|} ~ -) +) * |" (?: ( x01- x08 x0b x0c x0e- x1f x21 x23- x5b x5d- x7f) | \ ( x01- x09 x0b x0c x0e- x7f)) " @ (? :(? :( a-z0-9) (? :( a-z0-9 -) * (a-z0-9))? .) + (a-z0-9) (? :( a-z0-9 -) * (a-z0-9))? | ((? :( ?: 25 (0-5) | 2 (0-4) (0-9) | (01)? (0-9) (0-9)?) .) {3} (?: 25 ( 0-5) | 2 (0-4) (0-9) | (01)? (0- 9) (0-9)? | (A-z0-9 -) * (a-z0-9): (?: ( X01- x08 x0b x0c x0e- x1f x21- x5a x53- x7f) | \ ( x01- x09 x0b x0c x0e- x7f)) +) ))

Se parece que alguém bateu com o rosto no teclado, você não está sozinho. Mas sob o capô, toda essa bagunça está na verdade programando um máquina de estados finitos. Essa máquina é executada para cada personagem, acompanhando e correspondendo com base nas regras que você definiu. Muitas ferramentas on-line renderizam diagramas ferroviários, mostrando como sua máquina Regex funciona. Aqui está o mesmo Regex em forma visual:

Ainda é muito confuso, mas é muito mais compreensível. É uma máquina com partes móveis que possuem regras que definem como tudo se encaixa. Você pode ver como alguém montou isso; não é apenas uma grande quantidade de texto.

Primeiro: use um depurador Regex

Antes de começarmos, a menos que seu Regex seja particularmente curto ou você seja proficiente, use um depurador on-line ao escrevê-lo e testá-lo. Isso facilita muito a compreensão da sintaxe. Nós recomendamos Regex101 e RegExr, que oferecem teste e referência de sintaxe interna.

Como o Regex funciona?

Por enquanto, vamos nos concentrar em algo muito mais simples. Este é um diagrama de Regulex para um Regex de correspondência por email muito curto (e definitivamente não compatível com RFC 5322):

O mecanismo Regex inicia à esquerda e percorre as linhas, coincidindo com os caracteres. O grupo 1 corresponde a qualquer caractere, exceto uma quebra de linha, e continuará a corresponder caracteres até o próximo bloco encontrar uma correspondência. Nesse caso, ele pára quando atinge um @ símbolo, o que significa que o grupo nº 1 captura o nome do endereço de e-mail e tudo o que corresponde ao domínio.

O Regex que define o Grupo # 1 em nosso exemplo de email é:

(. +)

Os parênteses definem um grupo de captura, que informa ao mecanismo Regex para incluir o conteúdo da correspondência desse grupo em uma variável especial. Quando você executa um Regex em uma sequência, o retorno padrão é a correspondência inteira (nesse caso, o email inteiro). Mas ele também retorna cada grupo de captura, o que torna esse Regex útil para obter nomes de emails.

O período é o símbolo de "Qualquer caractere, exceto nova linha". Isso corresponde a tudo em uma linha; portanto, se você passou este e-mail para o Regex, um endereço como:

%$#^&%*#%$#^@gmail.com

Combinaria % $ # ^ &% * #% $ # ^ como o nome, mesmo que isso seja ridículo.

O símbolo de mais (+) é uma estrutura de controle que significa "corresponder ao caractere ou grupo anterior uma ou mais vezes". Ele garante que o nome inteiro seja correspondido, e não apenas o primeiro caractere. É isso que cria o loop encontrado no diagrama da ferrovia.

O restante do Regex é bastante simples de decifrar:

(. +) @ (. + .. +)

O primeiro grupo para quando atinge o @ símbolo. O próximo grupo é iniciado, que novamente combina vários caracteres até atingir um caractere de ponto.

Como caracteres como pontos, parênteses e barras são usados ​​como parte da sintaxe no Regrex, sempre que você deseja corresponder esses caracteres, é necessário escapá-los adequadamente com uma barra invertida. Neste exemplo, para corresponder ao período que escrevemos . e o analisador o trata como um símbolo que significa "corresponder a um ponto".

Correspondência de caracteres

Se você tiver caracteres não controlados em seu Regex, o mecanismo Regex assumirá que esses caracteres formarão um bloco correspondente. Por exemplo, o Regex:

ele + llo

Corresponderá a palavra "olá" a qualquer número de e's. Quaisquer outros caracteres precisam ser escapados para funcionar corretamente.

Regex também possui classes de caracteres, que funcionam como atalhos para um conjunto de caracteres. Eles podem variar com base na implementação do Regex, mas esses poucos são padrão:

  • . - corresponde a qualquer coisa, exceto nova linha.
  • W - corresponde a qualquer caractere "palavra", incluindo dígitos e sublinhados.
  • d - combina números.
  • b - corresponde a caracteres de espaço em branco (ou seja, espaço, guia, nova linha).

Todos esses três têm contrapartes maiúsculas que invertem sua função. Por exemplo, D corresponde a qualquer coisa que não seja um número.

Regex também possui correspondência de conjunto de caracteres. Por exemplo:

(abc)

Combinará uma, bou c. Isso atua como um bloco, e os colchetes são apenas estruturas de controle. Como alternativa, você pode especificar um intervalo de caracteres:

(a-c)

Ou negue o conjunto, que corresponderá a qualquer caractere que não esteja no conjunto:

(^ a-c)

Quantificadores

Quantificadores são uma parte importante do Regex. Eles permitem combinar cordas nas quais você não conhece o exato formato, mas você tem uma boa ideia.

o + O operador do exemplo de email é um quantificador, especificamente o quantificador "um ou mais". Se não soubermos quanto tempo uma determinada string é, mas sabemos que ela é composta de caracteres alfanuméricos (e não está vazia), podemos escrever:

 w +

Além de +, há também:

  • o * operador, que corresponde a "zero ou mais". Essencialmente o mesmo que +, exceto que ele tem a opção de não encontrar uma correspondência.
  • o ? operador, que corresponde a "zero ou um". Isso tem o efeito de tornar um personagem opcional; está lá ou não, e não corresponderá mais de uma vez.
  • Quantificadores numéricos. Estes podem ser um número único como {3}, que significa "exatamente três vezes" ou um intervalo como {3-6}. Você pode deixar de fora o segundo número para torná-lo ilimitado. Por exemplo, {3} significa "3 ou mais vezes". Por incrível que pareça, você não pode deixar de fora o primeiro número. Portanto, se você quiser "3 ou menos vezes", precisará

Quantificadores gananciosos e preguiçosos

Sob o capô, o * e + operadores são ávido. Corresponde o máximo possível e devolve o que é necessário para iniciar o próximo bloco. Isso pode ser um problema enorme.

Aqui está um exemplo: digamos que você esteja tentando combinar HTML ou qualquer outra coisa com chaves de fechamento. Seu texto de entrada é:

Olá Mundo

E você deseja combinar tudo entre parênteses. Você pode escrever algo como:

<.*>

Essa é a ideia certa, mas falha por um motivo crucial: o mecanismo Regex corresponde a "div> Olá Mundo

”Para a sequência . *, e depois recua até o próximo bloco corresponder, nesse caso, a um colchete de fechamento (>) Você esperaria que ela retornasse para corresponder apenas a "div“E repita novamente para corresponder à div de fechamento. Mas o backtracker é executado a partir do final da string e para no colchete final, que acaba correspondendo a tudo dentro dos colchetes.

Adicione ao Google Notícias

A solução é tornar nosso quantificador preguiçoso, o que significa que ele corresponderá ao mínimo de caracteres possível. Sob o capô, isso na verdade corresponde apenas a um caractere e depois expande para preencher o espaço até a próxima correspondência do bloco, o que o torna muito mais eficiente em grandes operações Regex.

Tornar um quantificador preguiçoso é feito adicionando um ponto de interrogação diretamente após o quantificador. Isso é um pouco confuso porque ? já é um quantificador (e é realmente ganancioso por padrão). Para o nosso exemplo HTML, o Regex é corrigido com esta simples adição:

<.*?>

O operador preguiçoso pode ser preso a qualquer quantificador, incluindo +?, {0,3}?, e até mesmo ??. Embora o último não tenha nenhum efeito; porque você está igualando zero ou um caractere de qualquer maneira, não há espaço para expandir.

Agrupamento e lookarounds

Grupos no Regex têm muitos propósitos. Em um nível básico, eles juntam vários tokens em um bloco. Por exemplo, você pode criar um grupo e usar um quantificador em todo o grupo:

ba (na) +

Agrupa o "na" repetido para corresponder à frase bananae banananana, e assim por diante. Sem o grupo, o mecanismo Regex corresponderia ao caractere final repetidamente.

Esse tipo de grupo com dois parênteses simples é chamado de grupo de captura e o incluirá na saída:

Se você deseja evitar isso e simplesmente agrupar tokens por motivos de execução, pode usar um grupo que não captura:

ba (?: na)

O ponto de interrogação (um caractere reservado) define um grupo não padrão e o caractere a seguir define que tipo de grupo é. Iniciar grupos com um ponto de interrogação é ideal, pois, caso contrário, se você deseja combinar ponto-e-vírgula em um grupo, precisará escapar deles sem um bom motivo. Mas você sempre precisa escapar de pontos de interrogação no Regex.

Você também pode nomear seus grupos, por conveniência, ao trabalhar com a saída:

(?'grupo')

Você pode fazer referência a eles no seu Regex, o que os faz funcionar de maneira semelhante às variáveis. Você pode referenciar grupos não nomeados com o token 1, mas isso só vai até 7, após o qual você precisará começar a nomear grupos. A sintaxe para referenciar grupos nomeados é:

 k {group}

Isso faz referência aos resultados do grupo nomeado, que pode ser dinâmico. Essencialmente, ele verifica se o grupo ocorre várias vezes, mas não se importa com a posição. Por exemplo, isso pode ser usado para corresponder todo o texto entre três palavras idênticas:

A classe do grupo é onde você encontra a maior parte da estrutura de controle da Regex, incluindo lookaheads. Os lookaheads garantem que uma expressão deve corresponder, mas não a inclui no resultado. De certa forma, é semelhante a uma instrução if e não corresponderá se retornar falso.

A sintaxe para um lookahead positivo é (? =). Aqui está um exemplo:

Isso corresponde perfeitamente à parte do nome de um endereço de email, interrompendo a execução na divisão @. Os Lookaheads não consomem nenhum caractere. Portanto, se você quiser continuar correndo depois que um Lookahead for bem-sucedido, ainda poderá corresponder ao caractere usado no Lookahead.

Além das visões positivas, também existem:

  • (?!) - Lookaheads negativos, que garantem uma expressão não Combine.
  • (? <=) - Perspectivas positivas, que não são suportadas em todos os lugares devido a algumas restrições técnicas. Eles são colocados antes da expressão que você deseja corresponder e devem ter uma largura fixa (ou seja, nenhum quantificador, exceto {número}. Neste exemplo, você poderia usar (? <= @) w + . w + para corresponder à parte do domínio do email.
  • (? <!) - Lookbehinds negativos, que são iguais aos lookbehinds positivos, mas negados.

Diferenças entre os motores Regex

Nem todos os Regex são criados iguais. A maioria dos mecanismos Regex não segue nenhum padrão específico, e alguns mudam um pouco as coisas para se adequar ao seu idioma. Alguns recursos que funcionam em um idioma podem não funcionar em outro.

Por exemplo, as versões do sed compilado para macOS e FreeBSD não suportam o uso de t para representar um caractere de tabulação. Você precisa copiar manualmente um caractere de tabulação e colá-lo no terminal para usar uma tabulação na linha de comando sed.

A maior parte deste tutorial é compatível com o PCRE, o mecanismo Regex padrão usado para PHP. Mas o mecanismo Regex do JavaScript é diferente - ele não suporta grupos de captura nomeados com aspas (deseja colchetes) e não pode fazer recursão, entre outras coisas. Mesmo o PCRE não é totalmente compatível com versões diferentes e possui muitas diferenças do Perl regex.

Existem muitas pequenas diferenças para listar aqui, então você pode usar esta tabela de referência para comparar as diferenças entre vários mecanismos Regex. Além disso, depuradores Regex como Regex101 permita que você alterne os mecanismos Regex. Verifique se está depurando usando o mecanismo correto.

Como executar o Regex

Temos discutido a parte correspondente de expressões regulares, que compõe a maior parte do que faz um Regex. Mas quando você deseja executar seu Regex, precisará transformá-lo em uma expressão regular completa.

Isso geralmente assume o formato:

/ partida / g

Tudo dentro das barras é o nosso par. o g é um modificador de modo. Nesse caso, ele diz ao mecanismo para não parar de rodar depois de encontrar a primeira partida. Para encontrar e substituir o Regex, é necessário formatá-lo da seguinte maneira:

/ encontre / substitua / g

Isso substitui todo o arquivo. Você pode usar referências de grupo de captura ao substituir, o que torna o Regex muito bom na formatação de texto. Por exemplo, este Regex corresponderá a qualquer tag HTML e substituirá os colchetes padrão por colchetes:

/<(.+?)>/ ( 1) / g

Quando isso funcionar, o mecanismo corresponderá

e
, permitindo que você substitua este texto (e somente este texto). Como você pode ver, o HTML interno não é afetado:

Isso torna o Regex muito útil para localizar e substituir texto. O utilitário de linha de comando para fazer isso é sed, que usa o formato básico de:

sed '/ find / replace / g' file> arquivo

Isso é executado em um arquivo e sai para STDOUT. Você precisará canalizá-lo para si mesmo (como mostrado aqui) para substituir o arquivo no disco.

O Regex também é suportado em muitos editores de texto e pode realmente acelerar o seu fluxo de trabalho ao realizar operações em lote. Vim, Átomoe VS CodTodos nós temos o Regex para localizar e substituir.

Obviamente, o Regex também pode ser usado de forma programática e geralmente é incorporado a muitos idiomas. A implementação exata dependerá do idioma, portanto, você precisará consultar a documentação do seu idioma.

Por exemplo, no JavaScript, a regex pode ser criada literalmente ou dinamicamente usando o objeto global RegExp:

var re = novo RegExp ('abc')

Isso pode ser usado diretamente chamando o .exec () método do objeto regex recém-criado ou usando o método .substituir(), .Combine()e .matchAll () métodos em strings.