O que fazem:

As expressões regulares servem para fazer o tratamento de strings.

As expressões regulares (re, no inglês) permitem que sejam feitas pesquisas completas ao longo de arquivos de texto e banco de dados.

Onde podemos usar:

• nFiltragem de dados.
• nTratamento/Transformação de dados.
• nInterpretadores.
• nCompiladores.
• nCorretores ortográficos.
• nTradutores de idiomas.
• nCensura de conteúdo.
• netc...

Por que PERL:

O processamento de texto é uma das mais poderosas capacidades de Perl e está capacidade se deve as expressões regulares.

O operador reconhecimento:

m//

O operador de reconhecimento, como o próprio nome diz, reconhece padrões.

Considere as seguintes strings:

$string1 = “Eu sou muito chato”;
$string2 = “Eu não vejo a hora de sair de casa”;
$string3 = “mas minha casa é tão longe.”

Considere os seguintes códigos:

$string1 =~ m/Eu/; #verdadeiro
$string1 =~ m/cha/; #verdadeiro
$string2 =~ m/a/; #verdadeiro
$string3 =~ m/z/; #falso
$string1 =~ m/casa/; #falso
$string2 =~ /casa/; #verdadeiro
$string3 =~ /casa/; #verdadeiro

No Código:

$string1 =~ m/Eu/;

O operador m//, procura pelo string “Eu” dentro da variável $string. Se achar devolve verdadeiro, se não falso.

Outro código:

$string = “onde está meu queijo?”;

if ( $string =~ /onde/ );
{
    print (“não sei”,“\n”);
}

print “achei” if $string =~ /queijo/;

O operadores de vínculos em PERL:

O operador de vínculo =~, rertona verdadeiro se o padrão for achado e o operador de vínculo !~, retorna verdadeiro se o padrão não for achado.

Usando contexto:

Se o operador de vínculo for omitido, o padrão é aplicado a variável $_

foreach (“aqui não”, “nem aqui”, “finalmente encontrou”)
{
    print if /encontrou/;
}

O operador de substituição:

s///

Além de reconhecer padrões, Perl permite substituições de padrões por strings:

Observe o código:

$string = “O mundo é complicado”;
$string =~ s/mundo/planeta/;
print $string;
#$string vale: “O planeta é complicado”

Caracteres especiais e classes de caracteres

Observe o seguinte código:

$string = “eu tenho 8 laranjas”;

if ( $string =~ /\d/ ) {
    print “ ‘$string’ possui um dígito”;
} else {
    print “ ‘$string’ não possui dígitos”;
}

if ( $string =~ /[0-9]/) {
    print “ ‘$string’ possui um dígito”;
}

O padrão \d é um caractere especial e representa qualquer número.

Os colchetes delimitam uma classe de caracteres a serem reconhecidos.

Alguns caracteres especiais:

Quantificadores

As expressões regulares possuem símbolos especiais que reconhecem mais de uma ocorrência do padrão.

Considere o reconhecimento do padrão '1\d*1' nas strings:

$string1 = “110001”;#vai ser V
$string2 = “1w1”;# vai ser F
$string3 = “111”;# vai ser V

Observe o quadro da sintaxe dos quantificadores:

Exemplo de tratamento de arquivo

Considere o seguinte arquivo

    http://www.araripina.com.br
2         http://www.uol.com.br
http://www.bol.com.br
            4     http://tux.lcc.ufrn.br/~iuri
                5 http://www.ufrn.br
    6 http://www.kernel.org
7         http://www.tucows.com

Nós queremos pegar somente as urls deste arquivo, vamos reconhecer os dados então:

• as linhas começam com espaços seguidos de um número e a url ou
• as linhas começam com espaços seguidos de um número, espaços e a url ou
• as linhas começam com espaços e a url ou
• as linhas só contém a url.

A solução para o problema seria apenas uma linha:

s/\s*\d*\s*//

Que quer dizer:

Substitua (zero ou mais espaços, seguidos de zero ou mais dígitos, seguidos de zero os mais espaços) por (nada).

Referências

Você já pensou que pode precisar de alguma coisa reconhecida no seu padrão em seu código?

Nas expressões regulares tudo que for reconhecido e estiver entre parênteses será atribuído a certas variáveis de Perl ($1, $2, $3,...):

$string = “Eu tenho 13 anos e meu nome é José”;
$string =~ /(\d+) anos/; #caso 1
$string =~ /nome é (\w+)/; #caso 2

O primeiro caso será verdadeiro e o padrão (\d+) reconhecerá “13” e, como está entre parênteses, jogará este valor para a variável $1.
O segundo caso também será verdadeiro e o padrão (\w+) reconhecerá “José” e jogará este valor para $1.
Para cada par de parênteses em uma expressão, seu reconhecimento será atribuído às variáveis $1, $2, $3,... respectivamente.

Expressões mais poderosas

Algo sobre asserções:

Asserções são caracteres especiais que contém tamanho zero.

As principais asserções são:

• ^ - reconhece o início de uma string.
• $ - reconhece o fim de uma string.

Algo sobre modificadores:

O operador s///, só substitui a primeira ocorrência do padrão, para substituir todas as ocorrências usa-se o modificador g. 

exemplo:

s/o/-/g; #substitui todas as letras o por -

Algo sobre alternâncias:

Alternâncias são métodos de reconhecer um padrão ou outro padrão em uma string, por exemplo:

m/(he|she|it) is/

Este padrão reconhece:

he is
she is
it is