Baixe Programação - Perl - Conceitos, exercícios e explicações e outras Exercícios em PDF para Programação em C, somente na Docsity!
! TUTORIAL PERL: O Início
Autor: Nik Silver, University of Leeds, UK http://agora.leeds.ac.uk/nik/ Tradução/adaptação: Hudson Pires, Campinas, SP, .br Tutorial On-Line Home Page http://Tutorial.VirtualAve.net Revisão: 11/03/
Este tutorial se destina a ensinar como escrever programas básicos em Perl, mas ele não explana determinados assuntos como generalizações sobre a linguagem.
! TUTORIAL PERL: O INÍCIO 1
! UM PROGRAMA SIMPLES 3
# A PRIMEIRA LINHA 3
# COMENTÁRIOS E DECLARAÇÕES 3
# I MPRIMINDO NA TELA 3
! EXECUTANDO O PROGRAMA 3
! VARIÁVEIS ESCALARES 4
# O PERAÇÕES E ATRIBUIÇÕES 5
# I NTERPOLAÇÃO 6
# EXERCÍCIO 6
! VARIÁVEIS DE MATRIZES 6
# ATRIBUIÇÕES DE MATRIZES 7
# M OSTRANDO MATRIZES 8
# EXERCÍCIO 8
! MANIPULANDO ARQUIVOS 8
# EXERCÍCIO 10
! ESTRUTURAS DE CONTROLE 10
_________________________________________________________________
FOREACH
TESTANDO
FOR
WHILE E UNTIL
EXERCÍCIO
-! CONDICIONAIS
-! COMPARANDO STRINGS
EXPRESSÕES REGULARES
A VARIÁVEL ESPECIAL $_
M AIS SOBRE ERS
ALGUNS EXEMPLOS DE ERS
EXERCÍCIO
-! SUBSTITUIÇÃO E TRADUÇÃO
O PÇÕES
RECORDANDO MODELOS
TRADUÇÃO
EXERCÍCIO
-! SPLIT
-! MATRIZES ASSOCIATIVAS
O PERADORES
VARIÁVEIS DE AMBIENTE
-! SUBROTINAS
P ARÂMETROS
RETORNANDO VALORES
VARIÁVEIS LOCAIS
Digite o programa acima em um editor de texto, depois salve ele. Existem duas formas de instalar seu programa no servidor:
Pelo Unix (requer conhecimento básico), Emacs é um bom editor porque possui o modo Perl que formata linhas facilmente quando você pressiona tab (use M-x perl-mode).
Pelo FTP, use qualquer editor de texto puro, e envie o arquivo através de um programa de FTP (CuteFTP ou WS_FTP), é importante que seja usado o modo de transferência ASCII, e nunca Binário.
O programa deve ser salvo com a extensão .cgi (que indica ser um script) ou com .pl (de Perl), e depois torná-lo executável.
Pelo Unix, digite:
chmod u+x programa
na linha de comandos, onde programa é o nome do seu arquivo.
Pelo FTP, clique em alterar atributos do arquivo, escolhendo o valor 755 ( -rwxr-xr-x ).
Agora rode o programa apenas digitando um destes comandos:
perl programa (pelo DOS ou UNIX) ./programa (pelo UNIX) programa (pelo UNIX)
Caso você esteja usando a linha de comandos do DOS, é necessário ter o programa Perl for Win32 instalado, ele pode ser retirado no endereço:
http://www.activestate.com/
Se algo ocorrer de errado, podem aparecer mensagens de erro, ou nada. Você pode sempre rodar o programa com mensagens através do comando:
perl -w programa
Ele mostrará avisos e outras mensagens de ajuda antes de tentar executar o programa. Para rodá-lo com a depuração, use o comando:
perl -d programa
O Perl compila primeiro o programa e então executa sua versão compilada. Assim, após uma pequena pausa para compilação, o programa deve rodar rapidamente.
Certifique-se de que o programa está funcionando antes de continuar.
Veremos a seguir como tornar esse programa mais interessante.
! Variáveis escalares
O tipo mais usado de variável no Perl é o escalar. Variáveis escalares podem conter caracteres e/ou números, e note que eles são completamente intercambiáveis. Por exemplo, a declaração:
$prioridade = 9;
atribui a variável escalar $prioridade o valor 9, mas você pode também designar uma string (cadeia de caracteres) para a mesma variável:
$prioridade = 'alta';
Perl também aceita números como strings:
$prioridade = '9'; $default = '0009';
e ainda pode realizar operações aritméticas ou outras.
Em geral, nomes de variáveis consistem de números, letras e símbolos _ mas não devem começar com números depois do $. A variável $_ é especial, como veremos mais tarde. Além disso, o Perl é case sensitive, i.é, letras maiúsculas são diferentes de minúsculas, por exemplo, $a e $A são variáveis distintas.
Operações e Atribuições
O Perl utiliza todas as operações usuais na linguagem C:
$a = 1 + 2; # soma 1 e 2 e armazena em $a $a = 3 - 4; # subtrai 4 de 3 e armazena em $a $a = 5 * 6; # multiplica 5 por 6 $a = 7 / 8; # divide 7 por 8 e retorna 0. $a = 9 ** 10; # 9 elevado por 10 $a = 5 % 2; # resto da divisão de 5 por 2 ++$a; # incrementa $a e retorna seu valor $a++; # retorna $a e depois incrementa em 1 --$a; # decrementa $a e retorna seu valor $a--; # retorna $a e depois decrementa em 1
e para caracteres, existem os seguintes operadores:
$a = $b. $c; # concatena $b e $c $a = $b x $c; # $b repetido $c vezes
Para atribuir valores, Perl utiliza:
$a = $b; # atribui $b para $a $a += $b; # soma $b para $a $a -= $b; # subtrai $b de $a $a .= $b; # acrescenta $b em $a
Note que quando Perl atribui um valor como $a = $b, ele faz uma cópia de $b e então o atribui para $a. Portanto, na próxima vez que você alterar $b, ele não irá alterar $a.
formato das escalares exceto que eles são prefixados pelo símbolo @. As declarações:
@comida = ("maçãs", "pêras", "uvas"); @musica = ("flauta", "gaita");
atribuem três elementos para a matriz @comida e dois para a matriz @musica.
A matriz é acessada pelo uso de índices começando do zero, e colchetes são usados para especificar cada índice. A expressão:
$comida[2]
retorna uvas. Note que o símbolo @ foi mudado para $ porque uvas é o valor de uma variável escalar.
Atribuições de matrizes
No Perl, a mesma expressão em um contexto diferente pode produzir um resultado diferente. A primeira atribuição abaixo expande a variável @musica de modo que fique equivalente à segunda atribuição:
@mais_musica = ("órgão", @musica, "harpa"); @mais_musica = ("órgão", "flauta", "gaita", "harpa");
Isto deve sugerir um modo de acrescentar elementos em uma matriz. Um modo simples de acrescentar estes elementos é usar a declaração:
push(@comida, "ovos");
que acrescenta ovos ao fim da matriz @comida. Para acrescentar dois ou mais itens, use um dos seguintes formatos:
push(@comida, "ovos", "carne"); push(@comida, ("ovos", "carne")); push(@comida, @mais_comida);
Além disso, a função push retorna o comprimento da nova lista.
Para remover o último item de uma lista e retorná-lo, use a função pop. De nossa primeira lista, a função pop retorna uvas e @comida passa a ter dois elementos:
$outra_comida = pop(@comida); # agora $outra_comida = "uvas"
Também é possível atribuir uma matriz para uma variável escalar. A linha:
$c = @comida;
atribui apenas o comprimento de @comida, mas
$c = "@comida";
transforma a lista em uma string com um espaço entre cada elemento. Este espaço pode ser substituído por qualquer outro caractere apenas
mudando o valor da variável especial $" (por exemplo, $" = " mais "; ). Esta variável é apenas uma de muitas outras usadas na linguagem Perl.
Matrizes também podem ser usadas para fazer múltiplas atribuições para variáveis escalares:
**($a, $b) = ($c, $d); # é o mesmo que $a=$c; $b=$d; ($a, $b) = @comida; # $a e $b são os primeiros
itens de @comida.
($a, @alguma_comida) = @comida; # $a é o primeiro item de @comida
e @alguma_comida é uma lista dos
demais elementos.
(@alguma_comida, $a) = @comida; # @alguma_comida = @comida e
$a é indefinida.**
A última atribuição ocorre desta maneira porque matrizes consomem tudo, e @alguma_comida retira todos os elementos de @comida. Portanto, este formato deve ser evitado.
Finalmente, você pode querer encontrar o índice do último elemento de uma lista.
Para fazer isso, use a expressão:
$#comida
# Mostrando matrizes
Desde que contexto é importante, não é surpresa que os seguintes comandos produzem resultados diferentes:
print @comida; # resultado óbvio print "@comida"; # tratado como string print @comida.""; # em um contexto escalar
# Exercício
Experimente cada uma das três declarações acima para ver o que elas fazem.
! Manipulando arquivos
Aqui está um programa básico em Perl que faz o mesmo que o comando cat do Unix em um certo arquivo:
**#!/usr/local/bin/perl
Programa para abrir o arquivo de senhas, ler,**
_________________________________________________________________
# Exercício
Modifique o programa acima de modo que todo o arquivo contenha o símbolo # no início de cada linha.
Você deverá somente acrescentar uma linha e modificar uma delas. Use a variável $".
Coisas inesperadas podem ocorrer com arquivos, então você pode encontrar alguma ajuda com o uso da opção –w, como mencionado no tópico Executando o programa.
_________________________________________________________________
! Estruturas de controle
Possibilidades mais interessantes aparecem quando nós introduzimos as estruturas de controle e o looping. Perl suporta muitos tipos diferentes de estruturas de controle que tendem a ser como na linguagem C, mas muitos são similares aos do Pascal, também. Aqui discutiremos um pouco delas.
foreach
Para executar cada linha de uma matriz ou de outra estrutura com formato de lista (como linhas em um arquivo), Perl usa a estrutura foreach. Ela tem o seguinte formato:
**foreach $petisco (@comida) # visitar cada item e colocá-lo
em $petisco
{ print "$petisco\n"; # exibe cada item print "Yum yum\n"; # de @comida... }**
As ações a serem realizadas cada vez, estão no bloco entre chaves. Na primeira passagem pelo bloco, $petisco é atribuído ao valor do primeiro item da matriz @comida. Na próxima vez, ele é atribuído ao segundo valor, e assim por diante. Se @comida estiver vazio logo no início, então o bloco de declarações não será executado.
Testando
As próximas e poucas estruturas contam com os testes booleanos verdadeiro ou falso. O número zero, sendo zero um caractere, e o caractere vazio ("") são contados como falsos. Aqui estão alguns testes em números e strings:
**$a == $b # $a é numericamente igual a $b?
cuidado: não use só o operador =
$a != $b # $a é numericamente diferente de $b? $a eq $b # $a é uma string igual a $b? $a ne $b # $a é uma string diferente de $b?**
Você pode também tentar usar operadores lógicos e, ou, não:
($a && $b) # $a e $b são verdadeiros? ($a || $b) # $a ou $b é verdadeiro? !($a) # $a é falso?
for
Perl possui a estrutura for que funciona da mesma forma que no C. Ele tem o formato:
for (inicializar; testar; incrementar) { primeira_ação; segunda_ação; etc; }
Primeiramente, a declaração inicializar é executada. Então, enquanto testar for verdadeiro, o bloco de ações será executado. Após cada
**while ($a ne "teste"); # repete enquanto a senha for errada
usando until no lugar de while,
until ($a eq "teste"); repete até que a senha esteja correta**
# Exercício
Modifique o programa do exercício anterior de modo que cada linha do arquivo seja lida uma a uma, e retorne com um número de linha no início. Você deve ter algo como:
_1 root:oYpYXm/qRO6N2:0:0:Super-User:/:/bin/csh 2 sysadm::0:0:System V Administration:/usr/admin:/bin/shdiag::0:996:Hardware Diagnostics:/usr/diags:/bin/csh 3 etc_**
Talvez seja interessante usar esta estrutura:
while ($linha = ) # lê cada linha até o final de INFO { ... }
Quando você tiver feito isso, veja se pode alterá-lo de modo que cada número de linha seja mostrada como 001, 002, ..., 009, 010, 011, 012, etc.
Para fazer isso, você deverá somente mudar uma linha inserindo quatro caracteres extras. Lembre-se que o Perl permite isso.
_________________________________________________________________
! Condicionais
É claro que o Perl também permite testes condicionais if/then/else. Eles possuem o seguinte formato:
if ($a) { print "A variável não está vazia\n"; } else { print "A variável está vazia\n"; }
Para entender, recorde que o caractere vazio é considerado como falso. Ele também retorna falso se o caractere for zero.
Também é possível incluir mais alternativas em uma declaração condicional:
if (!$a) #! é o operador não { print "A variável está vazia\n"; } elsif (length($a) == 1) # se acima falir, tente isso { print "A variável tem um caractere\n"; } else # se também falir... { print "A variável tem vários caracteres\n"; }
Neste caso, é importante notar que a declaração elsif está correta, sem o e de elseif.
# Exercício
Encontre um arquivo grande com algum texto e algumas linhas em branco.
Do exercício anterior, você deve ter um programa que mostra o arquivo de senhas com números de linhas. Mude ele de modo que funcione com o outro arquivo de texto.
Agora altere o programa de modo que aqueles números não sejam mostrados ou contados com linhas em branco, mas toda linha permanece sendo mostrada, incluindo as em branco. Recorde que, quando uma linha do arquivo é lida, ela continua incluindo seu caractere newline no final.
! Comparando strings
Um dos mais úteis recursos do Perl (senão o mais útil) é a poderosa manipulação de strings. No coração desta, está a expressão regular (ER) que é compartilhada por muitos outros utilitários do Unix.
# Expressões regulares
Uma expressão regular sempre está contida entre barras, e a comparação ocorre com o operador =~. A seguinte expressão é verdadeira se a string aparecer na variável $sentença:
$sentenca =~ /para/
A ER é case sensitive, de modo que se:
$sentenca = "Para as raposas";
**p.r # p seguido por qualquer caractere seguido por e
isto irá comparar:
par
para
por**
^f # f no início da linha ^ftp # ftp no início da linha es$ # es no final da linha
*und # un seguido por nenhum ou vários caracteres d
isto irá comparar:
un
und
undd
unddd (etc)**
*. # qualquer string sem o newline,
isto ocorre porque o. compara qualquer caractere
e o * é o mesmo que nenhum ou mais deste caractere**
^$ # uma linha vazia
Existem ainda mais opções. Colchetes podem ser usados para comparar qualquer um destes caracteres dentro deles. Entre colchetes, o símbolo - indica entre e o símbolo ^ no início significa não:
**[qjk] # tanto q ou j ou k [^qjk] # exceto q, j e k [a-z] # qualquer um entre a e z, inclusive estes [^a-z] # exceto letras minúsculas [a-zA-Z] # qualquer letra [a-z]+ # qualquer sequência com pelo menos uma ou
mais letras minúsculas**
As demais opções servem mais para referência.
Uma barra vertical | representa ou e os parênteses podem ser usados para agrupar caracteres:
geléia|creme # tanto geléia ou creme (ov|dad)os # tanto ovos ou dados (da)+ # tanto da ou dada ou dadada
Aqui estão mais alguns caracteres especiais:
**\n # um newline \t # um tab \w # qualquer caractere alfanumérico (palavra)
o mesmo que [a-zA-Z0-9_]
\W # exceto caracteres alfanuméricos,
o mesmo que [^a-zA-Z0-9_]
\d # qualquer dígito
o mesmo que [0-9]**
**\D # exceto dígitos, [^0-9] \s # qualquer caractere em branco: espaço,
tab, newline, etc
\S # exceto caracteres em branco \b # uma palavra limitada, fora de [] \B # nenhuma palavra limitada**
Está claro que caracteres como $ , | , [ , ) , ** , / são casos particulares em expressões regulares. Se você quiser comparar um ou mais destes caracteres, então deve sempre precedê-los de uma barra invertida:
| # barra vertical [ # colchetes esquerdo ) # parênteses direito * # asterisco ^ # circunflexo / # uma barra \ # barra invertida
_________________________________________________________________
Alguns exemplos de ERs
Como foi mencionado antes, o uso de expressões regulares deve ocorrer aos poucos. Aqui estão alguns exemplos. Lembre-se sempre de usá-los entre barras /.../
**[01] # tanto "0" ou "1" /0 # divisão por zero / 0 # divisão por zero com um espaço /\s0 # divisão por zero com um espaço em branco
"/ 0" onde o espaço pode ser um tab, por exemplo
/ *0 # divisão por zero com nenhum ou alguns espaços
"/0" ou "/ 0" ou "/ 0" etc
/\s+0 # divisão por zero com alguns espaços em branco /\s+0.0* # como o anterior, mas com ponto decimal
e alguns zeros depois dele, ou não
"/ 0." ou "/ 0.0" ou "/ 0.000" etc
observe a barra invertida antes do ponto**
Exercício
Seu programa anterior contava linhas não-vazias. Altere ele de modo que conte somente linhas com:
Este exemplo somente substitui a primeira ocorrência da string, mas pode ser que tenha mais do que uma string que desejamos substituir.
Para fazer uma substituição global, a última barra deve ser seguida por um g:
s/londres/Londres/g
que obviamente utiliza a variável $_. Novamente a expressão retorna o número de substituições realizadas, que é zero ou alguma coisa maior que zero (verdadeiro).
Se desejarmos também substituir ocorrências de lOndres, lonDRES, LoNDrES e assim por diante, então podemos usar:
s/[Ll][Oo][Nn][Dd][Rr][Ee][Ss]/Londres/g
mas um modo mais fácil é usar a opção i (para ignorar letras maiúsculas ou minúsculas). A expressão:
s/londres/Londres/gi
fará uma substituição global não importando se foi usado letras maiúsculas ou minúsculas. A opção i também pode ser usada em expressões regulares básicas.
Recordando modelos
É frequentemente útil recordar modelos que tem sido comparados de modo que eles possam ser usados novamente. Isto ocorre porque qualquer coisa comparada entre parênteses retorna nas variáveis $1,...,$9. Estas strings também podem ser usadas da mesma forma que nas expressões regulares (ou substituições) utilizando os códigos especiais ER \1,...,\9.
Esse teste:
$_ = "Lorde Whopper de Fibbing"; s/([A-Z])/:\1:/g; print "$_\n";
colocará cada letra maiúscula entre : (dois pontos). Neste exemplo, mostrará :L:orde :W:hopper de :F:ibbing. As variáveis $1,...,$9 são somente de leitura, você não pode alterá-las.
Como outro exemplo, o teste:
if (/(\b.+\b) \1/) { print "Encontrou $1 repetida\n"; }
irá identificar qualquer palavra repetida. Cada \b representa uma palavra limitada e .+ compara qualquer string não vazia, então \b.+\b compara qualquer coisa entre duas palavras limitadas.
O resultado é então armazenado como \1 para expressões regulares e como $1 para o resto do programa.
Se $_ for igual a "teste teste teste2 teste2", a mensagem será mostrada, mas somente com a primeira ocorrência.
O seguinte exemplo troca o primeiro e último caracteres da linha na variável $_ :
s/^(.)(.)(.)$/\3\2\1/*
O ^ e o $ comparam o início e o fim da linha. O código \1 armazena o primeiro caractere, o \2 armazena cada string entre os dois e o último caractere é armazenado no código \3. Então aquela linha é substituída com a troca entre \1 e **.
Após uma comparação, você pode usar variáveis especiais somente de leitura $` ou $& ou $' para encontrar o que foi comparado antes, durante e depois da busca. Então:
$_ = "Lorde Whopper de Fibbing"; /pp/;
resultará em verdadeiro nas seguintes declarações (recorde que eq é um teste usado em strings):
$` eq "Lorde Who"; $& eq "pp"; $' eq "er de Fibbing";
Finalmente, sobre o tópico Recordando modelos, o importante é saber que dentro de barras de uma comparação ou substituição, as variáveis são interpoladas. Então:
$busca = "par"; s/$busca/xxx/g;
irá substituir cada ocorrência com xxx. Se você quiser substituir cada ocorrência de para então você não pode usar s/$buscaa/xxx/g porque o a será interpolado com a variável $busca. Ao invés disso, você deve colocar o nome da variável entre chaves, de modo que o código seja:
$busca = "par"; s/${busca}a/xxx/g;
Tradução
