Tutorial de Expressões Regulares em

Perl

EXPRESSÕES REGULARES Tutorial Linguagem Perl - 8

Generalidades

Expressões Regulares são padrões de procura definidos para caracteres

e cadeias de caracteres (strings). Com a ajuda destes padrões pode-se,
por exemplo, pesquisar e processar o conteúdo de variáveis. Para tarefas
de CGI, as expressões regulares são de importância vital. Os
componentes de um fluxo de dados de um formulário HTML que seja
enviado a um programa CGI, por exemplo, podem ser identificados
através do uso das expressões regulares. Da mesma forma, com a ajuda
de expressões regulares, é possível fazer a leitura ordenada de arquivos
(por exemplo, de um livro de visitas) de acordo com a convenção
utilizada e transmitir os dados como código HTML a um navegador
requisitante.E, finalmente, as expressões regulares constituem um meio
poderoso de procura de expressões complexas em grandes volumes de
dados.

Para os principiantes, aliás, as expressões regulares parecem estranhas

e são o motivo pelo qual alguns scripts Perl contenham sequências de
caracteres crípticos de aparência ameaçadora. Quem, por acaso, souber
lidar com o comando UNIX grep, não terá dificuldades em se ambientar
com as expressões regulares da Perl.

Utilizando expressões regulares

Para poder usar as expressões regulares é necessário conhecer todas as

possibilidades que elas oferecem.

Exemplo 1:

#!/usr/bin/perl
$Dados = $ENV{'PATH'};
if($Dados =~ /PERL/) # Contém a sequência de caracteres 'PERL'? {
print "Hehe, na sua variável PATH existe a palavra PERL!\n";
} else {

1/9
 print "Infelizmente, na sua variável PATH não existe a palavra PERL!\n";
}

Exemplo 2:

#!/usr/bin/perl
@Cidades = ( "Sampa", "Paris", "Londres", "Madri", "Atenas", "Roma",
"Lisboa", "Estocolmo", "Kopenhagen");
for(@Cidades) {
if(/[MKS]/) # Todas cidades que contenham 'M', 'K' ou 'S'
{
print "A cidade ", $_, " corresponde ao modelo de busca\n";
}
}

Exemplo 3:

#!/usr/bin/perl
open(ARQUIVOLOG,"<access.log");
while(<ARQUIVOLOG>) {
/index.htm/ ? $Acessos = $Acessos + 1 : $Acessos = $Acessos;
}
print $Acessos, " Acessos do arquivo index.htm!\n";
close(ARQUIVOLOG);

2/9
( 1) /a/ # encontra 'a'
( 2) /[ab]/ # encontra 'a' ou 'b'
( 3) /[A-Z]/ # encontra todas as letras maiúsculas
( 4) /[0-9]/ # encontra números
( 5) /\d/ # encontra números - como em (4)
( 6) /\D/ # encontra tudo exceto números
( 7) /[0-9]\-/ # encontra números ou o sinal de menos
( 8) /[\[\]]/ # encontra tudo que estiver contido em colchetes [ ]
( 9) /[a-zA-Z0-9_]/ # encontra letras, números ou sinal de sublinhado
(10) /[\w]/ # encontra letras, números ou sinal de sublinhado -
como em (9)
(11) /[\W]/ # encontra tudo, exceto letras, números e sinal de
sublinhado
(12) /[\r]/ # encontra o sinal de retorno de carro (típico do
DOS)
(13) /[\n]/ # encontra o sinal para quebra de linha
(14) /[\t]/ # encontra o sinal de tabulação (tab)
(15) /[\f]/ # encontra o sinal para quebra de página
(16) /[\s]/ # encontra o sinal de espaço assim como os sinais
referidos de (12) a (15)
(17) /[\S]/ # encontra tudo, exceto sinal de espaço e os de
(12) a (15)
(18) /[^äöüÄÖÜ]/ # encontra todos os caracteres com umlaut
(19) /[^a-zA-Z]/ # encontra tudo que não contiver letras
(20) /[ab]/s # encontra 'a' ou 'b' também em várias linhas

Quando se pesquisa a existência de caracteres isolados em expressões

regulares, é necessário utilizar as contrabarras e os colchetes. Só quando
a procura for por um caracter único, como no exemplo (1), os colchetes
podem ser desprezados. Se diversos caracteres forem anotados sem
estarem entre colchetes, eles são interpretados como uma cadeia de
caracteres (string).

Quando a procura for por um grupo de determinados caracteres, estes

são simplesmente anotados entre colchetes - como no exemplo (2).

Quando se pesquisa um determinado contexto, por exemplo a primeira

3/9
metade do alfabeto ou números, marca-se o contexto desejado com um
caracter inicial seguido de um sinal de menos e do caracter final, como
mostram os exemplos (3) e (4).

Quando se deseja procurar um dos seguintes sinais, + - ? . * ^ $ ( ) [ ]

{ } | \, há a necessidade de precedê-los com uma barra invertida - como
mostrado nos exemplos (7) e (8).

Existem também padrões de pesquisa especiais, constituídos por uma

barra invertida e uma letra chave. Os exempos (5), (6) e de (10) a (17)
mostram estes padrões.

Uma procura negativa também pode ser efetuada. Para isso, utiliza-se o
acento circunflexo ^ antes do caracter ou contexto desejados. Uma
pesquisa deste tipo tem como resultado apenas as partes que não
contenham os caracteres indicados. Os exemplos (18) e (19) mostram
sua utilização.

Para procuras em mais de uma linha, a expressão regular precisa

terminar com um s. Veja o exemplo (20).

Expressões Regulares para Cadeias de Caracteres•

procurar por uma cadeia de caracteres específica
• procurar por uma cadeia de caracteres com operadores de
agrupamento (curingas - wildcards)
• procurar por grupo de caracteres no início ou no final de uma palavra
• procurar por grupo de caracteres no início ou no final de uma linha
Os exemplos a seguir são numerados, por exemplo, com (1). Esta
numeração não pertence às expressões regulares, serve apenas para
facilitar os esclarecimentos referentes aos exemplos.

4/9
( 1) /asa/ # encontra 'asa' - também 'casa' ou 'casamento'
( 2) /asa?/ # encontra 'asa', 'casa', 'casamento' e também 'as'
e 'asilo'
( 3) /a./ # encontra 'as' e 'ar'
( 4) /a+/ # encontra 'a' e 'aa' e 'aaaaa' - quantos houverem
( 5) /a*/ # encontra 'a' e 'aa' e 'aaaaa' e 'b' - nenhum ou
quantos 'a' houverem
( 6) /ca.a/ # encontra 'casa' e 'caça', mas não 'cansa'
( 7) /ca.+a/ # encontra 'casa', 'caça' e 'cansa'
( 8) /ca.?a/ # encontra 'casa', 'caça' e 'caso'
( 9) /x{10,20}/ # encontra sequências de 10 a 20 'x'
(10) /x{10,}/ # encontra sequências de 10 ou mais 'x'
(11) /x.{2}y/ # só encontra 'xxxy'
(12) /Clara\b/ # encontra 'Clara' mas não 'Clarinha'
(13) /\bassa/ # encontra 'assa' ou 'assado' mas não 'massa'
(14) /\bassa\b/ # encontra 'assa' mas não 'assado' e nem 'massa'
(15) /\bassa\B/ # encontra 'assado' mas não 'assa' e nem 'massa'
(16) /^Julia/ # encontra 'Julia' apenas no início do contexto da
pesquisa
(17) /Helena$/ # encontra 'Helena' apenas no final do contexto da
pesquisa
(18) /^\s*$/ # encontra linhas constituídas apenas por sinais
vazios ou similares
(19) /$Nome/ # encontra o conteúdo da escalar $Nome
(20) /asa/s # encontra 'asa', também em várias linhas

Para pesquisar a presença de determinada cadeia de caracteres (string)

numa expressão regular, basta incluí-la entre as duas barras da
expressão, como no exemplo (1).

Nas expressões regulares existem os assim chamados operadores de

agrupamento. Concatenados ou colocados em expressões mais
complexas, estes operadores permitem pesquisas com marcadores de
posição:

O ponto . é utilizado para indicar a posição exata de determinado

caracter - veja o exemplo (3). Se você vem do mundo DOS/Windows - o
5/9
ponto, numa expressão regular, corresponde ao ponto de interrogação
usado, por exemplo, numa pesquisa de nomes de arquivo.

O ponto de interrogação ?, integrando uma expressão regular, procura

pelo caracter precedente ou também não. Veja o exemplo (2).

O sinal de adição + significa: uma ou mais ocorrências do caracter

indicado antes do sinal. Veja o exemplo (4).

O sinal de multiplicação * significa: nenhuma, uma ou mais ocorrências

do caracter indicado antes do sinal. Veja o exemplo (5).

Quando se coloca um ponto . antes do sinal + ou *, gera-se um

marcador de posição. Corresponde ao curinga * do mundo DOS/Windows.
Veja os exemplos de (6) a (8).

Utiliza-se chaves contendo um ou dois números {n} para indicar a

repetição do caracter referido. Veja os exemplos de (9) a (11). Também é
possível colocar um ponto . antes das chaves. Neste caso, a expressão
significa: tantos do caracter indicado quanto consta entre chaves. Veja o
exemplo (11).

Pode-se pesquisar cadeias de caracteres que só serão encontradas se

estiverem no início ou no final de uma palavra. O contrário também é
possível, encontrar cadeias de caracteres só se não estiverem no início
ou no final de uma palavra.

Precedidas por \b, apenas serão encontradas as cadeias de caracteres

que estiverem no início de uma palavra.

Seguidas por \b, apenas serão encontradas as cadeias de caracteres que

estiverem no final de uma palavra.

Precedidas por \B, serão encontradas apenas as palavras que não forem
iniciadas pela cadeia de caracteres.

Seguidas por \B, serão encontradas apenas as palavras que não forem
terminadas pela cadeia de caracteres.

Os exemplos correspondentes são os de (12) a (15).

Pode-se procurar sequências de caracteres que, só serão localizadas, se

estiverem no início ou no final de um contexto de procura. Isto é
particularmente interessante associado com linhas de arquivos de texto.

6/9
Com o acento cinrcunflexo ^ no início da expressão de procura, a
sequência de caracteres só é encontrada se estiver no início de uma
linha.

Com um cifrão $ no final da expressão de procura, a sequência de

caracteres só é encontrada se estiver no final da linha.

Os exemplos de (16) a (18) demonstram essas posssibilidades.

As expressões de procura também podem conter variáveis. Dessa forma,

é possível inserir dados dinâmicos nos padrões de procura. Numa CGI,
por exemplo, pode-se incluir no padrão de procura uma entrada feita por
um usuário num campo de formulário. Veja o exemplo (19).
Para pesquisar em mais de uma linha, anota-se um s após a barra de
fechamento da expressão regular. Verifique o exemplo (20).

Expressões Regulares com AlternativasPode-se aplicar mais de uma

expressão regular. Neste caso serão pesquisados pontos nos quais pelo
menos uma das alternativas seja encontrada. Exemplos:

/a|b/ # encontra 'a' ou 'b' - idêntico a /[ab]/

/com|sem/ # encontra 'com' e 'descompensar', como também
'sem' e 'semântica'

As alternativas são marcadas através do caracter |. No primeiro exemplo

acima mostra uma alternativa formulada com dois caracteres
individuais. Na prática, esse tipo de alternativa é raro porque o habitual
é utilizar a anotação /[ab]/, que tem o mesmo significado.

No segundo exemplo procura-se por uma sequência de caracteres com

duas alternativas. O resultado da busca traz todas as coincidências com
qualquer das duas alternativas. É claro que também se pode usar mais
de duas alternativas.

Nas expressões regulares com alternativas é permitido o uso de todas as

possibilidades das expressões regulares.

Precedência e uso de Parênteses nas Expressões RegularesOs

caracteres especiais contidos em expressões regulares são avaliados
pelo interpretador Perl numa sequência (precedência) determinada.

7/9
1. Precedência: ( ) (parênteses)
2. Precedência: + * ? {#,#} (operadores de agrupamento)
3. Precedência: abc ^$ \b \B (caracteres/cadeia de caracteres, início ou
término de linha, início ou término de palavras)
4. Precedência: | (alternativas)

Dessa forma, cada expressão regular tem uma interpretação única. Se

quisermos que a expressão regular seja interpretada de forma diferente
da precedência pré-determinada, utiliza-se parênteses para forçar a
sequência de interpretação desejada. Exemplos:

/a|bc|d/ # encontra 'a' ou 'bc' ou 'd'

/(a|b)(c|d)/ # encontra 'ac' ou 'ad' ou 'bc' ou 'bd'

De acordo com a regra de precedência, os caracteres (ou cadeias de

caracteres) têm prioridade sobre o caracter delimitador de alternativas.
Com a ajuda de parênteses, pode-se forçar uma precedência diferente
(analise o exemplo acima).

Expressões Parciais com ParêntesesCom a ajuda de parênteses é

possível armazenar porções de expressões regulares complexas e
referenciá-las posteriormente no interior da mesma expressão. Exemplo:
#!/usr/bin/perl

$Frase = "Onde estará o juiz... o juiz Lalau?";

if($Frase =~ /(\bjuiz\b).*\1/) {
print $1;
}

No exemplo, testa-se em $Frase uma ocorrência múltipla de 'juiz'.

Para isso, coloca-se entre parênteses o que se está procurando. No
exemplo está-se procurando por uma palavra única 'juiz', por isso a
formulação é /bjuiz/b. Esta expressão parcial é colocada entre
parênteses para que o interpretador Perl tome conhecimento da mesma.
Completa-se a diretiva com .*: após a palavra 'juiz' pode constar
qualquer coisa. Finalmente, a sintaxe \1 refencia a expressão entre
parênteses definida anteriormente. Isto quer dizer: quando o
interpretador Perl encontrar a palavra 'juiz', ele verifica se a palavra já
foi encontrada.

Se forem colocados duas ou mais expressões deste tipo numa expressão

regular, pode-se referenciar cada uma delas através de \1, \2, \3, etc.
8/9
Como resultado, passam a existir então as respectivas variáveis em Perl,
ou seja, $1, $2, $3, etc.
A diretiva print $1; no exemplo acima mostra o conteúdo da variável $1,
o qual é 'juiz' e nada mais, pois esta palavra ocorre mais de uma vez na
frase analisada.

9/9