Perl - Expressões regulares

Uma expressão regular é uma sequência de caracteres que define o padrão ou padrões que você está visualizando. A sintaxe das expressões regulares em Perl é muito semelhante ao que você encontrará em outros programas de suporte de expressões regulares, comosed, grep, e awk.

O método básico para aplicar uma expressão regular é usar os operadores de associação de padrão = ~ e !~. O primeiro operador é um operador de teste e atribuição.

Existem três operadores de expressão regular em Perl.

• Corresponder à expressão regular - m //
• Substituir Expressão Regular - s ///
• Transliterar Expressão Regular - tr ///

As barras em cada caso atuam como delimitadores para a expressão regular (regex) que você está especificando. Se você se sentir confortável com qualquer outro delimitador, poderá usar no lugar da barra.

O Operador da Partida

O operador de correspondência, m //, é usado para fazer a correspondência de uma string ou instrução com uma expressão regular. Por exemplo, para combinar a sequência de caracteres "foo" com a barra escalar $, você pode usar uma instrução como esta -

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ /foo/) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ /foo/) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Quando o programa acima é executado, ele produz o seguinte resultado -

First time is matching
Second time is matching

OM // realmente funciona da mesma maneira que a série de operadores q //. Você pode usar qualquer combinação de caracteres naturalmente correspondentes para atuar como delimitadores para a expressão. Por exemplo, m {}, m () e m> <são todos válidos. Portanto, o exemplo acima pode ser reescrito da seguinte forma -

#!/usr/bin/perl

$bar = "This is foo and again foo";
if ($bar =~ m[foo]) {
   print "First time is matching\n";
} else {
   print "First time is not matching\n";
}

$bar = "foo";
if ($bar =~ m{foo}) {
   print "Second time is matching\n";
} else {
   print "Second time is not matching\n";
}

Você pode omitir m de m // se os delimitadores forem barras, mas para todos os outros delimitadores você deve usar o prefixo m.

Observe que toda a expressão de correspondência, que é a expressão à esquerda de = ~ ou! ~ E o operador de correspondência, retorna verdadeiro (em um contexto escalar) se a expressão corresponder. Portanto, a declaração -

$true = ($foo =~ m/foo/);

definirá $ true como 1 se $ foo corresponder à regex, ou 0 se a correspondência falhar. Em um contexto de lista, a correspondência retorna o conteúdo de quaisquer expressões agrupadas. Por exemplo, ao extrair as horas, minutos e segundos de uma string de tempo, podemos usar -

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Modificadores do operador de correspondência

O operador match suporta seu próprio conjunto de modificadores. O modificador / g permite correspondência global. O modificador / i tornará a correspondência insensível a maiúsculas e minúsculas. Aqui está a lista completa de modificadores

Sr. Não.	Modificador e descrição
1	i Torna a correspondência insensível a maiúsculas e minúsculas.
2	m Especifica que se a string tiver caracteres de nova linha ou de retorno de carro, os operadores ^ e $ agora corresponderão a um limite de nova linha, em vez de um limite de string.
3	o Avalia a expressão apenas uma vez.
4	s Permite o uso de. para corresponder a um caractere de nova linha.
5	x Permite que você use espaços em branco na expressão para maior clareza.
6	g Encontra globalmente todas as correspondências.
7	cg Permite que a pesquisa continue mesmo após a falha de uma correspondência global.

Correspondência apenas uma vez

Também existe uma versão mais simples do operador de correspondência - o? PATTERN? operador. Ele é basicamente idêntico ao operador m //, exceto que só corresponde uma vez dentro da string que você está procurando entre cada chamada para redefinir.

Por exemplo, você pode usar isso para obter o primeiro e o último elementos de uma lista -

#!/usr/bin/perl

@list = qw/food foosball subeo footnote terfoot canic footbrdige/;

foreach (@list) {
   $first = $1 if /(foo.*?)/;
   $last = $1 if /(foo.*)/;
}
print "First: $first, Last: $last\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

First: foo, Last: footbrdige

Variáveis ​​de Expressão Regular

Variáveis ​​de expressão regular incluem $, que contém a última correspondência de agrupamento correspondida; $&, que contém toda a string combinada; $`, que contém tudo antes da string correspondente; e$', que contém tudo após a string correspondente. O código a seguir demonstra o resultado -

#!/usr/bin/perl

$string = "The food is in the salad bar";
$string =~ m/foo/;
print "Before: $`\n";
print "Matched: $&\n";
print "After: $'\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Before: The
Matched: foo
After: d is in the salad bar

O Operador de Substituição

O operador de substituição, s ///, é realmente apenas uma extensão do operador de correspondência que permite substituir o texto correspondido por algum novo texto. A forma básica do operador é -

s/PATTERN/REPLACEMENT/;

O PADRÃO é a expressão regular para o texto que procuramos. O REPLACEMENT é uma especificação para o texto ou expressão regular que queremos usar para substituir o texto encontrado. Por exemplo, podemos substituir todas as ocorrências dedog com cat usando a seguinte expressão regular -

#/user/bin/perl

$string = "The cat sat on the mat";
$string =~ s/cat/dog/;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

The dog sat on the mat

Modificadores de operador de substituição

Aqui está a lista de todos os modificadores usados ​​com o operador de substituição.

Sr. Não.	Modificador e descrição
1	i Torna a correspondência insensível a maiúsculas e minúsculas.
2	m Especifica que se a string tiver caracteres de nova linha ou de retorno de carro, os operadores ^ e $ agora corresponderão a um limite de nova linha, em vez de um limite de string.
3	o Avalia a expressão apenas uma vez.
4	s Permite o uso de. para corresponder a um caractere de nova linha.
5	x Permite que você use espaços em branco na expressão para maior clareza.
6	g Substitui todas as ocorrências da expressão encontrada pelo texto de substituição.
7	e Avalia a substituição como se fosse uma instrução Perl e usa seu valor de retorno como o texto de substituição.

O operador de tradução

A tradução é semelhante, mas não idêntica, aos princípios da substituição, mas ao contrário da substituição, a tradução (ou transliteração) não usa expressões regulares para sua pesquisa em valores de substituição. Os operadores de tradução são -

tr/SEARCHLIST/REPLACEMENTLIST/cds
y/SEARCHLIST/REPLACEMENTLIST/cds

A tradução substitui todas as ocorrências dos caracteres em SEARCHLIST pelos caracteres correspondentes em REPLACEMENTLIST. Por exemplo, usando o "O gato sentou no tapete". string que temos usado neste capítulo -

#/user/bin/perl

$string = 'The cat sat on the mat';
$string =~ tr/a/o/;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

The cot sot on the mot.

Os intervalos de Perl padrão também podem ser usados, permitindo que você especifique intervalos de caracteres por letra ou valor numérico. Para alterar o caso da string, você pode usar a seguinte sintaxe no lugar douc função.

$string =~ tr/a-z/A-Z/;

Modificadores de operador de tradução

A seguir está a lista de operadores relacionados à tradução.

Sr. Não.	Modificador e descrição
1	c Complementa SEARCHLIST.
2	d Exclui caracteres encontrados, mas não substituídos.
3	s Squashes duplicam caracteres substituídos.

O modificador / d exclui os caracteres correspondentes a SEARCHLIST que não possuem uma entrada correspondente em REPLACEMENTLIST. Por exemplo -

#!/usr/bin/perl 

$string = 'the cat sat on the mat.';
$string =~ tr/a-z/b/d;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

b b   b.

O último modificador, / s, remove as sequências duplicadas de caracteres que foram substituídos, portanto -

#!/usr/bin/perl

$string = 'food';
$string = 'food';
$string =~ tr/a-z/a-z/s;

print "$string\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

fod

Expressões regulares mais complexas

Você não precisa apenas combinar em strings fixas. Na verdade, você pode corresponder a praticamente qualquer coisa com que poderia sonhar, usando expressões regulares mais complexas. Aqui está uma ficha rápida -

A tabela a seguir lista a sintaxe da expressão regular que está disponível em Python.

Sr. Não.	Padrão e Descrição
1	^ Corresponde ao início da linha.
2	$ Corresponde ao fim da linha.
3	. Corresponde a qualquer caractere único, exceto nova linha. Usar a opção m permite que ele corresponda a nova linha também.
4	[...] Corresponde a qualquer caractere único entre colchetes.
5	[^...] Corresponde a qualquer caractere único que não esteja entre colchetes.
6	* Corresponde a 0 ou mais ocorrências da expressão anterior.
7	+ Corresponde a 1 ou mais ocorrências da expressão anterior.
8	? Corresponde a 0 ou 1 ocorrência da expressão anterior.
9	{ n} Corresponde exatamente ao número n de ocorrências da expressão anterior.
10	{ n,} Corresponde a n ou mais ocorrências da expressão anterior.
11	{ n, m} Corresponde a pelo menos n e no máximo m ocorrências da expressão anterior.
12	a| b Corresponde a a ou b.
13	\w Corresponde a caracteres de palavras.
14	\W Corresponde a caracteres que não sejam palavras.
15	\s Corresponde ao espaço em branco. Equivalente a [\ t \ n \ r \ f].
16	\S Corresponde a espaços não brancos.
17	\d Corresponde aos dígitos. Equivalente a [0-9].
18	\D Corresponde a nondigits.
19	\A Corresponde ao início da string.
20	\Z Corresponde ao final da string. Se houver uma nova linha, ela corresponderá imediatamente antes da nova linha.
21	\z Corresponde ao final da string.
22	\G As partidas apontam onde a última partida terminou.
23	\b Corresponde aos limites da palavra quando fora dos colchetes. Corresponde ao backspace (0x08) quando entre colchetes.
24	\B Corresponde a limites sem palavras.
25	\n, \t, etc. Corresponde a novas linhas, retornos de carro, guias, etc.
26	\1...\9 Corresponde à enésima subexpressão agrupada.
27	\10 Corresponde à enésima subexpressão agrupada, se já houver correspondência. Caso contrário, refere-se à representação octal de um código de caractere.
28	[aeiou] Corresponde a um único caractere no conjunto fornecido
29	[^aeiou] Corresponde a um único caractere fora do conjunto fornecido

O ^ metacaractere corresponde ao início da string e o $ metasymbol corresponde ao final da string. Aqui estão alguns exemplos breves.

# nothing in the string (start and end are adjacent)
/^$/   

# a three digits, each followed by a whitespace
# character (eg "3 4 5 ")
/(\d\s) {3}/  

# matches a string in which every
# odd-numbered letter is a (eg "abacadaf")
/(a.)+/  

# string starts with one or more digits
/^\d+/

# string that ends with one or more digits
/\d+$/

Vamos dar uma olhada em outro exemplo.

#!/usr/bin/perl

$string = "Cats go Catatonic\nWhen given Catnip";
($start) = ($string =~ /\A(.*?) /);
@lines = $string =~ /^(.*?) /gm;
print "First word: $start\n","Line starts: @lines\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

First word: Cats
Line starts: Cats When

Limites correspondentes

o \bcorresponde a qualquer limite de palavra, conforme definido pela diferença entre a classe \ w e a classe \ W. Como \ w inclui os caracteres de uma palavra e \ W o oposto, isso normalmente significa o término de uma palavra. o\Bassertion corresponde a qualquer posição que não seja um limite de palavra. Por exemplo -

/\bcat\b/ # Matches 'the cat sat' but not 'cat on the mat'
/\Bcat\B/ # Matches 'verification' but not 'the cat on the mat'
/\bcat\B/ # Matches 'catatonic' but not 'polecat'
/\Bcat\b/ # Matches 'polecat' but not 'catatonic'

Selecionando Alternativas

O | caractere é como o padrão ou bit a bit OR em Perl. Ele especifica correspondências alternativas dentro de uma expressão regular ou grupo. Por exemplo, para corresponder a "gato" ou "cachorro" em uma expressão, você pode usar isto -

if ($string =~ /cat|dog/)

Você pode agrupar elementos individuais de uma expressão para oferecer suporte a correspondências complexas. Pesquisar o nome de duas pessoas pode ser feito com dois testes separados, como este -

if (($string =~ /Martin Brown/) ||  ($string =~ /Sharon Brown/))

This could be written as follows

if ($string =~ /(Martin|Sharon) Brown/)

Combinação de agrupamento

Do ponto de vista da expressão regular, não há diferença entre, exceto, talvez, que o primeiro seja ligeiramente mais claro.

$string =~ /(\S+)\s+(\S+)/;

and 

$string =~ /\S+\s+\S+/;

No entanto, o benefício do agrupamento é que ele nos permite extrair uma sequência de uma expressão regular. Os agrupamentos são retornados como uma lista na ordem em que aparecem no original. Por exemplo, no fragmento a seguir, retiramos as horas, minutos e segundos de uma string.

my ($hours, $minutes, $seconds) = ($time =~ m/(\d+):(\d+):(\d+)/);

Além desse método direto, os grupos correspondentes também estão disponíveis nas variáveis ​​especiais $ x, onde x é o número do grupo na expressão regular. Podemos, portanto, reescrever o exemplo anterior da seguinte forma -

#!/usr/bin/perl

$time = "12:05:30";

$time =~ m/(\d+):(\d+):(\d+)/;
my ($hours, $minutes, $seconds) = ($1, $2, $3);

print "Hours : $hours, Minutes: $minutes, Second: $seconds\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Hours : 12, Minutes: 05, Second: 30

Quando grupos são usados ​​em expressões de substituição, a sintaxe $ x pode ser usada no texto de substituição. Assim, poderíamos reformatar uma string de data usando este -

#!/usr/bin/perl

$date = '03/26/1999';
$date =~ s#(\d+)/(\d+)/(\d+)#$3/$1/$2#;

print "$date\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

1999/03/26

The \ G Assertion

A asserção \ G permite que você continue pesquisando a partir do ponto onde ocorreu a última correspondência. Por exemplo, no código a seguir, usamos \ G para que possamos pesquisar a posição correta e, em seguida, extrair algumas informações, sem ter que criar uma expressão regular única mais complexa -

#!/usr/bin/perl

$string = "The time is: 12:31:02 on 4/12/00";

$string =~ /:\s+/g;
($time) = ($string =~ /\G(\d+:\d+:\d+)/);
$string =~ /.+\s+/g;
($date) = ($string =~ m{\G(\d+/\d+/\d+)});

print "Time: $time, Date: $date\n";

Quando o programa acima é executado, ele produz o seguinte resultado -

Time: 12:31:02, Date: 4/12/00

A asserção \ G é na verdade apenas o meta-símbolo equivalente da função pos, portanto, entre as chamadas de expressões regulares, você pode continuar a usar pos e até mesmo modificar o valor de pos (e, portanto, \ G) usando pos como uma sub-rotina de lvalue.

Exemplos de expressões regulares

Caracteres literais

Sr. Não.	Exemplo e descrição
1	Perl Combine "Perl".

Classes de personagens

Sr. Não.	Exemplo e descrição
1	[Pp]ython Corresponde a "Python" ou "python"
2	rub[ye] Corresponde a "ruby" ou "rube"
3	[aeiou] Corresponde a qualquer vogal minúscula
4	[0-9] Corresponde a qualquer dígito; igual a [0123456789]
5	[a-z] Corresponde a qualquer letra ASCII minúscula
6	[A-Z] Corresponde a qualquer letra ASCII maiúscula
7	[a-zA-Z0-9] Corresponde a qualquer um dos anteriores
8	[^aeiou] Corresponde a qualquer coisa que não seja uma vogal minúscula
9	[^0-9] Corresponde a qualquer coisa diferente de um dígito

Classes de personagens especiais

Sr. Não.	Exemplo e descrição
1	. Corresponde a qualquer caractere, exceto nova linha
2	\d Corresponde a um dígito: [0-9]
3	\D Corresponde a um não dígito: [^ 0-9]
4	\s Corresponde a um caractere de espaço em branco: [\ t \ r \ n \ f]
5	\S Corresponde a espaços não-brancos: [^ \ t \ r \ n \ f]
6	\w Corresponde a um caractere de palavra única: [A-Za-z0-9_]
7	\W Corresponde a um caractere diferente de palavra: [^ A-Za-z0-9_]

Casos de Repetição

Sr. Não.	Exemplo e descrição
1	ruby? Corresponde a "rub" ou "ruby": o y é opcional
2	ruby* Corresponde a "rub" mais 0 ou mais ys
3	ruby+ Corresponde a "esfregar" mais 1 ou mais ys
4	\d{3} Corresponde exatamente a 3 dígitos
5	\d{3,} Corresponde a 3 ou mais dígitos
6	\d{3,5} Corresponde a 3, 4 ou 5 dígitos

Repetição Nongreedy

Isso corresponde ao menor número de repetições -

Sr. Não.	Exemplo e descrição
1	<.*> Repetição gananciosa: corresponde a "<python> perl>"
2	<.*?> Nongreedy: corresponde a "<python>" em "<python> perl>"

Agrupando com parênteses

Sr. Não.	Exemplo e descrição
1	\D\d+ Nenhum grupo: + repete-se \ d
2	(\D\d)+ Agrupado: + repete \ D \ d par
3	([Pp]ython(, )?)+ Corresponde a "Python", "Python, python, python" etc.

Referências anteriores

Isso corresponde a um grupo anteriormente correspondido novamente -

Sr. Não.	Exemplo e descrição
1	([Pp])ython&\1ails Corresponde a python & pails ou Python & Pails
2	(['"])[^\1]*\1 String entre aspas simples ou duplas. \ 1 corresponde a tudo o que o primeiro grupo correspondeu. \ 2 corresponde ao que o 2º grupo correspondeu, etc.

Alternativas

Sr. Não.	Exemplo e descrição
1	python|perl Corresponde a "python" ou "perl"
2	rub(y|le)) Corresponde a "rubi" ou "rublo"
3	Python(!+|\?) "Python" seguido por um ou mais! ou um?

Âncoras

Esta necessidade de especificar posições de correspondência.

Sr. Não.	Exemplo e descrição
1	^Python Corresponde a "Python" no início de uma string ou linha interna
2	Python$ Corresponde a "Python" no final de uma string ou linha
3	\APython Corresponde a "Python" no início de uma string
4	Python\Z Corresponde a "Python" no final de uma string
5	\bPython\b Corresponde a "Python" em um limite de palavra
6	\brub\B \ B é um limite sem palavras: corresponde a "esfregar" em "rube" e "ruby", mas não sozinho
7	Python(?=!) Corresponde a "Python", se seguido por um ponto de exclamação
8	Python(?!!) Corresponde a "Python", se não for seguido por um ponto de exclamação

Sintaxe especial com parênteses

Sr. Não.	Exemplo e descrição
1	R(?#comment) Corresponde a "R". Todo o resto é um comentário
2	R(?i)uby Não diferencia maiúsculas de minúsculas enquanto corresponde a "uby"
3	R(?i:uby) O mesmo que acima
4	rub(?:y|le)) Grupo apenas sem criar \ 1 referência anterior