Tweet
Quase tudo de Perl
A Linguagem de Programacão Perl
Introducão
PERL (Practical Extraction and Report Language ) foi criada por Larry Wall como uma linguagem de programação mais versátil para o desenvolvimento de programas que necessitem de tratamento de strings e a mais adequada para criação de scripts CGI nos servidores Web.
Perl é uma linguagem de programacao interpretada com um grande número de características que a tornam muito útil para manipulacão de dados textuais. Por isso é muito difundida para aplicacões Web, como CGI para servidores HTTP. Entre suas características, destacam-se:
Declaracão de variáveis implícita. O primeiro caracter distingue se a variavel é um escalar, um array ou um array associativo.
Strings e arrays não necessitam de definicão de tamanho. Dinâmicamente eles são criados pequenos e crescem conforme a necessidade.
Todas variáveis são inicializadas com um valor default.
Um conjunto muito rico de operacões de busca "padrões" em textos.
Um conjunto completo de funcões aritméticas.
Um conjunto de funcões internas à linguagem com diversas funcionalidades.
Uma sintaxe "exótica", semelhante em alguns aspectos à "C", mas bem diferente em outros.
Um filosofia de fazer o trabalho rápido e não de forma elegante.
Perl é interpretada, o que significa que a etapa de compilacão não é explicitamente necessária. Simplesmente se escreve o código fonte em um editor de texto qualquer e o processador Perl o converte a uma forma de representacão interna e o executa.
Executando um programa PERL
Para executar um programa PERL, ativa-se o interpretador passando como argumento o nome do arquivo que contem o programa. No prompt do DOS fariamos:
C:PERL PROG1.PL
Argumentos a serem passados para o programa devem ser escritos logo a seguir como:
C:PERL PROG1.PL DATA=10/01/1978
Caminho para o interpretador
Após instalar o interpretador PERL em sua máquina é preciso definir o caminho para o DOS poder encontrá-lo. Insira no arquivo AUTOEXEC.BAT o seguinte comando:
PATH=C:\PERL\BIN;%PATH%
Um programa PERL
Um programa PERL consiste de um grupo de instruções e chamadas de funções da linguagem PERL gravados em um arquivo ASCII (texto) cuja extensão deve ser .pl por convensão, mas isso não é necessário. Esta extensão permite que você reconheça que este é um programa PERL. Quando se trata de CGI, muitos servidores na Web podem exigir que a extensão seja .cgi ou .pl e que o programa resida num diretório especial chamado cgi-bin.
A primeira linha de um programa PERL deve ser a diretiva #!/usr/local/bin/perl para informar o sistema onde encontrar o interpretador PERL. Isso é necessário somente quando se usa PERL como CGI num servidor de Web, mas não é necessário quando se executa um programa em seu micro.
Outra consideração que deve ser levada em conta quando se trata de CGIs, é que, para o browser entender que tipo de arquivo está recebendo, é necessário que o primeiro comando "print" especifique o cabeçalho HTTP informando o tipo de arquivo que está sendo enviado. Assim, o primeiro comando "print" de todo CGI que envia uma página HTML a um browser deve ser:
print "Content-type: text/html\n\n";
Além disso, todo CGI deve enviar pelo menos uma linha HTML ao browser ou um erro ocorrerá.
Certos comandos em PERL, exigem que comandos ou funções subsequentes sejam declarados entre chaves { e }.
Exemplo
#!/usr/local/bin/perl
print "Programa teste";
for($n=0;$n>=10;$n++)
{
print $n,"\n";
}
No exemplo acima, o programa PERL irá imprimir a mensagem "Programa teste" no monitor do computador. Após isso, fará com que $n varie de 0 a 10 imprimindo cada valor após uma nova linha. Note que o comando termina por um ponto e vírgula. Aqui vemos a primeira regra na programação PERL : todos os comandos PERL devem terminar por ponto e vírgula.
Tipos de dados
PERL não necessita que se declare as variáveis antes de usá-las. Uma variável é gerada dinamicamente quando a referenciamos. As variáveis podem ser de tres tipos apenas: escalares , arrays e arrays associativos.
Escalares
As variáveis escalares começam com um símbolo $ seguido de uma sequência de caracteres, como $data, $contador, $cor_de_fundo, etc. Deve-se evitar o uso de variáveis como $1, $2, etc, pois em PERL elas têm significado especial. Além disso, os escalares podem ser do tipo inteiro, ponto flutuante ou string, mas não é necessário especificar isso em PERL pois o interpretador se incumbe de gerar o tipo adequado de acôrdo com o contexto. $nome = "Jose da Silva"; define um escalar string "Jose da Silva"
$contador = 125; define um escalar inteiro 125
$contador = 3.1416; define um escalar em ponto flutuante 3.1416
Arrays
As variáveis do tipo array começam com o simbolo @ e seguem a mesma regra para as variáveis escalares. Na verdade, um array é um conjunto de escalares.
@cores = ("azul","verde", "amarelo","vermelho"); define array de strings
@loto = (12,15,23,31,42); define um array de inteiros
Os elementos de um array são acessados por um índice cujo valor para o primeiro elemento é zero. Para acessarmos a cor verde do exemplo acima, escreveriamos $cores[1]. Isso mesmo, quando nos referimos a um elemento do array, usamos o símbolo $ ao invés de @. O índice 1, entre colchetes, dá acesso ao valor do elemento que é "verde". Além disso, para sabermos quantos elementos um array possui, usamos a forma $# como prefixo do nome do array. Tomemos como exemplo o array @loto acima. Esse array possui 5 (cinco) elementos, isto é, $loto[0]=12, $loto[1]=15, $loto[2]=23, $loto[3]=31 e $loto[4]=42. Assim, a variável $#loto contem o valor 5.
Se quisermos imprimir quantos elementos possui esse array, devemos chamar a função print da seguinte maneira:
print "O array contem ",$#loto," elementos\n";
Isso imprimirá no monitor do computador:
O array contem 5 elementos"
É bom ir se acostumando a usar o comando print pois ele será muito usado daqui para frente. Note que você pode especificar várias coisas dentro de uma chamada à função print, como fizemos acima: primeiro, especificamos a string "O array contem " seguida de uma vírgula que serviu para separar a declaração seguinte que é $#loto, uma variável que tem o número de elementos do array @loto e que foi substituido pelo número 5 quando a mensagem foi impressa. Depois, usamos mais uma vírgula e escrevemos a string " elementos\n" e terminamos com um ponto e vírgula. O \n informa o sistema para iniciar uma nova linha após a impressão da mensagem. Se \n não fosse especificado, a próxima mensagem a ser impressa sairia grudada na mensagem anterior.
Arrays associativos
Já vimos que, num array comum, cada elemento é indexado por um valor numérico como $loto[3]. Nos arrays associativos os elementos são indexados por strings, mais conhecidos como chaves. Um array associativo é definido usando-se o caracter % como prefixo do nome do array. Vejamos um exemplo:
%cadastro = ("nome","Jose","endereco","Rua Azul","telefone","126126126");
A declaração acima associa a chave nome ao valor Jose, a chave endereco ao valor Rua Azul e a chave telefone ao valor 126126126. Portanto, se quisermos nos referir a qualquer um dos elementos do array, devemos usar as seguintes declarações:
$cadastro{'nome'} para obtermos Jose
$cadastro{'endereco'} para obtermos Rua Azul
$cadastro{'telefone'} para obtermos 126126126
Note que a referência ainda é feita usando-se o caracter $ como prefixo do array, ao invés de % usado na sua definição. Além disso, o nome da chave é especificada entre aspas e dentro de { }.
Podemos, ainda, usar um escalar contendo o nome da chave para nos referenciarmos a um valor do array:
$n = "nome"; # atribui o valor "nome" ao escalar $n
print $cadastro{$n},"\n"; # imprime Jose no monitor do computador
$n = "endereco"; # atribui o valor "endereco" ao escalar $n
print $cadastro{$n},"\n"; # imprime Rua Azul no monitor do computador
$n = "telefone"; # atribui o valor "telefone" ao escalar $n
print $cadastro{$n},"\n"; # imprime 126126126 no monitor do computador
Comentários
Qualquer coisa escrita após o caracter # será considerada como comentário pelo interpretador PERL. Habitue-se a escrever comentários dentro de seus programas porque isso facilita muito na hora de fazer uma alteração.
Arquivos
Para operar com arquivos, Perl possui um tipo especial de variável que se chama Handle de arquivo. Um Handle é, na verdade, um ponteiro para o arquivo que PERL deve ler ou gravar.
Arquivos predefinidos
PERL possui tres Handles de arquivos especiais, predefinidos:
STDIN Entrada padrão (teclado)
STDOUT Saída padrão (monitor de vídeo)
STDERR Mensagens de erro (monitor de vídeo)
Toda vez que se usa o comando print "....."; sem que se especifique o Handle de arquivo, o resultado será enviado a STDOUT, o mesmo se dando com o comando read que lerá obterá a entrada do teclado STDIN.
Note que os Handles devem ser escritos com letras maiúsculas.
Abrindo e fechando arquivos
Para que um arquivo possa ser acessado, antes é necessário abrí-lo. Em PERL isso é feito usando-se a função open. A função open define o Handle de arquivo a ser utilizado e o modo como o arquivo será processado, isto é, se o arquivo será lido ou gravado.
A função open tem o seguinte formato:
open(handle,"nome do arquivo");
Por exemplo:
open(CADASTRO,"<cadastro.txt"); CADASTRO é o Handle do arquivo
o caracter < antes do nome do arquivo, significa que o arquivo está sendo aberto para leitura.
cadastro.txt é o nome do arquivo. Para arquivos residentes em outros diretórios, diferentes daquele onde se encontra o programa PERL, deve-se especificar o path completo.
Após utilizarmos o arquivo, este deve ser fechado com o a função close.
close(CADASTRO);
Do mesmo modo que especificamos o caracter < na frente do nome do arquivo, para dizer que ele será aberto para leitura, outros caracteres são usados para abrir arquivos para serem gravados ou ampliados. A tabela a seguir mostra essas variações:
Caracter Significado Exemplos e comentários
< Abre arquivo para leitura. open(ARQ1,"<texto.txt");
ou
open(ARQ1,"texto.txt");
Não é nexessário especificar o caracter <. Qualquer arquivo aberto sem a especificação de modo, será aberto para leitura.
> Abre arquivo para gravação. open(ARQ1,">texto.txt");
Se o arquivo já existir, ele será regravado e seus dados anteriores serão perdidos. Se o arquivo não existir, um novo arquivo será criado.
>> Abre arquivo para ampliação. open(ARQ1,">>texto.txt");
Se o arquivo já existir, os novos dados serão inseridos no final desse arquivo. Se o arquivo não existir, um novo arquivo será criado.
+< Abre arquivo para leitura e gravação. open(ARQ1,"+<texto.txt");
Pode-se ler e gravar no mesmo arquivo.
+> Abre arquivo para leitura e gravação. open(ARQ1,"+>texto.txt");
Pode-se ler e gravar no mesmo arquivo.
Lendo um arquivo
Para ler um arquivo, PERL tem um operador especial que consiste em colocar o Handle entre os caracteres < e > deste modo: <CADASTRO>. Podemos, então, atribuir a uma variável escalar ou a um array os registros provindos de um arquivo. Veja os exemplos abaixo:
$registro = <CADASTRO> Lê um registro do arquivo e o coloca na variável $registro
@matriz = <CADASTRO> Lê todos os registros do arquivo, de uma só vez, e armazena-os no array @matriz.
Após isso, pode-se obter os registros usando-se o método estudado para os arrays.
Gravando um arquivo novo
A gravação de um arquivo novo, implica em usarmos o caracter > na frente do nome do arquivo durante sua abertura. Além disso, para gravarmos um arquivo, usamos a função print usando como primeiro argumento o Handle do arquivo.
Exemplo:
open(CORES,">cores.txt"); # abre arquivo para gravação
@cores = ("azul","verde","amarelo","vermelho"); # gera array com os nomes das cores
foreach $i (@cores) # para cada cor no array
{ # inicio do bloco foreach
print CORES $cores[$i],"\n"; # grava um registro no arquivo
} # fim do bloco foreach
close(CORES); # fecha o arquivo
Ampliando um arquivo existente
A ampliação de um arquivo, implica em usarmos os caracters >> na frente do nome do arquivo durante sua abertura. Para gravarmos novos registros no arquivo, também usamos a função print.
Como exemplo, vamos ampliar o arquivo do exemplo anterior:
open(CORES,">>cores.txt"); # abre arquivo para ampliação
@cores = ("branco","rosa","violeta","laranja"); # gera array com os nomes das cores
foreach $i (@cores) # para cada cor no array
{ # inicio do bloco foreach
print CORES $cores[$i],"\n"; # grava um registro no arquivo
} # fim do bloco foreach
close(CORES); # fecha o arquivo
Controlando o fluxo
PERL fornece todos os controles de fluxo necessários a uma linguagem de programação. De início vamos dar uma olhada em dois operadores lógicos que facilitarão o entendimento dos comandos de controle de fluxo. São eles o OU, representado pelos símbolos "||" (duas barras verticais), e o E, representado pelos símbolos "&&". Esses dois operadores usam dois operandos e retornam o valor Falso ou Verdadeiro, dependendo dos operandos. Por exemplo:
$x = $a || $b; leia-se $x = $a OU $b
$x será Falso se $a e $b forem falsos. $x será Verdadeiro se $a for verdadeiro e $b for falso. $x será Verdadeiro se $a for falso e $b for verdadeiro.
Confuso? Bem, tentemos simplificar isso: na expressão acima, $a e $b são avaliados internamente de acordo com as definições da álgebra Booleana e o resultado será colocado em $x. A tabela abaixo mostra as principais operações da álgebra Booleana:
Seja F falso e V verdadeiro
Operação OU
(OR) V OR V = V
V OR F = V
F OR V = V
F OR F = F
Operação E
(AND) V AND V = V
V AND F = F
F AND V = F
F AND F = F
Operação OU
Exclusivo
(XOR) V XOR V = F
V XOR F = V
F XOR V = V
F XOR F = F
Vejamos agora a expressão $x = ($a > 1) && ($b < 10):
$x será verdadeiro se, e somente se, $a for maior do que 1 E $b for menor do que 10.
$x será falso quando $a for menor ou igual a 1 ou quando $b for maior ou igual a 10.
O que se deve notar aqui, é a lógica de avaliação da expressão. PERL não fará a avaliação da segunda parte da expressão ($b < 10) se a primeira parte for falsa pois, conforme a tabela de operações Booleanas acima, para a operação E, toda vez que o primeiro operando é falso, o resuldato será falso. Isso dá ao PERL uma vantagem não encontrada em outras linguagens, que é a capacidade de executar, ou não, comandos dentro de avaliações lógicas do tipo da expressão acima. Vejamos então:
$x < 20 || print "X maior ou igual a 20\n";
Neste caso, a primeira parte da expressão é avaliada e, se ela for falsa, isto é, se $x for maior ou igual a 20, então a segunda parte da expressão terá que ser avaliada para saber se ela é verdadeira (veja operação OU na tabela), mas, como a segunda parte da expressão é uma chamada para a função print, ela imprimirá a mensagem "X maior ou igual a 20" no monitor do computador.
Operadores Relacionais
Os operadores relacionais são símbolos usados entre os operandos nas expressões condicionais. Em PERL existe uma diferença entre o contexto numérico e o contexto de string no que diz respeito ao uso dos operadores relacionais, isto é, uma comparação entre duas variáveis numéricas deve ser feita da seguinte maneira: if($x == $y)..... enquanto uma comparação entre duas variáveis string seria: if($a eq $b)..... A tabela abaixo mostra todos os operadores relacionais para serem usados em ambos os contextos:
Operador Contexto númerico Contexto string
Igualdade == eq
Desigualdade != ne
Maior do que > gt
Maior ou igual a >= ge
Menor do que < lt
Menor ou igual a <= le
if elseif else
Após a expressão entre parenteses for verdadeira, as declarações entre chaves ({ }) serão executadas. Se a expressão entre parenteses for falsa, então o controle será passado para a declaração que segue o fechamento da chave. Exemplo:
if($x >= $y) {
print "X e maior ou igual a Y\n";
}
Os operadores elseif e else podem ser usados quando várias opções necessitam ser testadas:
if($x = $y) {
print "X e igual a Y\n";
}
elseif($x > 0) {
print "X e maior do que zero\n";
}
else {
print "X e diferente de Y e menor do que zero\n";
}
unless
A declaração a esquerda não será executada se a expressão for verdadeira
print "X e menor do que 20\n" unless $x >= 20;
Para facilitar o entendimento, leia a declaração acima como: imprima "X é menor do que 20" a não ser que $x seja maior ou igual a 20. Note também que não há ponto-e-vírgula após \n.
while
As declarações entre chaves { } serão executadas enquanto a expressão entre parenteses for verdadeira.
while($x <= 10) {
print "X=",$x,\n";
$x++;
}
print "Fim\n";
Traduzindo: o programa inicializa a variável $x em 0. Logo após, testa, no comando while, se $x é menor do que 10. Como isto é verdadeiro, pois $x ainda é zero, a instrução print será executada imprimindo "X=0". Após a impressão, soma-se 1 na variável $x com o comando $x++, dando como resultado $x=1. Novamente o controle é passado para a linha while que fára um novo teste com a variável $x. Isso vai acontecer até que $x fique com o valor 11, quando o teste resultará em falso e, portanto o controle será passado para a instrução após a última chave que imprimirá "Fim".
until
A instrução until executa uma série de declarações entre chaves até que a expressão entre parenteses seja verdadeira.
until($x >= 20) {
print "X=",$x,"\n";
$x++;
}
O programa acima incrementará e imprimirá os valores de $x até que este atinja o valor 20.
Outra maneira de se usar a instrução until é mostrada abaixo, onde a declaração do lado esquerdo será executada até que a expressão do lado direito seja verdadeira.
$x = 0;
$x++ until $x <= 100;
No exemplo acima, fazemos inicialmente $x=0. Após isso, será somado 1 em $x ($x++) até que $x atinja o valor 100.
for
Na instrução for coloca-se entre parenteses as condições para as quais ela deverá executar as declarações entre as chaves. Nos argumentos entre parenteses, são colocados, em primeiro lugar, uma variável contadora com o valor de início de contagem. Em segundo lugar, será informado o valor limite da variável contadora e, em terceiro lugar, o incremento da variável contadora. Todos os argumentos devem ser separados por ponto e vírgula.
for ($x = 100;$x <= 200;$x+10) {
print "X = ",$x,"\n";
}
No exemplo acima, inicializa-se a variável $x com o valor 100, estabelece-se o limite de contagem em 200 e incrementa-se $x de 10 em 10. Esse programa imprimirá os valores de $x de 100 a 200 de 10 em 10, ou seja, 100, 110, 120, 130 ....... 200.
foreach
A instrução foreach é especialmente projetada para operações com arrays. Do mesmo modo que a instrução for, ela executa as declarações entre as chaves.
@cores = ("azul","verde","amarelo","vermelho");
foreach $cor (@cores) {
print $cor,"\n";
}
Na primeira vez, a variável $cor assume o valor "azul" que será impresso a seguir. Na segunda vez, assume o valor "verde" e assim por diante. Não é necessário que o programador se preocupe com o número de elementos do array porque foreach faz isso automaticamente.
Outra maneira de se usar a intrução foreach é através de um indexador numérico como no exemplo abaixo:
@cores = ("azul","verde","amarelo","vermelho");
foreach $x (0..$#cores) {
print $cores[$x],"\n";
}
Nesse exemplo, a variável $x assumirá todos os valores, de zero, que é o número do primeiro elemento do array, até 3, que é o número do último elemento.
Labels
Um Label consiste de uma palavra, escrita em letras maiúsculas e seguida de dois-pontos que é usada para marcar um lugar dentro de um programa. Os Labels são geralmente usados nas instruções while, for e foreach em conjunto com as declarações next, last e redo, a fim de permitir maior controle dos loops. Os labels são usados também pela instrução goto.
AQUI: for($n = 0;$n <= 100;$n++) {
next AQUI if($n % 2 != 0)
}
O exemplo acima imprime todos os números pares de 0 a 100. Quando $n for impar, a declaração next remete o controle para o label AQUI:. A tabela abaixo mostra as declarações de controle:
next Desvia para a próxima iteração marcada pelo label.
last Sai do loop.
redo Reexecuta o loop marcado pelo label a partir do início.
goto
A instrução goto desvia o controle para o label especificado. Raramente um programador PERL usa esta instrução pois PERL é uma linguagem estruturada onde tais construções devem ser evitadas como norma de boa programação.
AQUI: ..........
................
................
................
goto AQUI:;
Expressões regulares
Expressões regulares são conjuntos de regras que descrevem uma string genéricamente. Com as expressões regulares podemos fazer pesquisas muito complexas dentro de uma string em apenas uma linha de programa, dispensando a análise byte a byte empregada em outras linguagens.
Equiparação de padrões
Quando os ceracteres que formam uma string estão de acôrdo com as regras estabelecidas numa expressão regular, dizemos que a expressão regular é equiparada ao string. Os dois tipos básicos de equiparação são:
Equiparação: para saber se um determinado string corresponde a um padrão.
Substituição: para substituir partes de uma string por um determinado padrão.
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /Perl/) {
print "Existe a palavra Perl na string\n";
$r =~ s/Perl/C/g;
print $r,"\n";
}
A variável $r foi definida com o conteúdo 'estudar Perl da muito trabalho'. Agora queremos saber se dentro da string existe a palavra Perl. Usamos o comando if no qual escrevemos a equiparação $r =~ /Perl/ . Se a equiparação for verdadeira, o comando print será executado. Note que o operador de equiparação da expressão regular com a string agora é =~ e não ==. Note também que a expressão regular propriamente dita é colocada entre barras.
Após o comando print vemos o comando $r =~ s/Perl/C/g; que substituirá a palavra Perl pela letra C . Aqui vemos a função s que localizará a string contida entre a primeira e a segunda barra e a substituirá pela string contida entre a segunda e a terceira barra. A letra g após a última barra significa que a substituição será feita todas as vezes que a palavra Perl for encontrada dentro da variável $r.
Assertivas
As assertivas servem para delimitar o padrão que se deseja equiparar. Pose-se equiparar padrões no começo, no fim, e entre palavras.
Tabela de assertivas das expressões regulares
Assertivas equiparadas Exemplo Equivale a Não equivale a
^ início da string ^tra trave letra
$ fim da string lha$ malha malhado
\b limite de palavra por\bque por que porque
\B não limite de palavra por\Bque porque por que
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /trabalho$/) {
print "Frase terminada com a palavra \"trabalho\"\n";
$r =~ s/trabalho/prazer/g;
print $r,"\n";
}
No comando if a equiparação esta sendo feita com uma expressão que verifica se a frase termina com a palavra "trabalho". Note a assertiva $ no fim da palavra trabalho$. Como a equiparação é verdadeira, a linha $r =~ s/trabalho/prazer/g; substituirá "trabalho" por "prazer".
Átomos
Os Átomos são os componentes fundamentais na formação das expressões regulares.
Tabela de átomos das expressões regulares
Átomo Equipara Exemplo Equivale a Não equivale a
.
(ponto) qualquer caracter exceto nova linha l.a lha lar
lista de caracteres entre colchetes qualquer dos caracteres da lista ^[tr] trabalho metralha
expressão regular entre parênteses qualquer coisa que a expressão equipare ^a(x.x)b$ axaxb axxb
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /.a/) {
print "Frase contem o esperado\n";
$r =~ s/.a/xi/g;
print $r,"\n";
}
A expressão regular $r =~ /.a/ testa se existe qualquer caracter dentro da frase seguido pela letra a. Como a equiparação resulta verdadeira, todo caracter seguido da letra a, incluindo a própria letra a será substituido por xi.
Quantificadores
Quantificadores são sinais usados para modificar os átomos. Eles permitem dizer quantas vezes os átomos devem aparecer.
Tabela de quantificadores das expressões regulares
Quantificador Equipara Exemplo Equivale a Não equivale a
* zero ou mais ocorrências do átomo xy*z xz
xyz xyy
+ uma ou mais ocorrências do átomo xy+z xyz xz
? zero ou uma ocorrência do átomo xy?z xz
xyz xyyz
{n} n ocorrências do átomo xy{2}z xyyz xyyyz
{n,} pelo menos n ocorrências do átomo xy{2,}z xyyz
xyyyz xyz
{n,m} pelo menos n e no máximo m ocorrências do átomo xy{2,3}z xyyz xyyyz
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /e+/) {
print "Frase contem a letra \"e\"\n";
$r =~ s/e/x/g;
print $r,"\n";
}
A expressão $r =~ /e+/ testa se existe uma ou mais ocorrências do caracter "e" dentro da variável $r. Note o quantificador +, após p caracter e da expressão regular entre barras, que indica a verificação de uma ou mais ocorrências. Como a equiparação é verdadeira, a expressão $r =~s/e/x/g; substituirá todas os caracteres e pelo caracter x.
Caracteres especiais
Caracteres especiais devem ser especificados por barras inversas \ a fim de serem reconhecidos nas expressões regularess.
Tabela de caracteres especiais das expressões regulares
Símbolo Equipara Exemplo Equivale a Não equivale a
\d qualquer dígito a\dx a5x arx
\D não dígito a\Dx arx a5x
\n nova linha
\r retorno de carro
\t tabulação
\f form feed
\s espaco em branco
\w caracter alfanumérico
\W nenhum caracter alfanumérico
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /\s+/) {
print "Frase contem a letra \"e\"\n";
$r =~ s/\s/\.\.\./g;
print $r,"\n";
}
A expressão regular $r =~ /\s+/ verifica se existe uma ou mais ocorrências de espaços em branco dentro da frase. Como a equiparação resulta verdadeira, a expressão $r =~ s/\s/\./g; substitui cada espaço em branco por tres pontos (\.). Note que, como o ponto é um átomo que indica qualquer caracter, não podemos usar diretamente os pontos entre a segunda e a terceira barra da expressão, sendo necessário especificá-los precedidos por barras reversas.
Sub-rotinas
Uma sub-rotina é uma espécie de função escrita pelo próprio programador e que executa uma tarefa repetitiva dentro do programa. A função de uma sub-rotina é executar trechos de códigos repetitivos, que deveriam ser codificados várias vezes dentro dos programas ou acionados através da instrução goto. As sub-rotinas podem receber valores e também devolver valores ao seu chamador.
Em Perl, define-se uma sub-rotina em qualquer lugar dentro de um programa usando-se o identificador sub seguido do nome da sub-rotina. Uma subrotina tem o seguinte aspecto:
sub nome_da_rotina {
declarações;
declarações;
declarações;
declarações;
}
O exemplo abaixo mostra uma sob-rotina completa. Note que a sub-rotina é chamada colocando-se o caracter & como prefixo de seu nome. A sub-rotina simplesmente imprimirá uma frase no monitor do computador a cada chamada.
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
for($n = 0;$n <= 5;$n++) {
&frase;
}
sub frase {
print "Exemplo de sub-rotina\n";
}
Retornando valores
As sub-rotinas podem devolver valores ao programa principal. Talves seja esta a maior utilidade das sub-rotinas. Os valores retornados podem ser escalares ou arrays. Devemos tomar muito cuidado na hora de codificar uma sub-rotina que retorna um valor pois, o valor retornado é sempre o valor da última declaração dentro da sub-rotina. Portanto, se a última declaração de uma sub-rotina for um print , ela retornará o valor 1.
Exemplo
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
$x = &valor;
if($x == 1) {
print "Valor retornado = ",$x,"\n";
}
sub valor {
print "Esta sub-rotina retorna um valor\n";
}
Passando valores
As vezes necessitamos passar certos valores para uma sub-rotina, como números, a fim de fazer cálculos e obtermos os resultados. Os valores a serem passados são informados como se fossem listas de variáveis entre parênteses na chamada da sub-rotina. A lista de variáveis informadas na chamada, chegam para a sub-rotina no array especial @_. Isso significa que Perl nunca trabalhará diretamente com as variáveis originais, mas com cópias dessas variáveis.
Exemplo
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
$x = &area(18,24);
print "Area = ",$x,"\n";
sub area {
local($a,$b) = @_;
return($a * $b);
}
No exemplo acima, a função da sub-rotina &area é calcular a área de qualquer retângulo. Na sua chamada foram passados os valores 18 e 24, que são as medidas dos lados de um retângulo. A sub-rotina recebeu os valores 18 e 24 nas variáveis locais $a e $b através do array especial @_, usando-se para isso a declaração local da linguagem Perl.
A seguir, a declaração return($a * $b) faz a multiplicação de $a * $b devolvendo imediatamente o resultado para a variável $x.
Outra versão da mesma sub-rotina é mostrada abaixo. Aqui, deve-se notar que a sub-rotina pode ser chamada de dentro da própria função "print". O exemplo abaixo calcula as áreas de todos os retângulos cujos lados variam de 1 a 4.
Exemplo
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
for($x = 1;$x <= 4;$x++) {
for($y = 1;$y <= 4;$y++) {
print "Area de ",$x," X ",$y," = ",&area($x,$y),"\n";
}
}
sub area {
local($a,$b) = @_;
return($a * $b);
}
Variáveis de ambiente
Perl possui variáveis especiais chamadas de variáveis de ambiente que contêm informações sobre o ambiente operacional em que o programa Perl esta sendo executado. Essas variáveis são armazenadas no array associativo %ENV e podem ser acessadas como $ENV{ 'nome_da_variavel' }.
O programa abaixo mostra todas as variáveis de ambiente para sua máquina.
foreach $k (keys %ENV) {
print $k, " = ",$ENV{$k},"\n";
}
Creditos:
Monitorador-Hacker
Atenciosamente,A Linguagem de Programacão Perl
Introducão
PERL (Practical Extraction and Report Language ) foi criada por Larry Wall como uma linguagem de programação mais versátil para o desenvolvimento de programas que necessitem de tratamento de strings e a mais adequada para criação de scripts CGI nos servidores Web.
Perl é uma linguagem de programacao interpretada com um grande número de características que a tornam muito útil para manipulacão de dados textuais. Por isso é muito difundida para aplicacões Web, como CGI para servidores HTTP. Entre suas características, destacam-se:
Declaracão de variáveis implícita. O primeiro caracter distingue se a variavel é um escalar, um array ou um array associativo.
Strings e arrays não necessitam de definicão de tamanho. Dinâmicamente eles são criados pequenos e crescem conforme a necessidade.
Todas variáveis são inicializadas com um valor default.
Um conjunto muito rico de operacões de busca "padrões" em textos.
Um conjunto completo de funcões aritméticas.
Um conjunto de funcões internas à linguagem com diversas funcionalidades.
Uma sintaxe "exótica", semelhante em alguns aspectos à "C", mas bem diferente em outros.
Um filosofia de fazer o trabalho rápido e não de forma elegante.
Perl é interpretada, o que significa que a etapa de compilacão não é explicitamente necessária. Simplesmente se escreve o código fonte em um editor de texto qualquer e o processador Perl o converte a uma forma de representacão interna e o executa.
Executando um programa PERL
Para executar um programa PERL, ativa-se o interpretador passando como argumento o nome do arquivo que contem o programa. No prompt do DOS fariamos:
C:PERL PROG1.PL
Argumentos a serem passados para o programa devem ser escritos logo a seguir como:
C:PERL PROG1.PL DATA=10/01/1978
Caminho para o interpretador
Após instalar o interpretador PERL em sua máquina é preciso definir o caminho para o DOS poder encontrá-lo. Insira no arquivo AUTOEXEC.BAT o seguinte comando:
PATH=C:\PERL\BIN;%PATH%
Um programa PERL
Um programa PERL consiste de um grupo de instruções e chamadas de funções da linguagem PERL gravados em um arquivo ASCII (texto) cuja extensão deve ser .pl por convensão, mas isso não é necessário. Esta extensão permite que você reconheça que este é um programa PERL. Quando se trata de CGI, muitos servidores na Web podem exigir que a extensão seja .cgi ou .pl e que o programa resida num diretório especial chamado cgi-bin.
A primeira linha de um programa PERL deve ser a diretiva #!/usr/local/bin/perl para informar o sistema onde encontrar o interpretador PERL. Isso é necessário somente quando se usa PERL como CGI num servidor de Web, mas não é necessário quando se executa um programa em seu micro.
Outra consideração que deve ser levada em conta quando se trata de CGIs, é que, para o browser entender que tipo de arquivo está recebendo, é necessário que o primeiro comando "print" especifique o cabeçalho HTTP informando o tipo de arquivo que está sendo enviado. Assim, o primeiro comando "print" de todo CGI que envia uma página HTML a um browser deve ser:
print "Content-type: text/html\n\n";
Além disso, todo CGI deve enviar pelo menos uma linha HTML ao browser ou um erro ocorrerá.
Certos comandos em PERL, exigem que comandos ou funções subsequentes sejam declarados entre chaves { e }.
Exemplo
#!/usr/local/bin/perl
print "Programa teste";
for($n=0;$n>=10;$n++)
{
print $n,"\n";
}
No exemplo acima, o programa PERL irá imprimir a mensagem "Programa teste" no monitor do computador. Após isso, fará com que $n varie de 0 a 10 imprimindo cada valor após uma nova linha. Note que o comando termina por um ponto e vírgula. Aqui vemos a primeira regra na programação PERL : todos os comandos PERL devem terminar por ponto e vírgula.
Tipos de dados
PERL não necessita que se declare as variáveis antes de usá-las. Uma variável é gerada dinamicamente quando a referenciamos. As variáveis podem ser de tres tipos apenas: escalares , arrays e arrays associativos.
Escalares
As variáveis escalares começam com um símbolo $ seguido de uma sequência de caracteres, como $data, $contador, $cor_de_fundo, etc. Deve-se evitar o uso de variáveis como $1, $2, etc, pois em PERL elas têm significado especial. Além disso, os escalares podem ser do tipo inteiro, ponto flutuante ou string, mas não é necessário especificar isso em PERL pois o interpretador se incumbe de gerar o tipo adequado de acôrdo com o contexto. $nome = "Jose da Silva"; define um escalar string "Jose da Silva"
$contador = 125; define um escalar inteiro 125
$contador = 3.1416; define um escalar em ponto flutuante 3.1416
Arrays
As variáveis do tipo array começam com o simbolo @ e seguem a mesma regra para as variáveis escalares. Na verdade, um array é um conjunto de escalares.
@cores = ("azul","verde", "amarelo","vermelho"); define array de strings
@loto = (12,15,23,31,42); define um array de inteiros
Os elementos de um array são acessados por um índice cujo valor para o primeiro elemento é zero. Para acessarmos a cor verde do exemplo acima, escreveriamos $cores[1]. Isso mesmo, quando nos referimos a um elemento do array, usamos o símbolo $ ao invés de @. O índice 1, entre colchetes, dá acesso ao valor do elemento que é "verde". Além disso, para sabermos quantos elementos um array possui, usamos a forma $# como prefixo do nome do array. Tomemos como exemplo o array @loto acima. Esse array possui 5 (cinco) elementos, isto é, $loto[0]=12, $loto[1]=15, $loto[2]=23, $loto[3]=31 e $loto[4]=42. Assim, a variável $#loto contem o valor 5.
Se quisermos imprimir quantos elementos possui esse array, devemos chamar a função print da seguinte maneira:
print "O array contem ",$#loto," elementos\n";
Isso imprimirá no monitor do computador:
O array contem 5 elementos"
É bom ir se acostumando a usar o comando print pois ele será muito usado daqui para frente. Note que você pode especificar várias coisas dentro de uma chamada à função print, como fizemos acima: primeiro, especificamos a string "O array contem " seguida de uma vírgula que serviu para separar a declaração seguinte que é $#loto, uma variável que tem o número de elementos do array @loto e que foi substituido pelo número 5 quando a mensagem foi impressa. Depois, usamos mais uma vírgula e escrevemos a string " elementos\n" e terminamos com um ponto e vírgula. O \n informa o sistema para iniciar uma nova linha após a impressão da mensagem. Se \n não fosse especificado, a próxima mensagem a ser impressa sairia grudada na mensagem anterior.
Arrays associativos
Já vimos que, num array comum, cada elemento é indexado por um valor numérico como $loto[3]. Nos arrays associativos os elementos são indexados por strings, mais conhecidos como chaves. Um array associativo é definido usando-se o caracter % como prefixo do nome do array. Vejamos um exemplo:
%cadastro = ("nome","Jose","endereco","Rua Azul","telefone","126126126");
A declaração acima associa a chave nome ao valor Jose, a chave endereco ao valor Rua Azul e a chave telefone ao valor 126126126. Portanto, se quisermos nos referir a qualquer um dos elementos do array, devemos usar as seguintes declarações:
$cadastro{'nome'} para obtermos Jose
$cadastro{'endereco'} para obtermos Rua Azul
$cadastro{'telefone'} para obtermos 126126126
Note que a referência ainda é feita usando-se o caracter $ como prefixo do array, ao invés de % usado na sua definição. Além disso, o nome da chave é especificada entre aspas e dentro de { }.
Podemos, ainda, usar um escalar contendo o nome da chave para nos referenciarmos a um valor do array:
$n = "nome"; # atribui o valor "nome" ao escalar $n
print $cadastro{$n},"\n"; # imprime Jose no monitor do computador
$n = "endereco"; # atribui o valor "endereco" ao escalar $n
print $cadastro{$n},"\n"; # imprime Rua Azul no monitor do computador
$n = "telefone"; # atribui o valor "telefone" ao escalar $n
print $cadastro{$n},"\n"; # imprime 126126126 no monitor do computador
Comentários
Qualquer coisa escrita após o caracter # será considerada como comentário pelo interpretador PERL. Habitue-se a escrever comentários dentro de seus programas porque isso facilita muito na hora de fazer uma alteração.
Arquivos
Para operar com arquivos, Perl possui um tipo especial de variável que se chama Handle de arquivo. Um Handle é, na verdade, um ponteiro para o arquivo que PERL deve ler ou gravar.
Arquivos predefinidos
PERL possui tres Handles de arquivos especiais, predefinidos:
STDIN Entrada padrão (teclado)
STDOUT Saída padrão (monitor de vídeo)
STDERR Mensagens de erro (monitor de vídeo)
Toda vez que se usa o comando print "....."; sem que se especifique o Handle de arquivo, o resultado será enviado a STDOUT, o mesmo se dando com o comando read que lerá obterá a entrada do teclado STDIN.
Note que os Handles devem ser escritos com letras maiúsculas.
Abrindo e fechando arquivos
Para que um arquivo possa ser acessado, antes é necessário abrí-lo. Em PERL isso é feito usando-se a função open. A função open define o Handle de arquivo a ser utilizado e o modo como o arquivo será processado, isto é, se o arquivo será lido ou gravado.
A função open tem o seguinte formato:
open(handle,"nome do arquivo");
Por exemplo:
open(CADASTRO,"<cadastro.txt"); CADASTRO é o Handle do arquivo
o caracter < antes do nome do arquivo, significa que o arquivo está sendo aberto para leitura.
cadastro.txt é o nome do arquivo. Para arquivos residentes em outros diretórios, diferentes daquele onde se encontra o programa PERL, deve-se especificar o path completo.
Após utilizarmos o arquivo, este deve ser fechado com o a função close.
close(CADASTRO);
Do mesmo modo que especificamos o caracter < na frente do nome do arquivo, para dizer que ele será aberto para leitura, outros caracteres são usados para abrir arquivos para serem gravados ou ampliados. A tabela a seguir mostra essas variações:
Caracter Significado Exemplos e comentários
< Abre arquivo para leitura. open(ARQ1,"<texto.txt");
ou
open(ARQ1,"texto.txt");
Não é nexessário especificar o caracter <. Qualquer arquivo aberto sem a especificação de modo, será aberto para leitura.
> Abre arquivo para gravação. open(ARQ1,">texto.txt");
Se o arquivo já existir, ele será regravado e seus dados anteriores serão perdidos. Se o arquivo não existir, um novo arquivo será criado.
>> Abre arquivo para ampliação. open(ARQ1,">>texto.txt");
Se o arquivo já existir, os novos dados serão inseridos no final desse arquivo. Se o arquivo não existir, um novo arquivo será criado.
+< Abre arquivo para leitura e gravação. open(ARQ1,"+<texto.txt");
Pode-se ler e gravar no mesmo arquivo.
+> Abre arquivo para leitura e gravação. open(ARQ1,"+>texto.txt");
Pode-se ler e gravar no mesmo arquivo.
Lendo um arquivo
Para ler um arquivo, PERL tem um operador especial que consiste em colocar o Handle entre os caracteres < e > deste modo: <CADASTRO>. Podemos, então, atribuir a uma variável escalar ou a um array os registros provindos de um arquivo. Veja os exemplos abaixo:
$registro = <CADASTRO> Lê um registro do arquivo e o coloca na variável $registro
@matriz = <CADASTRO> Lê todos os registros do arquivo, de uma só vez, e armazena-os no array @matriz.
Após isso, pode-se obter os registros usando-se o método estudado para os arrays.
Gravando um arquivo novo
A gravação de um arquivo novo, implica em usarmos o caracter > na frente do nome do arquivo durante sua abertura. Além disso, para gravarmos um arquivo, usamos a função print usando como primeiro argumento o Handle do arquivo.
Exemplo:
open(CORES,">cores.txt"); # abre arquivo para gravação
@cores = ("azul","verde","amarelo","vermelho"); # gera array com os nomes das cores
foreach $i (@cores) # para cada cor no array
{ # inicio do bloco foreach
print CORES $cores[$i],"\n"; # grava um registro no arquivo
} # fim do bloco foreach
close(CORES); # fecha o arquivo
Ampliando um arquivo existente
A ampliação de um arquivo, implica em usarmos os caracters >> na frente do nome do arquivo durante sua abertura. Para gravarmos novos registros no arquivo, também usamos a função print.
Como exemplo, vamos ampliar o arquivo do exemplo anterior:
open(CORES,">>cores.txt"); # abre arquivo para ampliação
@cores = ("branco","rosa","violeta","laranja"); # gera array com os nomes das cores
foreach $i (@cores) # para cada cor no array
{ # inicio do bloco foreach
print CORES $cores[$i],"\n"; # grava um registro no arquivo
} # fim do bloco foreach
close(CORES); # fecha o arquivo
Controlando o fluxo
PERL fornece todos os controles de fluxo necessários a uma linguagem de programação. De início vamos dar uma olhada em dois operadores lógicos que facilitarão o entendimento dos comandos de controle de fluxo. São eles o OU, representado pelos símbolos "||" (duas barras verticais), e o E, representado pelos símbolos "&&". Esses dois operadores usam dois operandos e retornam o valor Falso ou Verdadeiro, dependendo dos operandos. Por exemplo:
$x = $a || $b; leia-se $x = $a OU $b
$x será Falso se $a e $b forem falsos. $x será Verdadeiro se $a for verdadeiro e $b for falso. $x será Verdadeiro se $a for falso e $b for verdadeiro.
Confuso? Bem, tentemos simplificar isso: na expressão acima, $a e $b são avaliados internamente de acordo com as definições da álgebra Booleana e o resultado será colocado em $x. A tabela abaixo mostra as principais operações da álgebra Booleana:
Seja F falso e V verdadeiro
Operação OU
(OR) V OR V = V
V OR F = V
F OR V = V
F OR F = F
Operação E
(AND) V AND V = V
V AND F = F
F AND V = F
F AND F = F
Operação OU
Exclusivo
(XOR) V XOR V = F
V XOR F = V
F XOR V = V
F XOR F = F
Vejamos agora a expressão $x = ($a > 1) && ($b < 10):
$x será verdadeiro se, e somente se, $a for maior do que 1 E $b for menor do que 10.
$x será falso quando $a for menor ou igual a 1 ou quando $b for maior ou igual a 10.
O que se deve notar aqui, é a lógica de avaliação da expressão. PERL não fará a avaliação da segunda parte da expressão ($b < 10) se a primeira parte for falsa pois, conforme a tabela de operações Booleanas acima, para a operação E, toda vez que o primeiro operando é falso, o resuldato será falso. Isso dá ao PERL uma vantagem não encontrada em outras linguagens, que é a capacidade de executar, ou não, comandos dentro de avaliações lógicas do tipo da expressão acima. Vejamos então:
$x < 20 || print "X maior ou igual a 20\n";
Neste caso, a primeira parte da expressão é avaliada e, se ela for falsa, isto é, se $x for maior ou igual a 20, então a segunda parte da expressão terá que ser avaliada para saber se ela é verdadeira (veja operação OU na tabela), mas, como a segunda parte da expressão é uma chamada para a função print, ela imprimirá a mensagem "X maior ou igual a 20" no monitor do computador.
Operadores Relacionais
Os operadores relacionais são símbolos usados entre os operandos nas expressões condicionais. Em PERL existe uma diferença entre o contexto numérico e o contexto de string no que diz respeito ao uso dos operadores relacionais, isto é, uma comparação entre duas variáveis numéricas deve ser feita da seguinte maneira: if($x == $y)..... enquanto uma comparação entre duas variáveis string seria: if($a eq $b)..... A tabela abaixo mostra todos os operadores relacionais para serem usados em ambos os contextos:
Operador Contexto númerico Contexto string
Igualdade == eq
Desigualdade != ne
Maior do que > gt
Maior ou igual a >= ge
Menor do que < lt
Menor ou igual a <= le
if elseif else
Após a expressão entre parenteses for verdadeira, as declarações entre chaves ({ }) serão executadas. Se a expressão entre parenteses for falsa, então o controle será passado para a declaração que segue o fechamento da chave. Exemplo:
if($x >= $y) {
print "X e maior ou igual a Y\n";
}
Os operadores elseif e else podem ser usados quando várias opções necessitam ser testadas:
if($x = $y) {
print "X e igual a Y\n";
}
elseif($x > 0) {
print "X e maior do que zero\n";
}
else {
print "X e diferente de Y e menor do que zero\n";
}
unless
A declaração a esquerda não será executada se a expressão for verdadeira
print "X e menor do que 20\n" unless $x >= 20;
Para facilitar o entendimento, leia a declaração acima como: imprima "X é menor do que 20" a não ser que $x seja maior ou igual a 20. Note também que não há ponto-e-vírgula após \n.
while
As declarações entre chaves { } serão executadas enquanto a expressão entre parenteses for verdadeira.
while($x <= 10) {
print "X=",$x,\n";
$x++;
}
print "Fim\n";
Traduzindo: o programa inicializa a variável $x em 0. Logo após, testa, no comando while, se $x é menor do que 10. Como isto é verdadeiro, pois $x ainda é zero, a instrução print será executada imprimindo "X=0". Após a impressão, soma-se 1 na variável $x com o comando $x++, dando como resultado $x=1. Novamente o controle é passado para a linha while que fára um novo teste com a variável $x. Isso vai acontecer até que $x fique com o valor 11, quando o teste resultará em falso e, portanto o controle será passado para a instrução após a última chave que imprimirá "Fim".
until
A instrução until executa uma série de declarações entre chaves até que a expressão entre parenteses seja verdadeira.
until($x >= 20) {
print "X=",$x,"\n";
$x++;
}
O programa acima incrementará e imprimirá os valores de $x até que este atinja o valor 20.
Outra maneira de se usar a instrução until é mostrada abaixo, onde a declaração do lado esquerdo será executada até que a expressão do lado direito seja verdadeira.
$x = 0;
$x++ until $x <= 100;
No exemplo acima, fazemos inicialmente $x=0. Após isso, será somado 1 em $x ($x++) até que $x atinja o valor 100.
for
Na instrução for coloca-se entre parenteses as condições para as quais ela deverá executar as declarações entre as chaves. Nos argumentos entre parenteses, são colocados, em primeiro lugar, uma variável contadora com o valor de início de contagem. Em segundo lugar, será informado o valor limite da variável contadora e, em terceiro lugar, o incremento da variável contadora. Todos os argumentos devem ser separados por ponto e vírgula.
for ($x = 100;$x <= 200;$x+10) {
print "X = ",$x,"\n";
}
No exemplo acima, inicializa-se a variável $x com o valor 100, estabelece-se o limite de contagem em 200 e incrementa-se $x de 10 em 10. Esse programa imprimirá os valores de $x de 100 a 200 de 10 em 10, ou seja, 100, 110, 120, 130 ....... 200.
foreach
A instrução foreach é especialmente projetada para operações com arrays. Do mesmo modo que a instrução for, ela executa as declarações entre as chaves.
@cores = ("azul","verde","amarelo","vermelho");
foreach $cor (@cores) {
print $cor,"\n";
}
Na primeira vez, a variável $cor assume o valor "azul" que será impresso a seguir. Na segunda vez, assume o valor "verde" e assim por diante. Não é necessário que o programador se preocupe com o número de elementos do array porque foreach faz isso automaticamente.
Outra maneira de se usar a intrução foreach é através de um indexador numérico como no exemplo abaixo:
@cores = ("azul","verde","amarelo","vermelho");
foreach $x (0..$#cores) {
print $cores[$x],"\n";
}
Nesse exemplo, a variável $x assumirá todos os valores, de zero, que é o número do primeiro elemento do array, até 3, que é o número do último elemento.
Labels
Um Label consiste de uma palavra, escrita em letras maiúsculas e seguida de dois-pontos que é usada para marcar um lugar dentro de um programa. Os Labels são geralmente usados nas instruções while, for e foreach em conjunto com as declarações next, last e redo, a fim de permitir maior controle dos loops. Os labels são usados também pela instrução goto.
AQUI: for($n = 0;$n <= 100;$n++) {
next AQUI if($n % 2 != 0)
}
O exemplo acima imprime todos os números pares de 0 a 100. Quando $n for impar, a declaração next remete o controle para o label AQUI:. A tabela abaixo mostra as declarações de controle:
next Desvia para a próxima iteração marcada pelo label.
last Sai do loop.
redo Reexecuta o loop marcado pelo label a partir do início.
goto
A instrução goto desvia o controle para o label especificado. Raramente um programador PERL usa esta instrução pois PERL é uma linguagem estruturada onde tais construções devem ser evitadas como norma de boa programação.
AQUI: ..........
................
................
................
goto AQUI:;
Expressões regulares
Expressões regulares são conjuntos de regras que descrevem uma string genéricamente. Com as expressões regulares podemos fazer pesquisas muito complexas dentro de uma string em apenas uma linha de programa, dispensando a análise byte a byte empregada em outras linguagens.
Equiparação de padrões
Quando os ceracteres que formam uma string estão de acôrdo com as regras estabelecidas numa expressão regular, dizemos que a expressão regular é equiparada ao string. Os dois tipos básicos de equiparação são:
Equiparação: para saber se um determinado string corresponde a um padrão.
Substituição: para substituir partes de uma string por um determinado padrão.
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /Perl/) {
print "Existe a palavra Perl na string\n";
$r =~ s/Perl/C/g;
print $r,"\n";
}
A variável $r foi definida com o conteúdo 'estudar Perl da muito trabalho'. Agora queremos saber se dentro da string existe a palavra Perl. Usamos o comando if no qual escrevemos a equiparação $r =~ /Perl/ . Se a equiparação for verdadeira, o comando print será executado. Note que o operador de equiparação da expressão regular com a string agora é =~ e não ==. Note também que a expressão regular propriamente dita é colocada entre barras.
Após o comando print vemos o comando $r =~ s/Perl/C/g; que substituirá a palavra Perl pela letra C . Aqui vemos a função s que localizará a string contida entre a primeira e a segunda barra e a substituirá pela string contida entre a segunda e a terceira barra. A letra g após a última barra significa que a substituição será feita todas as vezes que a palavra Perl for encontrada dentro da variável $r.
Assertivas
As assertivas servem para delimitar o padrão que se deseja equiparar. Pose-se equiparar padrões no começo, no fim, e entre palavras.
Tabela de assertivas das expressões regulares
Assertivas equiparadas Exemplo Equivale a Não equivale a
^ início da string ^tra trave letra
$ fim da string lha$ malha malhado
\b limite de palavra por\bque por que porque
\B não limite de palavra por\Bque porque por que
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /trabalho$/) {
print "Frase terminada com a palavra \"trabalho\"\n";
$r =~ s/trabalho/prazer/g;
print $r,"\n";
}
No comando if a equiparação esta sendo feita com uma expressão que verifica se a frase termina com a palavra "trabalho". Note a assertiva $ no fim da palavra trabalho$. Como a equiparação é verdadeira, a linha $r =~ s/trabalho/prazer/g; substituirá "trabalho" por "prazer".
Átomos
Os Átomos são os componentes fundamentais na formação das expressões regulares.
Tabela de átomos das expressões regulares
Átomo Equipara Exemplo Equivale a Não equivale a
.
(ponto) qualquer caracter exceto nova linha l.a lha lar
lista de caracteres entre colchetes qualquer dos caracteres da lista ^[tr] trabalho metralha
expressão regular entre parênteses qualquer coisa que a expressão equipare ^a(x.x)b$ axaxb axxb
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /.a/) {
print "Frase contem o esperado\n";
$r =~ s/.a/xi/g;
print $r,"\n";
}
A expressão regular $r =~ /.a/ testa se existe qualquer caracter dentro da frase seguido pela letra a. Como a equiparação resulta verdadeira, todo caracter seguido da letra a, incluindo a própria letra a será substituido por xi.
Quantificadores
Quantificadores são sinais usados para modificar os átomos. Eles permitem dizer quantas vezes os átomos devem aparecer.
Tabela de quantificadores das expressões regulares
Quantificador Equipara Exemplo Equivale a Não equivale a
* zero ou mais ocorrências do átomo xy*z xz
xyz xyy
+ uma ou mais ocorrências do átomo xy+z xyz xz
? zero ou uma ocorrência do átomo xy?z xz
xyz xyyz
{n} n ocorrências do átomo xy{2}z xyyz xyyyz
{n,} pelo menos n ocorrências do átomo xy{2,}z xyyz
xyyyz xyz
{n,m} pelo menos n e no máximo m ocorrências do átomo xy{2,3}z xyyz xyyyz
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /e+/) {
print "Frase contem a letra \"e\"\n";
$r =~ s/e/x/g;
print $r,"\n";
}
A expressão $r =~ /e+/ testa se existe uma ou mais ocorrências do caracter "e" dentro da variável $r. Note o quantificador +, após p caracter e da expressão regular entre barras, que indica a verificação de uma ou mais ocorrências. Como a equiparação é verdadeira, a expressão $r =~s/e/x/g; substituirá todas os caracteres e pelo caracter x.
Caracteres especiais
Caracteres especiais devem ser especificados por barras inversas \ a fim de serem reconhecidos nas expressões regularess.
Tabela de caracteres especiais das expressões regulares
Símbolo Equipara Exemplo Equivale a Não equivale a
\d qualquer dígito a\dx a5x arx
\D não dígito a\Dx arx a5x
\n nova linha
\r retorno de carro
\t tabulação
\f form feed
\s espaco em branco
\w caracter alfanumérico
\W nenhum caracter alfanumérico
Exemplo:
$r = "aprender Perl da muito trabalho";
if( $r =~ /\s+/) {
print "Frase contem a letra \"e\"\n";
$r =~ s/\s/\.\.\./g;
print $r,"\n";
}
A expressão regular $r =~ /\s+/ verifica se existe uma ou mais ocorrências de espaços em branco dentro da frase. Como a equiparação resulta verdadeira, a expressão $r =~ s/\s/\./g; substitui cada espaço em branco por tres pontos (\.). Note que, como o ponto é um átomo que indica qualquer caracter, não podemos usar diretamente os pontos entre a segunda e a terceira barra da expressão, sendo necessário especificá-los precedidos por barras reversas.
Sub-rotinas
Uma sub-rotina é uma espécie de função escrita pelo próprio programador e que executa uma tarefa repetitiva dentro do programa. A função de uma sub-rotina é executar trechos de códigos repetitivos, que deveriam ser codificados várias vezes dentro dos programas ou acionados através da instrução goto. As sub-rotinas podem receber valores e também devolver valores ao seu chamador.
Em Perl, define-se uma sub-rotina em qualquer lugar dentro de um programa usando-se o identificador sub seguido do nome da sub-rotina. Uma subrotina tem o seguinte aspecto:
sub nome_da_rotina {
declarações;
declarações;
declarações;
declarações;
}
O exemplo abaixo mostra uma sob-rotina completa. Note que a sub-rotina é chamada colocando-se o caracter & como prefixo de seu nome. A sub-rotina simplesmente imprimirá uma frase no monitor do computador a cada chamada.
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
for($n = 0;$n <= 5;$n++) {
&frase;
}
sub frase {
print "Exemplo de sub-rotina\n";
}
Retornando valores
As sub-rotinas podem devolver valores ao programa principal. Talves seja esta a maior utilidade das sub-rotinas. Os valores retornados podem ser escalares ou arrays. Devemos tomar muito cuidado na hora de codificar uma sub-rotina que retorna um valor pois, o valor retornado é sempre o valor da última declaração dentro da sub-rotina. Portanto, se a última declaração de uma sub-rotina for um print , ela retornará o valor 1.
Exemplo
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
$x = &valor;
if($x == 1) {
print "Valor retornado = ",$x,"\n";
}
sub valor {
print "Esta sub-rotina retorna um valor\n";
}
Passando valores
As vezes necessitamos passar certos valores para uma sub-rotina, como números, a fim de fazer cálculos e obtermos os resultados. Os valores a serem passados são informados como se fossem listas de variáveis entre parênteses na chamada da sub-rotina. A lista de variáveis informadas na chamada, chegam para a sub-rotina no array especial @_. Isso significa que Perl nunca trabalhará diretamente com as variáveis originais, mas com cópias dessas variáveis.
Exemplo
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
$x = &area(18,24);
print "Area = ",$x,"\n";
sub area {
local($a,$b) = @_;
return($a * $b);
}
No exemplo acima, a função da sub-rotina &area é calcular a área de qualquer retângulo. Na sua chamada foram passados os valores 18 e 24, que são as medidas dos lados de um retângulo. A sub-rotina recebeu os valores 18 e 24 nas variáveis locais $a e $b através do array especial @_, usando-se para isso a declaração local da linguagem Perl.
A seguir, a declaração return($a * $b) faz a multiplicação de $a * $b devolvendo imediatamente o resultado para a variável $x.
Outra versão da mesma sub-rotina é mostrada abaixo. Aqui, deve-se notar que a sub-rotina pode ser chamada de dentro da própria função "print". O exemplo abaixo calcula as áreas de todos os retângulos cujos lados variam de 1 a 4.
Exemplo
#-------------------------------------------------------#
# Exemplo de sub-rotina #
#-------------------------------------------------------#
for($x = 1;$x <= 4;$x++) {
for($y = 1;$y <= 4;$y++) {
print "Area de ",$x," X ",$y," = ",&area($x,$y),"\n";
}
}
sub area {
local($a,$b) = @_;
return($a * $b);
}
Variáveis de ambiente
Perl possui variáveis especiais chamadas de variáveis de ambiente que contêm informações sobre o ambiente operacional em que o programa Perl esta sendo executado. Essas variáveis são armazenadas no array associativo %ENV e podem ser acessadas como $ENV{ 'nome_da_variavel' }.
O programa abaixo mostra todas as variáveis de ambiente para sua máquina.
foreach $k (keys %ENV) {
print $k, " = ",$ENV{$k},"\n";
}
Creditos:
Monitorador-Hacker
Equilibrio
Comment