Baixar para ler offline
![Capítulo 3
Lição 2 - Básico 2 (arrays, listas,
contexto)
3.1 Elementos de um array
Para acessar os elementos de um array, utilize o operador colchete:
print "$params[0] $params[2]n";
Os números entre colchetes são índices. Essa expressão imprime os elementos de @params
com os índices 0 e 2. O cifrão de dólar indica que os elementos desse array são valores escalares.
Com sabemos, um valor escalar é aquele que é tratado como uma unidade sem partes, em
contraposição ao valor de arrays, que são compostos de elementos. Existem três tipos de valores
escalares: números, strings e referências. Em nosso exemplo, os elementos do array são strings.
Para armazenar um valor escalar temos de usar uma variável escalar:
my $word = $params[0];
print "$wordn";
O cifrão de dólar no início de $word indica que esta é uma variável escalar.
Como o nome do array é @params, é tentador escrever a linha acima como:
# exemplo de linha incorreta:
my $word = @params[0];
Ou seja, designando o elemento de índice 0 do array parâmetro como se fosse um array ( @
). A variável @params é um array, e por isso o arroba, mas seus elementos são escalares. O
correto é nos referir ao elemento como $params[0];
A primeira linha do exemplo incorreto acima é um comentário.
Comentários começam com o caractere hash ( # ) e terminam ao nal da linha, como em bash
script.
O Perl tentaria executar esse erro se ele estivesse presente. Existe, no entanto, um pragma,
o warnings que altera o comportamento do Perl para que ele cheque a presença desse tipo de
erro. Adicione a seguinte linha ao seu código:
27](https://image.slidesharecdn.com/perl-160921151514/85/Perl-28-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
use warnings;
Se executássemos o programa com a linha errada o Perl agora avisaria:
Scalar value @params[0] better written as $params[0].
Enquanto aprendendo Perl, é bom que se utilize os pragmas strict e warnings para que
ajudem a encontrar erros. Mais tarde, ao trabalhar com programas maiores, ainda é bom utilizá-
los para garantir uma boa prática de programação. Em outras palavras, é sempre bom utilizá-los.
Podemos ter, de uma vez só, mais de um elemento de um array colocando uma lista dos
índices entre os colchetes.
O seguinte programa cria uma varíavel de array chamada @words e a designa um novo array
que contém os elementos (de índice) 0 e 2 de @params.
my @words = @params[0, 2];
print @wordsn;
O novo array é dito um slice.
3.2 Contexto escalar e de lista
Até então, nós vimos dois tipos built-in do Perl, os arrays e os valores escalares. Variáveis de
array começam com ’ @ ’ e variáveis escalares, com ’ $ ’. De fato, em muitos casos, expressões
com arrays que começam com @ e com escalares que começam com $ são facilmente vistas.
Mas nem sempre.
Lembre-se: a forma como uma expressão é avaliada depende de seu contexto!
Em uma expressão de atribuição, a parte da esquerda determina o contexto. Se a parte da
esquerda for uma variável escalar, a parte da direita será avaliada em contexto escalar. Se a
parte da esquerda for um array, então a parte da direita será avaliada em contexto de lista.
Se um array for avaliado em contexto escalar, ele terá o número de elementos do array. O
seguinte programa imprime o número de parâmetros. Deixarei para você ver o que acontece se
se avaliar um escalar em contexto de lista.
my $word = @params;
print $wordn;
3.3 Listas literais
Uma forma de atribuir um valor a uma varíavel de array é utilizar uma lista literal. Uma lista
literal é uma expressão que carrega o valor de uma lista. Eis o exemplo típico de uma lista padrão:
my @list = (1, 2, 3);
print @listn;
Na maior parte do tempo, podemos pensar que listas e arrays são a mesma coisa. Existem
diferenças, mas, por hora a única com que vamos nos deparar é a seguinte: quando avaliamos
28](https://image.slidesharecdn.com/perl-160921151514/85/Perl-29-320.jpg)
![Capítulo 5
Lição 4 - Expressões regulares 1
5.1 Casando padrões
O operador que conecta padrões [= ] compara uma string na esquerda com um padrão na
direita. Ao comparar ele retorna verdadeiro se a string bate com o padrão. Por exemplo, se o
padrão é uma seqüência de caracteres, a string casa se contiver essa seqüência.
if ($line = abc) { print $line; }
Em um dicionário de inglês, a única palavra encontrada foi Babcok.
Mais freqüentemente, o padrão da direita é um padrão que casa, que parece algo assim:
m/abc/. O padrão entre barras pode ser qualquer expressão regular, o que significa que além
de caracteres simples, ele pode conter também metacaracteres com significados especiais. Um
metacaractere comum é o ponto ( . ) , que é um coringa que pode casar com qualquer caractere.
Por exemplo, a expressão regular ’pa..u.e’ casa com quaisquer strings que contenham os ca-
racteres ’pa’ , seguido exatamente de dois caracteres, depois ’u’, depois exatamente um caractere
e por fim a letra ’e’. No dicionário de inglês quatro palavras bateram: departure, departures,
pasturee pastures.
A seguinte subrotina pega dois parâmetros, um padrão e um arquivo. Ela lê cada linha do
arquivo e imprime aquela que casa com o padrão. Este tipo de coisa é muito útil para trapacear
palavras cruzadas!
sub grep_file {
my $padrao = shift;
my $arquivo = shift;
open ARQUIVO, $arquivo;
while (my $linha = ARQUIVO) {
if ($linha = m/$padrao/) {print $linha }
}
}
Chamei esta subrotina de ’grep_file’ tendo em mente o utilitário Linux grep, que faz quase que
a mesma coisa.
Note que a última expressão de um bloco não precisa de ponto-e-vírgula.
34](https://image.slidesharecdn.com/perl-160921151514/85/Perl-35-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
5.2 Âncoras
Apesar do programa anterior ser útil para trapacear em palavras cruzadas, podemos fazê-lo
melhor com âncoras. Âncoras nos permitem especificar onde na linha o padrão deve aparecer.
Podemos encurtar a busca utilizando o metacaractere ˆ, que indica que o padrão deve estar no
início da linha. Ou melhor, o início do padrão deve bater com o início da linha. Analogamente, o
caractere $ indica que o padrão deve estar ao final da linha. Ou melhor, o final do padrão deve
casar com o final da linha. Colocar um padrão qualquer entre os dois metacaracteres como em
ˆpadrão$, portanto, garante que o padrão deve coincidir com toda a linha.
5.3 Quantificadores
Um quanticador é parte de uma expressão regular que controla quantas vezes uma dada seqüên-
cia deve aparecer.
Por exemplo, o quantificador {2} diz que o padrão deve aparecer duas vezes. Seu uso é,
porém, um pouco truculento por se aplicar a uma parte do padrão chamada ’átomo’.
Todo caractere simples, por ele mesmo, em um padrão, é um átomo. Da mesma forma, uma
seqüência de caracteres entre parênteses também é um átomo. Ou seja, para tratar um conjunto
de mais de um caractere juntos como um único átomo, temos de colocá-los entre parênteses.
Os termos ’a+’ e ’a*’ quase representam o mesmo conjunto. A diferença é que ’a*’ também
contém a string vazia. Então o padrão ab{2} casa qualquer palavra com um ’a’ seguido de
dois ’b’s, mas o padrão (ba){2} só casaria com uma palavra que contivessa a seqüência ’ba’
repetida duas vezes, como em ’babado’. O padrão (.es.){3} casa com qualquer palavra em que o
padrão [caractere qualquer] es [caractere qualquer]apareça três vezes. Em inglês há a palavra
restlessness, por exemplo, que satisfaz o padrão.
O quantificador ’?’ especifica que um átomo é opcional; ou seja, que ele pode aparecer 0 ou
uma 1 vez. Então o padrão (in)?comum casa tanto com comumquanto com incomum.
Similarmente, o quantificador ’+’ indica que um átomo pode aparecer uma ou mais vezes e o
quantificador ’*’ indica que um átomo pode aparecer 0 ou mais vezes.
Até então, falamos sobre expressões regulares em termos de casamento de padrões. Mas há
outra forma de pensarmos sobre elas:
uma expressão regular é uma forma de denotar um conjuntos de strings.
No exemplo mais simples, a expressão regular ’abc’ representa o conjunto que contém uma
string ’abc’. Com quantificadores, os conjuntos são mais interessantes. Por exemplo, a expressão
regular ’a+’ representa o conjunto que contém a, aa, aaa, aaaa, e daí por diante. É um
conjunto infinito, então é conveniente que possamos representá-lo de forma tão sucinta.
5.4 Alternância
O metacaractere ’ | ’ é como uma conjunção ’ou’; ele indica que ’ou um átomo ou o outro’.
Então a expressão regular a|b|c representa os conjuntos que contêm cada um um dos carateres
e suas combinações. O termo ˆ(des|in) casa com qualquer palavra que inicia com ’des’ ou com
’in’. Existe uma forma mais simples, no entanto, de designar um conjunto (de conjuntos) longo de
35](https://image.slidesharecdn.com/perl-160921151514/85/Perl-36-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
caracteres alternativos do que com um termo como a|b|c|d|e. Podemos representar este conjunto
maior usando os colchetes assim: [abcde].
O metacaractere colchete define uma classe de caracteres, que casa com palavras que con-
tenham quaisquer caracteres incluídos na classe. Então o termo ˆ[abcde] casa com qualquer
palavra que inicie com qualquer um dos caracteres listados, e o termo ˆ[abcde]+$ casa com qual-
quer palavra que só contenha estes caracteres, ainda que não necessariamente eles todos, do
início ao fim.
Entre colchetes, o metacaractere ’hífen’, ’ - ’, especifica um escopo de caracteres, então [1-5]
é o mesmo que [12345] e o termo [0-9A-Da-z] é o mesmo que [0123456789ABCDabcdefghij-
klmnopqrstuvxwyz]. Inclusive, o metacaractere ’ ˆ’, que do lado de fora indica o início de uma
palavra, dentro dos colchetes serve para negar a classe de caracteres. Ou seja, o termo [ˆ0-9]
casa com qualquer palavra que não é um dígito (ou, ao menos, que não contém um).
ˆ[ˆ-], repare, casa com qualquer coisa que não inicie com um hífen - ou seja, o hífen perde o
caráter especial se iniciar a seqüência da classe de caracteres e passa a representar ele mesmo,
um hífen.
Diversas classes de caracteres são predenidas e podem ser especicadas com termos com contra-
barra como d, que representa qualquer dígito, equivalentemente a [0-9].
Semelhantemente, s casa com qualquer caractere de espaço em branco (espaço, tab, linha
nova, return, form feed), e w casa com os chamados ’caracteres de palavras’ (letras maiúsculas
e minúsculas, dígitos e ’ _ ’).
5.5 Captura de sequências
Em uma expressão regular, os parênteses têm duas funções. Como já vimos, eles agrupam
uma seqüência de caracteres em um átomo para que, por exemplo, um quantificador possa ser
aplicado a uma seqüência e não a uma única letra. Além disso, eles indicam uma parte da string
que casa que deveria ser capturada; ou seja, armazenada para uso posterior. Por exemplo, o
padrão http: (.*) casa com qualquer URL que comece com ’http:’, mas também salva o resto da
URL na variável chamada ’$1’. O seguinte fragmento checa uma linha pela presença de uma
URL e então imprime tudo que aparece após http:.
my $pattern = http: (.*); if ($line = m/$pattern/) { print $1n}
Se estamos também interessados um URLs que usem ftp, podemos escrever algo como:
my pattern = (ftp|http): (.*); if ($line = m/$pattern/) { print $1, $2n;}
Já que há duas seqüências em parênteses, o casamento cria duas variáveis, $1 e $2. Essas
variáveis são chamadas backreferences, e as strings às quais elas se referem são as captured
strings, ou seqüências capturadas. Seqüências capturadas podem ser aninhados. Por exemplo, a
expressão regular ((ftp|http): (.*)) cria três variáveis: $1 corresponde à seqüência capturada mais
externa, que carrega string casada inteira; $2 e $3 correspondem às duas seqüências aninhadas.
36](https://image.slidesharecdn.com/perl-160921151514/85/Perl-37-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
Infelizmente, porque o || tem maior precedência que o or essa expressão computa $file ||
die Não foi possível abrir $filen primeiro, que carrega o valor de $file, então o die nunca é
executado, mesmo que o arquivo não exista.
Uma forma de evitar esse problema é usar o or. Outra forma é usar a função call syntax para
open. O que segue funciona porque a função call syntax é avaliada na ordem que esperamos.
open(FILE, $file) || die Não foi possível abrir $filen;
Gostaria de comentar que existem duas variáveis especiais que podem gerar mais mensagens
de erro úteis.
die $0: Não foi possível abrir $file: $!n;
Em Perl (e em bash script), a variável $0 contém o nome do programa que está rodando e $!
contém uma descrição textual da mensagem de erro mais recente.
Esse idioma é tão comum que é uma boa idéia encapsulá-lo em uma subrotina:
sub croak { die $0: @_: $!n}
(Pegamos o nome croak emprestado de Programming Perl, de Wall, Christiansen e Orwant.)
6.5 A semântica das subrotinas
Anteriormente vimos que o nome especial @_ em uma subrotina se refere à lista de parâme-
tros. Ou melhor ainda, os elementos da lista de parâmetros são apelidos, aliases, para os valores
escalares providos como argumentos.
Um alias é uma forma alternativa de se referir a uma variável.
Em outras palavras, @_ pode ser usado para acessar e modificar variáveis que são usadas
como argumentos.
Por exemplo, swap pega dois parâmetros e troca seus valores:
sub swap {
($_[0], $_[1]) = ($_[1], $_[0]);
}
Em uma atribuição em lista, a parte da direita é avaliada antes da realização de qualquer
atribuição, então não há necessidade de uma variável temporária para fazer a troca.
O seguinte código testa a troca:
my $um = 1;
my $dois = 2;
swap($um, $dois);
print $um, $doisn;
Como previsto, a saída é 2, 1. Como swap tenta modificar seus parâmetros, é ilegal invocá-lo
com valores constantes. A expressão swap(1,2) retorna:
Modification of a read-only value attempted in ./swap.pl
Por outro lado, podemos chamá-lo com uma lista:
39](https://image.slidesharecdn.com/perl-160921151514/85/Perl-40-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
tabela, então modificar o array é tudo o que temos de fazer.
Note que as declarações our e my podem se aplicar a uma lista de variáveis.
8.5 Texto aleatório
Agora que analisamos o texto original, gostaríamos de gerar um texto aleatório que tenha as
mesmas combinações de palavras com a mesma freqüência.
O primeiro passo é escolher um prefixo aleatório do hash. O operador rand escolhe um
número aleatório (ponto flutuante) entre 0 e seu parâmetro (até, mas não incluso, o parâmetro).
Então a expressão rand @list escolhe um índice aleatório de uma lista dada (porque quando a
lista é avaliada em contexto escalar ela contém seu tamanho).
A subrotina rand_elt escolhe e retorna um elemento aleatório da lista de parâmetros.
sub rand_elt { $_[rand @_] }
Agora escolhendo uma chave aleatória do hash é fácil:
my $prefix = rand_elt keys %hash;
Em seguida capturamos o prefixo no hash, separamos a string de palavras em uma lista e
escolhemos um elemento aleatório.
my $words = $hash{$prefix};
my $word = rand_elt split , $words;
Finalmente, podemos formar o prefixo seguinte separando o prefixo antigo, trocando (com
shift) a primeira palavra e anexando a nova.
my @triple = split , $prefix;
shift @triple;
$prefix = @triple $word;
49](https://image.slidesharecdn.com/perl-160921151514/85/Perl-50-320.jpg)
![Capítulo 10
Lição 9 - Objetos 2
10.1 Imprimindo Objetos
Para fins de debugging, vamos quase sempre querer um método que imprima o estado de um
objeto. Aqui está uma simples solução:
sub imprimir {
my $self = shift;
while ((my $key, my $value) = each %$self)
{ print $key = $valuen; }
}
Por conta do argumento ser uma referência a um hash, temos de usar o termo %$self para o
dereferenciar.
Este método simplesmente imprime as chaves e valores do hash. Se alguns dos valores são
referências, o Perl imprime o tipo de referência e seu identificador único. Podemos querer adicio-
nar código a esse método para imprimir o conteúdo do objeto de uma forma mais informativa.
10.2 Pilhas
Para demonstrar um objeto mais interessante, vamos escrever a implementação de uma pi-
lha. Para desenvolver o código gradualmente, vamos começar com uma pilha de número. Eis a
declaração do pacote e o construtor:
package Pilha;
sub new {
my $class = shift;
my $self = { aref = [ ], next = 1
@_};
bless $self, $class;
}
As variáveis de instância são referências a um array, (sabiamente dito aref) e a um número
chamado next que acompanha a próxima posição disponível no array. A expressão [ ] cria a
referência a um array com um único elemento, uma string vazia. Não utilizaremos o primeiro
elemento do array, então estamos colocando lá a string vazia para ocupar esse lugar. O valor
inicial de next é o índice da primeira posição que vamos utilizar, 1.
Como de hábito, é uma boa idéia ter um método que imprima o estado de um objeto.
54](https://image.slidesharecdn.com/perl-160921151514/85/Perl-55-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
sub print {
my $self = shift;
my $next = $self-{next};
my $aref = $self-{aref};
print array = @$arefn;
print next = $nextn;
}
Visto que self-{aref} é uma referência a um array, nós temos de o dereferenciá-lo para impri-
mir seu conteúdo. $self-{next} é um escalar, então tudo o que temos de fazer agora é imprimi-lo.
10.3 Pilhas - Adicionar
O método adicionar pega dois parâmetros, a pilha e o valor que queremos adicionar. Ele põe
o valor na próxima posição disponível no array e então o incrementa.
sub adicionar { my ($self, $value) = @_; my $index = $self-{next}; $self-{aref}[$index]
= $value; $self-{next}++; }
$index é uma cópia local da variável de instância next. Podemos usar seu valor como índice
à aref, mas para que atualizemos o next temos que usar o termo $self-{next}. É motivo de
surpresa que possamos acessar os elementos de um array usando as chaves. Afinal, $self-
{aref} é uma referência a um array, e não o próprio array, e normalmente o Perl não dereferencia
automaticamente. Considere os seguintes exemplos:
my @array = ( 1, 2, 3 );
my $aref = [ 1, 2, 3 ];
A primeira linha cria a lista e a atribui a um array chamado @array. A segunda linha cria a
referência a um array e atribui a um escalar chamado $aref. Nós podemos usar os colchetes
para acessar os elementos de @array, então o termo $array[1] tem o valor 2. Mas a expressão
$aref[1] é ilegal. Vamos ter uma resposta como:
Global symbol @arefrequires explicit package name
E isso porque o Perl pensa que estamos perguntando pelo segundo elemento de um array
chamado @aref. A solução usual é utilizar o operador flecha, como em $aref-[1], que derefe-
rencia $aref e então pega o elemento 1. Então, se colocarmos uma referência a array em um
hash, da seguinte forma:
my %hash; $hash{aref} = $aref;
como acessamos seus elementos? Poderíamos pensar que deveríamos usar o operador
flecha novamente, como em $hash{aref}-[1]. Isso funciona, na verdade, mas não é a solução
mais comum. Acontece que podemos pegar a referência do hash e a dereferenciar ao mesmo
tempo, como em $hash{aref}[1]. Neste momento pode ser que você esteja zonzo, isto é normal.
Ignore. Podemos testar os métodos adicionar e imprimir colocando alguns números aleatórios
em uma pilha:
my $pilha = Pilha-new; for (my $i=0; $i10; $i++) { $pilha-adicionar (rand 100);
} $pilha-imprimir;
55](https://image.slidesharecdn.com/perl-160921151514/85/Perl-56-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
Se tentarmos, vamos provavelmente ver um array de dez números aleatórios entre 0 e 100, e
o valor do next deverá ser 10.
10.4 Pilhas Remover
Eis aqui um método remover que remove e retorna o primeiro elemento de um array e move
o último elemento para a primeira posição.
sub remover { my $self = shift; my $aref = $self-{aref}; my $resultado = $aref-[1];
$aref-[1] = pop @$aref; $self-{next}; return $resultado }
Como de costume, a primeira linha pega o parâmetro. A segunda linha faz uma cópia local da
referência de array aref.
Se o valor de uma variável de instância é uma referência, então podemos desempacotá-lo, un-
pack it, designando-o a uma variável local. Por ser uma referência, podemos utilizá-la tanto para
ler quanto para escrever o array.
As próximas três linhas (1) guardam o primeiro elemento da pilha, que é o resultado que
vamos retornar, (2) move o último elemento da pilha para a frente (por razão que se esclarecerá),
e (3) decrementa next, que o seta como o índice da posição não-disponível que acabamos de
esvaziar. Podemos testar remover com o seguinte loop:
for (1..10) { my $valor = $pilha-remover; print $valorn; }
O operador .. constrói uma lista de elementos de 1 a 10.
Quanto a expressão for é aplicada a uma lista, ela se comporta como uma expressão foreach.
Se rodarmos esse código, ele imprimirá os elementos da pilha, mas não em ordem numérica, ainda
(e nem sequer na ordem em que foram adicionados).
Uma alternativa melhor é implementar esvaziar:
sub esvaziar { my $self = shift; return $self-{next} == 1; }
Então podemos usar a expressão until para esvaziar a pilha:
until ($pilha-esvaziar) { my $valor = $pilha-remover; $valor-imprimir; }
O until é o mesmo que o while, só que com a condição invertida.
10.5 Módulos
Já vimos como usar um módulo existente com o use. Agora vamos ver como criar um novo
módulo.
Em um programa orientado à objetos, um módulo é usualmente um arquivo que define um
pacote. Começando com a nossa implemenação de pilha, podemos criar um módulo em poucos
passos:
1 - renomeie o arquivo pilha.pl, que tem a extensão de um programa, para pilha.pm, que
indica tratar-se de um módulo Perl.
56](https://image.slidesharecdn.com/perl-160921151514/85/Perl-57-320.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
O último passo é juntar o nome do arquivo e abrir o arquivo:
my $arquivo = $uri-authority . $path; open FILE, , $arquivo or croak Não foi
possível abrir $arquivo;
Estamos usando a parte authorityda URI como diretório de topo, de forma que todas as
páginas que pegarmos a partir de um mesmo site vão parar em um mesmo diretório.
11.6 Analisando
Enquanto lemos o conteúdo de uma página da web, podemos também querer extrair os links
que ela contém. A forma mais simples de fazê-lo é procurar pelos padrões que casam com a
tag a. Mas há um módulo chamado HTML::Parser que é ainda mais acessível (assim que se
aprende como usá-lo), e que nos dá outra chance de utilizar os callbacks.
Antes de analisar, vamos criar o objeto Parser.
our $p = HTML::Parser-new(
start_h = [$start_tag, tagname, attr]; )
Os parâmetros que enviamos ao construtor são, como de costume, uma lista de variáveis
de instância e seus valores. Nesse caso, a variável de instância é start_h. Um manipulador
(handler) é um tipo de callback que é invocado para lidar com um tipo de evento. O Parser utiliza
manipuladores para vários outros tipos de eventos, aliás.
O valor de start_h é uma lista que contém uma referência ao callback, que é sabiamente
chamado start_tag, e também uma string que especifica que informação deveria ser passada
como parâmetro ao callback. Nesse caso, queremos que o nome da tag um hash que contenha
os atributos que aparecem na tag.
Por exemplo, o seguinte código HTML gera um link textual.
a href=http://exemplo.compágina da weba
Quando esse código é analisado, ele gera três eventos. O primeiro é uma tag de abertura com
nome de tag ’ a ’ e um hash de atributos que contém uma entrada, href = http://exemplo.com.
O próximo evento é um evento textual com o texto página da web. O último evento é uma tag de
finalização com o nome de tag ’ a ’ (e nenhum atributo).
Eis uma versão de start_tag que espera por links a e imprime a URI a qual eles se referem.
sub start_tag {
my ($tagname, $attr) = @_;
if ($tagname eq a) {
my $href = $attr-{href};
print $hrefn;
}
}
O objeto analisador é incrementante, o que significa que podemos invocar parse repetida-
mente, passando porções de quaisquer tamanhos de código HTML. Essa capacidade funciona
bem com o código da seção anterior que armazena o arquivo que chega em porções. Podemos
modificar callback de forma que ele armazene cada porção e o passe para o Parser.
sub callback {
my $linha = shift;
61](https://image.slidesharecdn.com/perl-160921151514/85/Perl-62-320.jpg)
Mais conteúdo relacionado
Perl
- 1.
- 2. Sumário I Sobre essaApostila 2 II Informações Básicas 4 III GNU Free Documentation License 9 IV Perl 18 1 Introdução 19 1.1 Informações Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 1.1.1 Sobre o curso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 1.1.2 Plano de ensino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2 Lição 1 - Básico 1 (variáveis, subrotinas, pragmas) 22 2.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.2 Echo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.3 Erros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.4 Subrotinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 2.5 Variáveis locais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3 Lição 2 - Básico 2 (arrays, listas, contexto) 26 3.1 Elementos de um array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.2 Contexto escalar e de lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.3 Listas literais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.4 Atribuição em lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 3.5 Operador Shift . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 4 Lição 3 - Arquivos 30 4.1 Manipuladores de arquivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.2 Cat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.3 Foreach e @_ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 5 Lição 4 - Expressões regulares 1 33 5.1 Casando padrões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 5.2 Âncoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 5.3 Quantificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 5.4 Alternância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 1
- 3. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 5.5 Captura de sequências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 6 Lição 5 - Expressões regulares 2 36 6.1 Casamento mínimo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 6.2 Padrões extendidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 6.3 Alguns operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.4 Operadores pré-fixados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 6.5 A semântica das subrotinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 7 Lição 6 - Hashes 40 7.1 Operadores de pilha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 7.2 Operadores de fila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 7.3 Hashes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 7.4 Tabela de freqüência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 7.5 Ordenação . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 8 Lição 7 - Hashes 2 44 8.1 Conjunto e membros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 8.2 Referências a subrotinas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 8.3 Hashes como parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 8.4 Gerador Markov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 8.5 Texto aleatório . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 9 Lição 8 - Objetos 1 49 9.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 9.2 Pacotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 9.3 O operador Bless . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 9.4 Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 9.5 Construtores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 10 Lição 9 - Objetos 2 53 10.1 Imprimindo Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 10.2 Pilhas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 10.3 Pilhas - Adicionar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 10.4 Pilhas Remover . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 10.5 Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 11 Lição 10 - Callbacks e Pipes 57 11.1 Introdução . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 11.2 URIs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 11.3 HTTP GET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 11.4 Callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 11.5 Espelhando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 11.6 Analisando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 11.7 URIs absolutas e relativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 11.8 Processos múltiplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 11.9 Planejamento familiar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 11.10Fazendo filhos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 11.11Respondendo aos pais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 2
- 4. Parte I Sobre essaApostila 3
- 5. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Conteúdo O conteúdo dessa apostila é fruto da compilação de diversos materiais livres publicados na in- ternet, disponíveis em diversos sites ou originalmente produzido no CDTC (http://www.cdtc.org.br.) O formato original deste material bem como sua atualização está disponível dentro da licença GNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção de mesmo nome, tendo inclusive uma versão traduzida (não oficial). A revisão e alteração vem sendo realizada pelo CDTC (suporte@cdtc.org.br) desde outubro de 2006. Críticas e sugestões construtivas serão bem-vindas a qualquer hora. Autores A autoria deste é de responsabilidade de Tomas Ribeiro Cardoso (tomas@cdtc.org.br). O texto original faz parte do projeto Centro de Difusão de Tecnologia e Conhecimento que vêm sendo realizado pelo ITI (Instituto Nacional de Tecnologia da Informação) em conjunto com outros parceiros institucionais, e com as universidades federais brasileiras que tem produzido e utilizado Software Livre apoiando inclusive a comunidade Free Software junto a outras entidades no país. Informações adicionais podem ser obtidas através do email ouvidoria@cdtc.org.br, ou da home page da entidade, através da URL http://www.cdtc.org.br. Garantias O material contido nesta apostila é isento de garantias e o seu uso é de inteira responsabi- lidade do usuário/leitor. Os autores, bem como o ITI e seus parceiros, não se responsabilizam direta ou indiretamente por qualquer prejuízo oriundo da utilização do material aqui contido. Licença Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br) . Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Chapter being SOBRE ESSA APOS- TILA. A copy of the license is included in the section entitled GNU Free Documentation License. 4
- 6.
- 7. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Sobre o CDTC Objetivo Geral O Projeto CDTC visa a promoção e o desenvolvimento de ações que incentivem a dissemina- ção de soluções que utilizem padrões abertos e não proprietários de tecnologia, em proveito do desenvolvimento social, cultural, político, tecnológico e econômico da sociedade brasileira. Objetivo Específico Auxiliar o Governo Federal na implantação do plano nacional de software não-proprietário e de código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre os servidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercado nacional a adotar novos modelos de negócio da tecnologia da informação e de novos negócios de comunicação com base em software não-proprietário e de código fonte aberto, oferecendo treinamento específico para técnicos, profissionais de suporte e funcionários públicos usuários, criando grupos de funcionários públicos que irão treinar outros funcionários públicos e atuar como incentivadores e defensores dos produtos de software não proprietários e código fonte aberto, ofe- recendo conteúdo técnico on-line para serviços de suporte, ferramentas para desenvolvimento de produtos de software não proprietários e do seu código fonte livre, articulando redes de terceiros (dentro e fora do governo) fornecedoras de educação, pesquisa, desenvolvimento e teste de pro- dutos de software livre. Guia do aluno Neste guia, você terá reunidas uma série de informações importantes para que você comece seu curso. São elas: • Licenças para cópia de material disponível; • Os 10 mandamentos do aluno de Educação a Distância; • Como participar dos foruns e da wikipédia; • Primeiros passos. É muito importante que você entre em contato com TODAS estas informações, seguindo o roteiro acima. Licença Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br). 6
- 8. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior públicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSA APOSTILA. Uma cópia da licença está inclusa na seção entitulada "Licença de Docu- mentação Livre GNU". Os 10 mandamentos do aluno de educação online • 1. Acesso à Internet: ter endereço eletrônico, um provedor e um equipamento adequado é pré-requisito para a participação nos cursos a distância; • 2. Habilidade e disposição para operar programas: ter conhecimentos básicos de Informá- tica é necessário para poder executar as tarefas; • 3. Vontade para aprender colaborativamente: interagir, ser participativo no ensino a distân- cia conta muitos pontos, pois irá colaborar para o processo ensino-aprendizagem pessoal, dos colegas e dos professores; • 4. Comportamentos compatíveis com a etiqueta: mostrar-se interessado em conhecer seus colegas de turma respeitando-os e se fazendo ser respeitado pelos mesmos; • 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisão e a sua recuperação de materiais; • 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações e realizá-las em tempo real; • 7. Curiosidade e abertura para inovações: aceitar novas idéias e inovar sempre; • 8. Flexibilidade e adaptação: requisitos necessário à mudança tecnológica, aprendizagens e descobertas; • 9. Objetividade em sua comunicação: comunicar-se de forma clara, breve e transparente é ponto - chave na comunicação pela Internet; • 10. Responsabilidade: ser responsável por seu próprio aprendizado. O ambiente virtual não controla a sua dedicação, mas reflete os resultados do seu esforço e da sua colaboração. Como participar dos fóruns e Wikipédia Você tem um problema e precisa de ajuda? Podemos te ajudar de 2 formas: A primeira é o uso dos fóruns de notícias e de dúvidas gerais que se distinguem pelo uso: . O fórum de notícias tem por objetivo disponibilizar um meio de acesso rápido a informações que sejam pertinentes ao curso (avisos, notícias). As mensagens postadas nele são enviadas a 7
- 9. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF todos participantes. Assim, se o monitor ou algum outro participante tiver uma informação que interesse ao grupo, favor postá-la aqui. Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico do curso. É recomendado que você faça uso do Fórum de dúvidas gerais que lhe dá recursos mais efetivos para esta prática. . O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativo para solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadas a todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podem ajudar. Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com a formalização ou a gramática. Responda! E não se esqueça de que antes de abrir um novo tópico é recomendável ver se a sua pergunta já foi feita por outro participante. A segunda forma se dá pelas Wikis: . Uma wiki é uma página web que pode ser editada colaborativamente, ou seja, qualquer par- ticipante pode inserir, editar, apagar textos. As versões antigas vão sendo arquivadas e podem ser recuperadas a qualquer momento que um dos participantes o desejar. Assim, ela oferece um ótimo suporte a processos de aprendizagem colaborativa. A maior wiki na web é o site "Wikipé- dia", uma experiência grandiosa de construção de uma enciclopédia de forma colaborativa, por pessoas de todas as partes do mundo. Acesse-a em português pelos links: • Página principal da Wiki - http://pt.wikipedia.org/wiki/ Agradecemos antecipadamente a sua colaboração com a aprendizagem do grupo! Primeiros Passos Para uma melhor aprendizagem é recomendável que você siga os seguintes passos: • Ler o Plano de Ensino e entender a que seu curso se dispõe a ensinar; • Ler a Ambientação do Moodle para aprender a navegar neste ambiente e se utilizar das ferramentas básicas do mesmo; • Entrar nas lições seguindo a seqüência descrita no Plano de Ensino; • Qualquer dúvida, reporte ao Fórum de Dúvidas Gerais. Perfil do Tutor Segue-se uma descrição do tutor ideal, baseada no feedback de alunos e de tutores. O tutor ideal é um modelo de excelência: é consistente, justo e profissional nos respectivos valores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita as idéias dos estudantes, é paciente, pessoal, tolerante, apreciativo, compreensivo e pronto a ajudar. 8
- 10. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF A classificação por um tutor desta natureza proporciona o melhor feedback possível, é crucial, e, para a maior parte dos alunos, constitui o ponto central do processo de aprendizagem.’ Este tutor ou instrutor: • fornece explicações claras acerca do que ele espera e do estilo de classificação que irá utilizar; • gosta que lhe façam perguntas adicionais; • identifica as nossas falhas, mas corrige-as amavelmente’, diz um estudante, ’e explica por- que motivo a classificação foi ou não foi atribuída’; • tece comentários completos e construtivos, mas de forma agradável (em contraste com um reparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, de ameaça e de nervossismo’) • dá uma ajuda complementar para encorajar um estudante em dificuldade; • esclarece pontos que não foram entendidos, ou corretamente aprendidos anteriormente; • ajuda o estudante a alcançar os seus objetivos; • é flexível quando necessário; • mostra um interesse genuíno em motivar os alunos (mesmo os principiantes e, por isso, talvez numa fase menos interessante para o tutor); • escreve todas as correções de forma legível e com um nível de pormenorização adequado; • acima de tudo, devolve os trabalhos rapidamente; 9
- 11. Parte III GNU FreeDocumentation License 10
- 12. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF (Traduzido pelo João S. O. Bueno através do CIPSGA em 2001) Esta é uma tradução não oficial da Licença de Documentação Livre GNU em Português Brasi- leiro. Ela não é publicada pela Free Software Foundation, e não se aplica legalmente a distribuição de textos que usem a GFDL - apenas o texto original em Inglês da GNU FDL faz isso. Entretanto, nós esperamos que esta tradução ajude falantes de português a entenderem melhor a GFDL. This is an unofficial translation of the GNU General Documentation License into Brazilian Por- tuguese. It was not published by the Free Software Foundation, and does not legally state the distribution terms for software that uses the GFDL–only the original English text of the GFDL does that. However, we hope that this translation will help Portuguese speakers understand the GFDL better. Licença de Documentação Livre GNU Versão 1.1, Março de 2000 Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA É permitido a qualquer um copiar e distribuir cópias exatas deste documento de licença, mas não é permitido alterá-lo. INTRODUÇÃO O propósito desta Licença é deixar um manual, livro-texto ou outro documento escrito "livre"no sentido de liberdade: assegurar a qualquer um a efetiva liberdade de copiá-lo ou redistribui-lo, com ou sem modificações, comercialmente ou não. Secundariamente, esta Licença mantém para o autor e editor uma forma de ter crédito por seu trabalho, sem ser considerado responsável pelas modificações feitas por terceiros. Esta Licença é um tipo de "copyleft"("direitos revertidos"), o que significa que derivações do documento precisam ser livres no mesmo sentido. Ela complementa a GNU Licença Pública Ge- ral (GNU GPL), que é um copyleft para software livre. Nós fizemos esta Licença para que seja usada em manuais de software livre, por que software livre precisa de documentação livre: um programa livre deve ser acompanhado de manuais que provenham as mesmas liberdades que o software possui. Mas esta Licença não está restrita a manuais de software; ela pode ser usada para qualquer trabalho em texto, independentemente do assunto ou se ele é publicado como um livro impresso. Nós recomendamos esta Licença prin- cipalmente para trabalhos cujo propósito seja de introdução ou referência. APLICABILIDADE E DEFINIÇÕES Esta Licença se aplica a qualquer manual ou outro texto que contenha uma nota colocada pelo detentor dos direitos autorais dizendo que ele pode ser distribuído sob os termos desta Licença. O "Documento"abaixo se refere a qualquer manual ou texto. Qualquer pessoa do público é um 11
- 13. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF licenciado e é referida como "você". Uma "Versão Modificada"do Documento se refere a qualquer trabalho contendo o documento ou uma parte dele, quer copiada exatamente, quer com modificações e/ou traduzida em outra língua. Uma "Seção Secundária"é um apêndice ou uma seção inicial do Documento que trata ex- clusivamente da relação dos editores ou dos autores do Documento com o assunto geral do Documento (ou assuntos relacionados) e não contém nada que poderia ser incluído diretamente nesse assunto geral (Por exemplo, se o Documento é em parte um livro texto de matemática, a Seção Secundária pode não explicar nada de matemática). Essa relação poderia ser uma questão de ligação histórica com o assunto, ou matérias relaci- onadas, ou de posições legais, comerciais, filosóficas, éticas ou políticas relacionadas ao mesmo. As "Seções Invariantes"são certas Seções Secundárias cujos títulos são designados, como sendo de Seções Invariantes, na nota que diz que o Documento é publicado sob esta Licença. Os "Textos de Capa"são certos trechos curtos de texto que são listados, como Textos de Capa Frontal ou Textos da Quarta Capa, na nota que diz que o texto é publicado sob esta Licença. Uma cópia "Transparente"do Documento significa uma cópia que pode ser lida automatica- mente, representada num formato cuja especificação esteja disponível ao público geral, cujos conteúdos possam ser vistos e editados diretamente e sem mecanismos especiais com editores de texto genéricos ou (para imagens compostas de pixels) programas de pintura genéricos ou (para desenhos) por algum editor de desenhos grandemente difundido, e que seja passível de servir como entrada a formatadores de texto ou para tradução automática para uma variedade de formatos que sirvam de entrada para formatadores de texto. Uma cópia feita em um formato de arquivo outrossim Transparente cuja constituição tenha sido projetada para atrapalhar ou de- sencorajar modificações subsequentes pelos leitores não é Transparente. Uma cópia que não é "Transparente"é chamada de "Opaca". Exemplos de formatos que podem ser usados para cópias Transparentes incluem ASCII sim- ples sem marcações, formato de entrada do Texinfo, formato de entrada do LaTex, SGML ou XML usando uma DTD disponibilizada publicamente, e HTML simples, compatível com os padrões, e projetado para ser modificado por pessoas. Formatos opacos incluem PostScript, PDF, formatos proprietários que podem ser lidos e editados apenas com processadores de texto proprietários, SGML ou XML para os quais a DTD e/ou ferramentas de processamento e edição não estejam disponíveis para o público, e HTML gerado automaticamente por alguns editores de texto com finalidade apenas de saída. A "Página do Título"significa, para um livro impresso, a página do título propriamente dita, mais quaisquer páginas subsequentes quantas forem necessárias para conter, de forma legível, o material que esta Licença requer que apareça na página do título. Para trabalhos que não tenham uma página do título, "Página do Título"significa o texto próximo da aparição mais proe- minente do título do trabalho, precedendo o início do corpo do texto. 12
- 14. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF FAZENDO CÓPIAS EXATAS Você pode copiar e distribuir o Documento em qualquer meio, de forma comercial ou não comercial, desde que esta Licença, as notas de copyright, e a nota de licença dizendo que esta Licença se aplica ao documento estejam reproduzidas em todas as cópias, e que você não acres- cente nenhuma outra condição, quaisquer que sejam, às desta Licença. Você não pode usar medidas técnicas para obstruir ou controlar a leitura ou confecção de cópias subsequentes das cópias que você fizer ou distribuir. Entretanto, você pode aceitar com- pensação em troca de cópias. Se você distribuir uma quantidade grande o suficiente de cópias, você também precisa respeitar as condições da seção 3. Você também pode emprestar cópias, sob as mesmas condições colocadas acima, e também pode exibir cópias publicamente. FAZENDO CÓPIAS EM QUANTIDADE Se você publicar cópias do Documento em número maior que 100, e a nota de licença do Documento obrigar Textos de Capa, você precisará incluir as cópias em capas que tragam, clara e legivelmente, todos esses Textos de Capa: Textos de Capa da Frente na capa da frente, e Textos da Quarta Capa na capa de trás. Ambas as capas também precisam identificar clara e legivelmente você como o editor dessas cópias. A capa da frente precisa apresentar o título com- pleto com todas as palavras do título igualmente proeminentes e visíveis. Você pode adicionar outros materiais às capas. Fazer cópias com modificações limitadas às capas, tanto quanto estas preservem o título do documento e satisfaçam a essas condições, pode ser tratado como cópia exata em outros aspectos. Se os textos requeridos em qualquer das capas for muito volumoso para caber de forma legível, você deve colocar os primeiros (tantos quantos couberem de forma razoável) na capa verdadeira, e continuar os outros nas páginas adjacentes. Se você publicar ou distribuir cópias Opacas do Documento em número maior que 100, você precisa ou incluir uma cópia Transparente que possa ser lida automaticamente com cada cópia Opaca, ou informar, em ou com, cada cópia Opaca a localização de uma cópia Transparente completa do Documento acessível publicamente em uma rede de computadores, à qual o público usuário de redes tenha acesso a download gratuito e anônimo utilizando padrões públicos de protocolos de rede. Se você utilizar o segundo método, você precisará tomar cuidados razoavel- mente prudentes, quando iniciar a distribuição de cópias Opacas em quantidade, para assegurar que esta cópia Transparente vai permanecer acessível desta forma na localização especificada por pelo menos um ano depois da última vez em que você distribuir uma cópia Opaca (direta- mente ou através de seus agentes ou distribuidores) daquela edição para o público. É pedido, mas não é obrigatório, que você contate os autores do Documento bem antes de redistribuir qualquer grande número de cópias, para lhes dar uma oportunidade de prover você com uma versão atualizada do Documento. 13
- 15. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF MODIFICAÇÕES Você pode copiar e distribuir uma Versão Modificada do Documento sob as condições das se- ções 2 e 3 acima, desde que você publique a Versão Modificada estritamente sob esta Licença, com a Versão Modificada tomando o papel do Documento, de forma a licenciar a distribuição e modificação da Versão Modificada para quem quer que possua uma cópia da mesma. Além disso, você precisa fazer o seguinte na versão modificada: A. Usar na Página de Título (e nas capas, se houver alguma) um título distinto daquele do Do- cumento, e daqueles de versões anteriores (que deveriam, se houvesse algum, estarem listados na seção "Histórico do Documento"). Você pode usar o mesmo título de uma versão anterior se o editor original daquela versão lhe der permissão; B. Listar na Página de Título, como autores, uma ou mais das pessoas ou entidades responsá- veis pela autoria das modificações na Versão Modificada, conjuntamente com pelo menos cinco dos autores principais do Documento (todos os seus autores principais, se ele tiver menos que cinco); C. Colocar na Página de Título o nome do editor da Versão Modificada, como o editor; D. Preservar todas as notas de copyright do Documento; E. Adicionar uma nota de copyright apropriada para suas próprias modificações adjacente às outras notas de copyright; F. Incluir, imediatamente depois das notas de copyright, uma nota de licença dando ao público o direito de usar a Versão Modificada sob os termos desta Licença, na forma mostrada no tópico abaixo; G. Preservar nessa nota de licença as listas completas das Seções Invariantes e os Textos de Capa requeridos dados na nota de licença do Documento; H. Incluir uma cópia inalterada desta Licença; I. Preservar a seção entitulada "Histórico", e seu título, e adicionar à mesma um item dizendo pelo menos o título, ano, novos autores e editor da Versão Modificada como dados na Página de Título. Se não houver uma sessão denominada "Histórico"no Documento, criar uma dizendo o título, ano, autores, e editor do Documento como dados em sua Página de Título, então adicionar um item descrevendo a Versão Modificada, tal como descrito na sentença anterior; J. Preservar o endereço de rede, se algum, dado no Documento para acesso público a uma cópia Transparente do Documento, e da mesma forma, as localizações de rede dadas no Docu- mento para as versões anteriores em que ele foi baseado. Elas podem ser colocadas na seção "Histórico". Você pode omitir uma localização na rede para um trabalho que tenha sido publicado pelo menos quatro anos antes do Documento, ou se o editor original da versão a que ela se refira der sua permissão; K. Em qualquer seção entitulada "Agradecimentos"ou "Dedicatórias", preservar o título da 14
- 16. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF seção e preservar a seção em toda substância e fim de cada um dos agradecimentos de contri- buidores e/ou dedicatórias dados; L. Preservar todas as Seções Invariantes do Documento, inalteradas em seus textos ou em seus títulos. Números de seção ou equivalentes não são considerados parte dos títulos da seção; M. Apagar qualquer seção entitulada "Endossos". Tal sessão não pode ser incluída na Versão Modificada; N. Não reentitular qualquer seção existente com o título "Endossos"ou com qualquer outro título dado a uma Seção Invariante. Se a Versão Modificada incluir novas seções iniciais ou apêndices que se qualifiquem como Seções Secundárias e não contenham nenhum material copiado do Documento, você pode optar por designar alguma ou todas aquelas seções como invariantes. Para fazer isso, adicione seus títulos à lista de Seções Invariantes na nota de licença da Versão Modificada. Esses títulos preci- sam ser diferentes de qualquer outro título de seção. Você pode adicionar uma seção entitulada "Endossos", desde que ela não contenha qual- quer coisa além de endossos da sua Versão Modificada por várias pessoas ou entidades - por exemplo, declarações de revisores ou de que o texto foi aprovado por uma organização como a definição oficial de um padrão. Você pode adicionar uma passagem de até cinco palavras como um Texto de Capa da Frente , e uma passagem de até 25 palavras como um Texto de Quarta Capa, ao final da lista de Textos de Capa na Versão Modificada. Somente uma passagem de Texto da Capa da Frente e uma de Texto da Quarta Capa podem ser adicionados por (ou por acordos feitos por) qualquer entidade. Se o Documento já incluir um texto de capa para a mesma capa, adicionado previamente por você ou por acordo feito com alguma entidade para a qual você esteja agindo, você não pode adicionar um outro; mas você pode trocar o antigo, com permissão explícita do editor anterior que adicionou a passagem antiga. O(s) autor(es) e editor(es) do Documento não dão permissão por esta Licença para que seus nomes sejam usados para publicidade ou para assegurar ou implicar endossamento de qualquer Versão Modificada. COMBINANDO DOCUMENTOS Você pode combinar o Documento com outros documentos publicados sob esta Licença, sob os termos definidos na seção 4 acima para versões modificadas, desde que você inclua na com- binação todas as Seções Invariantes de todos os documentos originais, sem modificações, e liste todas elas como Seções Invariantes de seu trabalho combinado em sua nota de licença. O trabalho combinado precisa conter apenas uma cópia desta Licença, e Seções Invariantes Idênticas com multiplas ocorrências podem ser substituídas por apenas uma cópia. Se houver múltiplas Seções Invariantes com o mesmo nome mas com conteúdos distintos, faça o título de 15
- 17. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF cada seção único adicionando ao final do mesmo, em parênteses, o nome do autor ou editor origianl daquela seção, se for conhecido, ou um número que seja único. Faça o mesmo ajuste nos títulos de seção na lista de Seções Invariantes nota de licença do trabalho combinado. Na combinação, você precisa combinar quaisquer seções entituladas "Histórico"dos diver- sos documentos originais, formando uma seção entitulada "Histórico"; da mesma forma combine quaisquer seções entituladas "Agradecimentos", ou "Dedicatórias". Você precisa apagar todas as seções entituladas como "Endosso". COLETÂNEAS DE DOCUMENTOS Você pode fazer uma coletânea consitindo do Documento e outros documentos publicados sob esta Licença, e substituir as cópias individuais desta Licença nos vários documentos com uma única cópia incluida na coletânea, desde que você siga as regras desta Licença para cópia exata de cada um dos Documentos em todos os outros aspectos. Você pode extrair um único documento de tal coletânea, e distribuí-lo individualmente sob esta Licença, desde que você insira uma cópia desta Licença no documento extraído, e siga esta Licença em todos os outros aspectos relacionados à cópia exata daquele documento. AGREGAÇÃO COM TRABALHOS INDEPENDENTES Uma compilação do Documento ou derivados dele com outros trabalhos ou documentos se- parados e independentes, em um volume ou mídia de distribuição, não conta como uma Ver- são Modificada do Documento, desde que nenhum copyright de compilação seja reclamado pela compilação. Tal compilação é chamada um "agregado", e esta Licença não se aplica aos outros trabalhos auto-contidos compilados junto com o Documento, só por conta de terem sido assim compilados, e eles não são trabalhos derivados do Documento. Se o requerido para o Texto de Capa na seção 3 for aplicável a essas cópias do Documento, então, se o Documento constituir menos de um quarto de todo o agregado, os Textos de Capa do Documento podem ser colocados em capas adjacentes ao Documento dentro do agregado. Senão eles precisarão aparecer nas capas de todo o agregado. TRADUÇÃO Tradução é considerada como um tipo de modificação, então você pode distribuir traduções do Documento sob os termos da seção 4. A substituição de Seções Invariantes por traduções requer uma permissão especial dos detentores do copyright das mesmas, mas você pode incluir traduções de algumas ou de todas as Seções Invariantes em adição às versões orignais dessas Seções Invariantes. Você pode incluir uma tradução desta Licença desde que você também in- clua a versão original em Inglês desta Licença. No caso de discordância entre a tradução e a 16
- 18. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF versão original em Inglês desta Licença, a versão original em Inglês prevalecerá. TÉRMINO Você não pode copiar, modificar, sublicenciar, ou distribuir o Documento exceto como expres- samente especificado sob esta Licença. Qualquer outra tentativa de copiar, modificar, sublicen- ciar, ou distribuir o Documento é nula, e resultará automaticamente no término de seus direitos sob esta Licença. Entretanto, terceiros que tenham recebido cópias, ou direitos de você sob esta Licença não terão suas licenças terminadas, tanto quanto esses terceiros permaneçam em total acordo com esta Licença. REVISÕES FUTURAS DESTA LICENÇA A Free Software Foundation pode publicar novas versões revisadas da Licença de Documen- tação Livre GNU de tempos em tempos. Tais novas versões serão similares em espirito à versão presente, mas podem diferir em detalhes ao abordarem novos porblemas e preocupações. Veja http://www.gnu.org/copyleft/. A cada versão da Licença é dado um número de versão distinto. Se o Documento especificar que uma versão particular desta Licença "ou qualquer versão posterior"se aplica ao mesmo, você tem a opção de seguir os termos e condições daquela versão específica, ou de qualquer versão posterior que tenha sido publicada (não como rascunho) pela Free Software Foundation. Se o Documento não especificar um número de Versão desta Licença, você pode escolher qualquer versão já publicada (não como rascunho) pela Free Software Foundation. ADENDO: Como usar esta Licença para seus documentos Para usar esta Licença num documento que você escreveu, inclua uma cópia desta Licença no documento e ponha as seguintes notas de copyright e licenças logo após a página de título: Copyright (c) ANO SEU NOME. É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior publicada pela Free Soft- ware Foundation; com as Seções Invariantes sendo LISTE SEUS TÍTULOS, com os Textos da Capa da Frente sendo LISTE, e com os Textos da Quarta-Capa sendo LISTE. Uma cópia da li- cença está inclusa na seção entitulada "Licença de Documentação Livre GNU". Se você não tiver nenhuma Seção Invariante, escreva "sem Seções Invariantes"ao invés de dizer quais são invariantes. Se você não tiver Textos de Capa da Frente, escreva "sem Textos de Capa da Frente"ao invés de "com os Textos de Capa da Frente sendo LISTE"; o mesmo para os Textos da Quarta Capa. Se o seu documento contiver exemplos não triviais de código de programas, nós recomenda- mos a publicação desses exemplos em paralelo sob a sua escolha de licença de software livre, 17
- 19. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF tal como a GNU General Public License, para permitir o seu uso em software livre. 18
- 20.
- 21. Capítulo 1 Introdução 1.1 InformaçõesBásicas 1.1.1 Sobre o curso O Perl é uma linguagem de programação dinâmica criada por Larry Wall e primeiramente lançada em 1987. A linguagem pega emprestada características de diversas liguagens, incluidas C, shell script (sh), AWK, sed e Lisp. O Perl é uma liguagem de programação originalmente desenvolvida para manipulação de texto e hoje é usada com os mais diversos propósitos, desde administração e sistemas, desen- volvimento para web, programação para redes, desenvolvimento de GUIs, e mais. A linguagem tem o propósito de ser prática, ou seja, fácil, eficiente e completa, ao invés de bela. Suas mais notáveis características são o suporte a múltiplos paradigmas de programação (procedural, orientado-a-objetos e funcional), gerenciamento automático de memória, suporte built-in a processamento de texto e uma vasta coleção de módulos de terceira mão. Texto retirado e traduzido da wikipedia SOBRE A IMAGEM: Licença (traduzida por mim): Licenciamos a imagem do camelo de forma geral para os pro- dutos de código aberto e para sites não-comerciais, sendo, para tanto, somente necessário um reconhecimento da sua marca e um link para http://www.perl.com License (original): We will license the camel image widely for open source products and non-commercial sites, requiring only an acknowledgement of its trademark status and a link to http://www.perl.com. SOBRE O CURSO: Este curso inteiro é uma tradução adaptada quase total do livro Learning Perl the Hard Way, de Allen B. Downey, disponível em http://www.greenteapress.com/perl/, licenciado pela GNU Free Documentation License. 1.1.2 Plano de ensino Objetivo Qualificar programadores na linguagem de programação Perl. 20
- 22. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Público Alvo Programadores já habituados a programação estruturada, familiarizados com conceitos como controle de fluxo e funções, e que desejem trabalhar rapidamente e de forma prática com Perl. Pré-requisitos Os usuários deverão já estar habituados com programação estruturada em alguma outra lin- guagem de programação. Eles devem estar à vontade com as formas de controle de fluxo e com conceitos básicos como rotinas, variáveis e expressões. Alternativamente, uma pessoa pode tentar acompanhar o curso ao mesmo tempo que procura por fora embasamento em lógica de programação. Descrição O curso de Perl do CDTC é, por inteiro, uma tradução adaptada quase completa do livro Learning Perl the Hard Way disponível em http://www.greenteapress.com/perl/, licenciado em pela GNU Free Documentation License. Sua abordagem é rápida e direta, não passando pelas definições fundamentais à lógica de programação, mas trabalhando as idiossincrasias do Perl para aquelas pessoas que com ele resolveram aventurar-se. O curso dura 2 semanas e é dividido em 10 lições. Cada uma pode ser lida e absorvida em aproximadamente 1 hora. Metodologia O curso está dividido da seguinte maneira: Cronograma • Descrição das atividades • Semana 1: • Lição 1 - Básico 1 (variáveis, subrotinas, pragmas); • Lição 2 - Básico 2 (arrays, listas, contexto); • Lição 3 - Arquivos ; • Lição 4 - Expressões regulares 1; • Lição 5 - Expressões regulares 2; • Avaliação de aprendizagem. • Semana 2: • Lição 6 - Hashes 1; • Lição 7 - Hashes 2; • Lição 8 - Objetos 1; 21
- 23. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • Lição 9 - Objetos 2; • Lição 10 - Callbacks e Pipes; • Avaliação de aprendizagem. Avaliação Toda a avaliação será feita on-line. Tanto o resultado das lições quanto o resultado do ques- tionário final serão relevantes para a média final, que por sua vez nos habilita ou não a liberar a certificação. Para a aprovação o participante deverá obter nota maior ou igual a 6,0 na média final. Bibliografia Learning Perl the Hard Way, disponível em http://www.greenteapress.com/perl/ 22
- 24. Capítulo 2 Lição 1- Básico 1 (variáveis, subrotinas, pragmas) 2.1 Introdução Esta lição apresenta dois dos tipos built-in, arrays e valores escalares. Um valor escalar é um valor que o Perl trata como uma unidade, como um único número ou uma única palavra. Um array é uma coleção ordenada (uma seqüência) de elementos cujos valores são escalares. 2.2 Echo O utilitário Linux ’echo’ pega um número de argumentos de linha de comando e os imprime. Este é um programa em perl que faz praticamente a mesma coisa: print @ARGV; O programa contém uma expressão de impressão. Como todas as expressões, ela termina com um ponto-e-vírgula. Como todas generalizações, a sentença anterior é falsa. Como, no entanto, prezamos por um padrão no código, vamos aqui procurar inserir o ponto-e-vírgula em todas as expressões. O operando do operador print é ’@ARGV’. O símbolo ’arroba’ indica que ’@ARGV’ é um array variável; na verdade, é uma variável built-in que se refere a um array de strings que contém quaisquer argumentos de linha de comando dados no momento da execução do programa. Existem diversas maneiras de se executar um programa Perl, mas a mais comum é colocar uma linha "shebang"no início do código. Ela diz ao Shell onde encontrar o programa chamado perl que compila e executa programas Perl. Execute whereis para saber onde o perl se encontra em seu sistema. Assumimos aqui que está em /usr/bin, logo inserimos a seguinte linha no início do arquivo: #!/usr/bin/perl print @ARGV; Arquivos que contêm programas em Perl devem possuir, por convenção, a extensão .pl. Gravemos, portanto, este nosso script como echo.pl. 23
- 25. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Para executar um arquivo precisamos, naturalmente, ter permissão para executá-lo. Como, por padrão, os arquivos no Linux não são executáveis, precisamos antes de mais nada alterar suas per- missões. Para tornar nosso arquivo executável, digite os seguintes comandos no terminal: $ chmod u+x echo.pl Enfim, para executar nosso programa: $ ./echo.pl Experimente agora passar argumentos para o nosso script: $ ./echo.pl argumento1 argumento2 argumento1argumento2$ Como previsto, nosso script imprime os argumentos dados pela linha de comando, apesar de, não haver espaços entre as palavras nem quebra de linha (newline), razão pela qual aparece o cifrão do Shell ainda na linha da saída do programa. Podemos resolver ambos problemas usando o operador aspas-duplas e o indicador de quebra de linha como mostrado a seguir: #!/usr/bin/perl print "@ARGVn"; Pode ser tentador pensar que o argumento aqui é uma string, mas é mais acurado se dizer que ele é uma expressão que, quando avaliada, entrega uma string. Quando o Perl avalia uma expressão em aspas-duplas, ele realiza interpolação de variável e interpolação de contra-barra: Interpolação de variável: quando o nome de uma variável aparece em aspas-duplas, ela é substituída pelo seu valor; Interpolação de contra-barra: quando uma seqüência inciado com contra-barra aparece em aspas-duplas, ela é substituída pelo caractere especificado pela seqüência. Neste caso, a seqüência n é substituída por um único caractere de quebra de linha (newline). Agora quando rodamos o programa, ele imprime os argumentos como eles aparecem na linha de comando: $ ./echo.pl argumento1 argumento2 argumento1 argumento2 $ Sabemos o motivo pelo qual o cifrão do Shell aparece em uma nova linha: porque inserimos o caractere newline. Mas por que o Perl insere os espaços entre as palavras agora? A razão é: A forma como uma variável é interpretada depende do contexto! Neste caso, a variável aparece em aspas-duplas, então é avaliada em contexto de interpo- lação. É uma variável de array e no contexto de interpolação, logo os elementos do array são unidos utilizando o separador especificado pela variável built-in nomeada de $". Seu valor padrão é um espaço. 2.3 Erros O que pode ter saído errado? Três coisas: Erro de compilação: o Perl compila o programa inteiro antes de começar a execução. Se houver um erro de sintaxe em algum lugar do programa, o compilador imprimirá uma mensagem 24
- 26. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF de erro e parará sem tentar rodar o programa. Erro de execução: se o programa compilar com sucesso, ele começará a executar o programa, mas se qualquer coisa der errado durante a execução, o sistema de execução run-time system imprimirá uma mensagem e parará o programa. Erro semântica: em alguns casos, o programa é compilado e executado sem quaisquer erros, mas não realiza aquilo a que se destinava. É claro, só o programador sabe à que que ele se destina, então erros semânticos são de nossa exclusiva responsabilidade. Para ver uma mensagem de erro de compilação, experimente escrever ’print’ errado. Quando tentar rodar o programa, deve-se receber um aviso do compilador como este: String found where operator expected at ./echo.pl line 2, near "prnt "@ARGVn (Do you need to predeclare prnt?) syntax error at ./echo.pl line 2, near "prnt "@ARGVn Execution of ./echo.pl aborted due to compilation errors. Esta mensagem traz muitas informações, mas algumas são difíceis de se interpretar, espe- cialmente quando não estamos familiarizados com o Perl. Como estamos experimentando com uma linguagem nova, sugerimos que você cometa erros deliberadamente para que se habitue com as mensagens de erros mais comuns. Como segundo exemplo, tente errar o nome de uma variável (em nosso programa, a ’@ARGV’). O nosso programa não mais captura os argumentos passados, como pretendíamos. Como não há variável @ARG, @ARV ou @RGV, o Perl dá a ela o valor padrão (como se a estivéssemos declarando), que é uma lista ( @ ) vazia. De fato, o Perl ignora o que é quase que com certeza um erro e tenta rodar o programa ainda assim. Este comportamento é eventualmente útil, mas nor- malmente gostaríamos que o compilador nos ajudasse a encontrar erros. Nós podemos utilizar o pragma strict para mudar o comportamento do compilador. Um pragma é um módulo que controla o comportamento do Perl. Para utilizar o strict , adicione a seguinte linha ao programa: use strict; Agora se alterarmos o nome da variável vamos ver, ao executar o programa, algo como: Global symbol @ARG requires explicit package name. Como muitas mensagem de compiladores, esta também pode nos confundir, mas contém dicas sobre onde o problema pode estar. 2.4 Subrotinas Se você escreveu programas maiores que cem linhas, não preciso lhe dizer como é importante organizar programas em subrotinas. Por alguma razão, alguns programadores Perl, no entanto, parecem ser alérgicos a elas. Bom, diferentes autores recomendam diferentes estilos, mas de forma geral é adequado uti- lizar muitas subrotinas. Uma maneira de organizá-las pode ser nomear uma subrotina com o mesmo nome que o programa e iniciá-lo chamando. sub echo { print "@_n"; } 25
- 27. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF echo @ARGV Este programa faz a mesma coisa que fazia o anterior (echo.pl), só é mais elaborado. Toda declaração de uma subrotina começa com sub seguido do nome da subrotina e seu corpo. O corpo da subrotina é um bloco de expressões fechadas em chaves. Em nosso exemplo acima, o bloco contém uma única expressão. A variável @_ é uma variável buit-in que se refere ao array de valores que foi recebido como parâmetro pela subrotina. 2.5 Variáveis locais A palavra-chave my cria uma variável local. A subrotina a seguir cria uma variável local cha- mada ’params’ e atribue a ela uma cópia dos parâmetros. sub echo { my @params = @_; print "@paramsn"; echo "@ARGVn"; Se deixarmos de lado a palavra my, o Perl assume que estamos criando uma variável global. Se estivermos utilizando o pragma strict, o Perl vai reclamar. Experimente para ver como se parece a mensagem de erro. 26
- 28. Capítulo 3 Lição 2- Básico 2 (arrays, listas, contexto) 3.1 Elementos de um array Para acessar os elementos de um array, utilize o operador colchete: print "$params[0] $params[2]n"; Os números entre colchetes são índices. Essa expressão imprime os elementos de @params com os índices 0 e 2. O cifrão de dólar indica que os elementos desse array são valores escalares. Com sabemos, um valor escalar é aquele que é tratado como uma unidade sem partes, em contraposição ao valor de arrays, que são compostos de elementos. Existem três tipos de valores escalares: números, strings e referências. Em nosso exemplo, os elementos do array são strings. Para armazenar um valor escalar temos de usar uma variável escalar: my $word = $params[0]; print "$wordn"; O cifrão de dólar no início de $word indica que esta é uma variável escalar. Como o nome do array é @params, é tentador escrever a linha acima como: # exemplo de linha incorreta: my $word = @params[0]; Ou seja, designando o elemento de índice 0 do array parâmetro como se fosse um array ( @ ). A variável @params é um array, e por isso o arroba, mas seus elementos são escalares. O correto é nos referir ao elemento como $params[0]; A primeira linha do exemplo incorreto acima é um comentário. Comentários começam com o caractere hash ( # ) e terminam ao nal da linha, como em bash script. O Perl tentaria executar esse erro se ele estivesse presente. Existe, no entanto, um pragma, o warnings que altera o comportamento do Perl para que ele cheque a presença desse tipo de erro. Adicione a seguinte linha ao seu código: 27
- 29. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF use warnings; Se executássemos o programa com a linha errada o Perl agora avisaria: Scalar value @params[0] better written as $params[0]. Enquanto aprendendo Perl, é bom que se utilize os pragmas strict e warnings para que ajudem a encontrar erros. Mais tarde, ao trabalhar com programas maiores, ainda é bom utilizá- los para garantir uma boa prática de programação. Em outras palavras, é sempre bom utilizá-los. Podemos ter, de uma vez só, mais de um elemento de um array colocando uma lista dos índices entre os colchetes. O seguinte programa cria uma varíavel de array chamada @words e a designa um novo array que contém os elementos (de índice) 0 e 2 de @params. my @words = @params[0, 2]; print @wordsn; O novo array é dito um slice. 3.2 Contexto escalar e de lista Até então, nós vimos dois tipos built-in do Perl, os arrays e os valores escalares. Variáveis de array começam com ’ @ ’ e variáveis escalares, com ’ $ ’. De fato, em muitos casos, expressões com arrays que começam com @ e com escalares que começam com $ são facilmente vistas. Mas nem sempre. Lembre-se: a forma como uma expressão é avaliada depende de seu contexto! Em uma expressão de atribuição, a parte da esquerda determina o contexto. Se a parte da esquerda for uma variável escalar, a parte da direita será avaliada em contexto escalar. Se a parte da esquerda for um array, então a parte da direita será avaliada em contexto de lista. Se um array for avaliado em contexto escalar, ele terá o número de elementos do array. O seguinte programa imprime o número de parâmetros. Deixarei para você ver o que acontece se se avaliar um escalar em contexto de lista. my $word = @params; print $wordn; 3.3 Listas literais Uma forma de atribuir um valor a uma varíavel de array é utilizar uma lista literal. Uma lista literal é uma expressão que carrega o valor de uma lista. Eis o exemplo típico de uma lista padrão: my @list = (1, 2, 3); print @listn; Na maior parte do tempo, podemos pensar que listas e arrays são a mesma coisa. Existem diferenças, mas, por hora a única com que vamos nos deparar é a seguinte: quando avaliamos 28
- 30. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF uma lista em contexto escalar, ficamos com o último elemento da lista. O programa a seguir imprime ’ 3 ’: my $scalar = (1, 2, 3); print $scalarn; Quando, porém, atribuímos uma lista a uma variável de array, o resultado é um valor de array. Então o seguinte programa imprime o tamanho da lista, que é 3: my @list = (1, 2, 3); my $scalar = @list; print $scalarn; A diferença é sutil. 3.4 Atribuição em lista Quando uma lista de variáveis aparece na parte esquerda de uma atribuição, o Perl realiza uma atribuição em lista. A parte da direita é avaliada em contexto de lista e então o primeiro elemento do resultado é atribuído à primeira variável, o segundo elemento à segunda variável e assim por diante. Um uso comum deste funcionamento é atribuir valores de uma lista de parâmetros a variáveis locais: sub echo { my ($p1, $p2, @params) = @_; print $p1 $p2 @paramsn; } O argumento de print é uma expressão entre aspas duplas que utiliza interpolação de variá- veis para apresentar os valores dos parâmetros. Este tipo de expressão print é útil para debugar. Sempre que houver um erro em uma subrotina, pode ser bom começar a análise imprimindo os valores dos parâmetros. 3.5 Operador Shift Outra forma de se fazer a mesma coisa (porque em Perl sempre há outra forma de se fazer a mesma coisa) é utilizar o operador shift. O shift pega um array com um argumento e faz duas coisas: remove o primeiro elemento da lista e retorna o valor removido. Como muitos operadores, o shift tem tanto um efeito colateral (modificar o array) e um valor de retorno (o resultado da operação). A seguinte subrotina é a mesma que a anterior: sub echo { my $p1 = shift @_; my $p2 = shift @_; print $p1 $p2 @_n; } 29
- 31. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Se chamamos o shift sem um argumento, ele utiliza o @_ por padrão. Neste exemplo é possível (e comum) omitir o argumento. 30
- 32. Capítulo 4 Lição 3- Arquivos 4.1 Manipuladores de arquivo Para ler o conteúdo de um arquivo, você deve usar o operador open para ter um manipulador de arquivo, e então utilizar o manipulador para ler linhas. O operando de open é uma lista de dois termos: um nome arbitrário para o manipulador de arquivo e o nome do arquivo que queremos abrir. Digamos que o arquivo que queiramos abrir é /usr/share/dict/words. Veja a seguir: open FILE, /usr/share/dict/words; Neste caso, o identificador FILE é global. Uma alternativa é criar uma variável local que contém um manipulador indireto de arquivo: open my $fh, /usr/share/dict/words; Por convenção, o nome de uma variável global é todo em letras maiúsculas e o nome de uma variável local todo em letras minúsculas. Em ambos os casos, podemos utilizar o operador angle ( ), que tem a função readline como fundo, para ler uma linha do arquivo: my $first = FILE; my $first = $fh; Para ser mais exato, eu deveria dizer que em um contexto escalar, o operador angle lê uma linha. O que será que ele faz em um contexto de lista? Quando chegamos ao fim do arquivo, o operador angle retorna undef, que é um valor especial que o Perl usa para variáveis não definidas e para condições como o término de um arquivo. Dentro de um loop de while, undef é considerado um valor de verdade falso, então é comum utilizar o operador angle em loops como o seguinte: while (my $line = FILE) { print $line; } 4.2 Cat O utilitário Linux ’cat’ pega uma lista de nomes de arquivos como argumentos de linha de co- mando e imprime o conteúdo dos arquivos. Aqui está um programa em Perl que faz basicamente a mesma coisa: 31
- 33. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF use strict; use warnings; sub print_file { my $file = shift; open FILE, $file; while (my $line = FILE) { print $line; } } sub cat { while (my $file = shift) { print_file $file; } } cat @ARGV; Há duas subrotinas aqui, ’print_file’ e ’cat’. A última linha do programa invoca ’cat’, passando os argumentos de linha de comando como parâmetros. O ’cat’ usa o operador shift dentro de uma expressão ’while’ para iterar pela lista de nomes de arquivos. Quando a lista está vazia, o shift retorna undef e o loop termina. Cada vez feito o loop, o ’cat’ chama ’print_file’, que abre o arquivo e então usa um loop de ’while’ para imprimir os conteúdos. Note que o ’cat’ e o ’print_file’ ambos têm variáveis locais chamadas $file. Naturalmente, não há conflito entre variáveis locais em diferentes subrotinas. A declaração de uma subrotina tem de aparecer antes de ser chamada. Após digitar esse programa acima, tente rearranjar a ordem das subrotinas e ver que mensa- gens de erro vão sair. 4.3 Foreach e @_ Na página anterior, utilizamos o operador shift e um loop de ’while’ para iterar pela lista de parâmetros. Uma maneira mais comum de fazer a mesma coisa é utilizar uma expressão foreach. # o loop de 'cat', do programa anterior foreach my $file (@_) { print_file $file; } Quando uma expressão foreach é executada, a expressão entre parênteses é avaliada uma vez e em contexto de lista. Então o valor do primeiro elemento da lista é atribuído à variável nomeada (no caso, ’$file’) e o corpo do loop é executado. O corpo do loop é executado uma vez para cada elemento da lista, em ordem. Se não dermos uma variável de loop, o Perl usa $_ por padrão. Então poderíamos escrever o mesmo loop como: # o loop de ’cat’ foreach (@_) { print_file $_; 32
- 34. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF } Quando o operador angle aparece em um loop de ’while’, ele também usa $_ como variável de loop padrão, então poderíamos escrever o loop de ’print_file’ como: # o loop de print_file while (FILE) { print $_; } Usar a variável de loop padrão tem uma desvantagem e uma desvantagem. A vantagem é que muitos operadores built-in usam o $_ como parâmetro padrão, então podemos deixá-lo de fora: # o loop de print_file while (FILE) { print; } A desvantagem é que o $_ é global, então alterá-lo em uma subrotina afeta outras partes do programa. Por exemplo, tente imprimir o valor de $_ em ’cat’, desta forma: # o loop de ’cat’ foreach (@_) { print_file $_; print $_; } Após a execução de ’print_file’ o valor de $_ é undef porque esta é a condição de término do loop em ’print_file’. Nesse exemplo, é provavelmente melhor utilizar variáveis de loop locais e explícitas. Por quê? Porque o nome da variável contém também uma documentação útil. Em ’cat’ é claro que não estamos iterando sobre uma lista de arquivos, e em ’print_file’ é claro que estamos iterando sobre linhas de um arquivo. Usar a variável de loop padrão é conciso, mas obscurece a função do programa. 33
- 35. Capítulo 5 Lição 4- Expressões regulares 1 5.1 Casando padrões O operador que conecta padrões [= ] compara uma string na esquerda com um padrão na direita. Ao comparar ele retorna verdadeiro se a string bate com o padrão. Por exemplo, se o padrão é uma seqüência de caracteres, a string casa se contiver essa seqüência. if ($line = abc) { print $line; } Em um dicionário de inglês, a única palavra encontrada foi Babcok. Mais freqüentemente, o padrão da direita é um padrão que casa, que parece algo assim: m/abc/. O padrão entre barras pode ser qualquer expressão regular, o que significa que além de caracteres simples, ele pode conter também metacaracteres com significados especiais. Um metacaractere comum é o ponto ( . ) , que é um coringa que pode casar com qualquer caractere. Por exemplo, a expressão regular ’pa..u.e’ casa com quaisquer strings que contenham os ca- racteres ’pa’ , seguido exatamente de dois caracteres, depois ’u’, depois exatamente um caractere e por fim a letra ’e’. No dicionário de inglês quatro palavras bateram: departure, departures, pasturee pastures. A seguinte subrotina pega dois parâmetros, um padrão e um arquivo. Ela lê cada linha do arquivo e imprime aquela que casa com o padrão. Este tipo de coisa é muito útil para trapacear palavras cruzadas! sub grep_file { my $padrao = shift; my $arquivo = shift; open ARQUIVO, $arquivo; while (my $linha = ARQUIVO) { if ($linha = m/$padrao/) {print $linha } } } Chamei esta subrotina de ’grep_file’ tendo em mente o utilitário Linux grep, que faz quase que a mesma coisa. Note que a última expressão de um bloco não precisa de ponto-e-vírgula. 34
- 36. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 5.2 Âncoras Apesar do programa anterior ser útil para trapacear em palavras cruzadas, podemos fazê-lo melhor com âncoras. Âncoras nos permitem especificar onde na linha o padrão deve aparecer. Podemos encurtar a busca utilizando o metacaractere ˆ, que indica que o padrão deve estar no início da linha. Ou melhor, o início do padrão deve bater com o início da linha. Analogamente, o caractere $ indica que o padrão deve estar ao final da linha. Ou melhor, o final do padrão deve casar com o final da linha. Colocar um padrão qualquer entre os dois metacaracteres como em ˆpadrão$, portanto, garante que o padrão deve coincidir com toda a linha. 5.3 Quantificadores Um quanticador é parte de uma expressão regular que controla quantas vezes uma dada seqüên- cia deve aparecer. Por exemplo, o quantificador {2} diz que o padrão deve aparecer duas vezes. Seu uso é, porém, um pouco truculento por se aplicar a uma parte do padrão chamada ’átomo’. Todo caractere simples, por ele mesmo, em um padrão, é um átomo. Da mesma forma, uma seqüência de caracteres entre parênteses também é um átomo. Ou seja, para tratar um conjunto de mais de um caractere juntos como um único átomo, temos de colocá-los entre parênteses. Os termos ’a+’ e ’a*’ quase representam o mesmo conjunto. A diferença é que ’a*’ também contém a string vazia. Então o padrão ab{2} casa qualquer palavra com um ’a’ seguido de dois ’b’s, mas o padrão (ba){2} só casaria com uma palavra que contivessa a seqüência ’ba’ repetida duas vezes, como em ’babado’. O padrão (.es.){3} casa com qualquer palavra em que o padrão [caractere qualquer] es [caractere qualquer]apareça três vezes. Em inglês há a palavra restlessness, por exemplo, que satisfaz o padrão. O quantificador ’?’ especifica que um átomo é opcional; ou seja, que ele pode aparecer 0 ou uma 1 vez. Então o padrão (in)?comum casa tanto com comumquanto com incomum. Similarmente, o quantificador ’+’ indica que um átomo pode aparecer uma ou mais vezes e o quantificador ’*’ indica que um átomo pode aparecer 0 ou mais vezes. Até então, falamos sobre expressões regulares em termos de casamento de padrões. Mas há outra forma de pensarmos sobre elas: uma expressão regular é uma forma de denotar um conjuntos de strings. No exemplo mais simples, a expressão regular ’abc’ representa o conjunto que contém uma string ’abc’. Com quantificadores, os conjuntos são mais interessantes. Por exemplo, a expressão regular ’a+’ representa o conjunto que contém a, aa, aaa, aaaa, e daí por diante. É um conjunto infinito, então é conveniente que possamos representá-lo de forma tão sucinta. 5.4 Alternância O metacaractere ’ | ’ é como uma conjunção ’ou’; ele indica que ’ou um átomo ou o outro’. Então a expressão regular a|b|c representa os conjuntos que contêm cada um um dos carateres e suas combinações. O termo ˆ(des|in) casa com qualquer palavra que inicia com ’des’ ou com ’in’. Existe uma forma mais simples, no entanto, de designar um conjunto (de conjuntos) longo de 35
- 37. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF caracteres alternativos do que com um termo como a|b|c|d|e. Podemos representar este conjunto maior usando os colchetes assim: [abcde]. O metacaractere colchete define uma classe de caracteres, que casa com palavras que con- tenham quaisquer caracteres incluídos na classe. Então o termo ˆ[abcde] casa com qualquer palavra que inicie com qualquer um dos caracteres listados, e o termo ˆ[abcde]+$ casa com qual- quer palavra que só contenha estes caracteres, ainda que não necessariamente eles todos, do início ao fim. Entre colchetes, o metacaractere ’hífen’, ’ - ’, especifica um escopo de caracteres, então [1-5] é o mesmo que [12345] e o termo [0-9A-Da-z] é o mesmo que [0123456789ABCDabcdefghij- klmnopqrstuvxwyz]. Inclusive, o metacaractere ’ ˆ’, que do lado de fora indica o início de uma palavra, dentro dos colchetes serve para negar a classe de caracteres. Ou seja, o termo [ˆ0-9] casa com qualquer palavra que não é um dígito (ou, ao menos, que não contém um). ˆ[ˆ-], repare, casa com qualquer coisa que não inicie com um hífen - ou seja, o hífen perde o caráter especial se iniciar a seqüência da classe de caracteres e passa a representar ele mesmo, um hífen. Diversas classes de caracteres são predenidas e podem ser especicadas com termos com contra- barra como d, que representa qualquer dígito, equivalentemente a [0-9]. Semelhantemente, s casa com qualquer caractere de espaço em branco (espaço, tab, linha nova, return, form feed), e w casa com os chamados ’caracteres de palavras’ (letras maiúsculas e minúsculas, dígitos e ’ _ ’). 5.5 Captura de sequências Em uma expressão regular, os parênteses têm duas funções. Como já vimos, eles agrupam uma seqüência de caracteres em um átomo para que, por exemplo, um quantificador possa ser aplicado a uma seqüência e não a uma única letra. Além disso, eles indicam uma parte da string que casa que deveria ser capturada; ou seja, armazenada para uso posterior. Por exemplo, o padrão http: (.*) casa com qualquer URL que comece com ’http:’, mas também salva o resto da URL na variável chamada ’$1’. O seguinte fragmento checa uma linha pela presença de uma URL e então imprime tudo que aparece após http:. my $pattern = http: (.*); if ($line = m/$pattern/) { print $1n} Se estamos também interessados um URLs que usem ftp, podemos escrever algo como: my pattern = (ftp|http): (.*); if ($line = m/$pattern/) { print $1, $2n;} Já que há duas seqüências em parênteses, o casamento cria duas variáveis, $1 e $2. Essas variáveis são chamadas backreferences, e as strings às quais elas se referem são as captured strings, ou seqüências capturadas. Seqüências capturadas podem ser aninhados. Por exemplo, a expressão regular ((ftp|http): (.*)) cria três variáveis: $1 corresponde à seqüência capturada mais externa, que carrega string casada inteira; $2 e $3 correspondem às duas seqüências aninhadas. 36
- 38. Capítulo 6 Lição 5- Expressões regulares 2 6.1 Casamento mínimo Se extendermos o exemplo anterior, encontraremos uma propriedade de expressões regula- res que é freqüentemente problemática: os quantificadores são gulosos. Vamos dizer que quei- ramos analisar uma URL como ’http://www.gnu.org/philosophy/free-sw.html’ e separar o nome da máquina (www.gnu.org) do nome do arquivo (philosophy/free-sw.html). Podemos tentar algo como: my $pattern = (ftp|http)://(.*)/(.*); if ($line = m/$pattern/) { print $1, $2, $3n} Mas o resultado seria este: http, www.gnu.org/philosophy, free-sw.html O primeiro quantificador (.*) realizou um casamento máximo, pegando não só o nome da máquina, mas também a primeira parte do nome do arquivo. O que queremos é um casamento mínimo, que pararia no primeira barra. Podemos mudar o comportamento dos quantificadores adicionando um sinal de interrogação. O padrão (ftp|http)://(.*?)/(.*) faz o que queremos. Os quantificadores *?, +? e ?? são os mesmos que *, + e ?, exceto pelo fato de que realizam casamento mínimo. 6.2 Padrões extendidos Assim que expressões regulares ficam maiores, elas se tornam mais difíceis de se ler e de se debugar. Nos exemplos anteriores tentamos tornar os padrões mais simples designando um padrão a uma variável e depois usando a variável dentro do operador match m//. Esta idéia, no entanto, não nos pode levar mais adiante. Uma alternativa é utilizar o formato de padrões extendidos, que é parecido com isto: if ($line = m{ (ftp|http):// # protocolo (.*?) # nome da máquina (mínimo) /(.*) # nome do arquivo }x ) 37
- 39. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF { print $1, $2, $3n} O padrão começa com m{ e termina com }x. O ’ x ’ indica o formato extendido; é um dos diversos modificadores que podem aparecer ao final de uma expressão regular. O restante da expressão é normal, exceto o arranjo de expressões e pontuações, que é diferente. As capaci- dades mais importantes do formato extendido são o uso de espaços em branco e comentários, ambos os quais tornam a leitura da expressão mais fácil. 6.3 Alguns operadores O Perl provê um conjunto de operadores que podem ser melhor descritos como um supercon- junto de operadores C. Os operadores matemáticos +, -, * e / têm seus sentidos usuais, e % é o operador de módulo. Além disso, ** realiza exponenciação. Os operadores de comparação , , ==, =, = e != realizam comparações numéricas, mas os operadores gt, lt, eq, ge, le e ne realizam comparações entre strings. Em ambos os casos, o Perl converte os operandos aos tipos apropriados automaticamente. Então expressões como 10 lt 2 realiza comparações de strings mesmo sendo ambos operandos números, e o resultado é verdadeiro. = é chamado de operador spaceship. Seu valor é 1 se o operando da esquerda é numeri- camente maior, e -1 se o maior é o da direita e 0 se os operandos são iguais. Existem dois conjuntos de operadores lógicos: ’ ’ é o mesmo que o econjuntivo e ’ || ’ é o mesmo que o ou. Na verdade, existe uma diferença. Os operadores textuais tem menos precedência que os operadores simbólicos correspondente. 6.4 Operadores pré-fixados Já utilizamos diversos operadores pré-fixados, incluindo print, shift e open. Estes operadores são seguidos por uma lista de operandos, normalmente separados por vírgulas. Os operandos são avaliados em contexto de lista, e depois achatadosem uma lista única. Há uma sintaxe alternativa para um operador prefixado que o faz se comportar como uma chamada de função C. Por exemplo, os seguintes pares de expressões são equivalentes: print $1, $2; print($1, $2); shift @_; shfit(@_); open FILE, $file; open(FILE, $file); Em certo sentido, os parênteses são opcionais, mas tem mais que isso, porque as duas sintaxes têm diferentes precedências. Normalmente isso não importaria muito, exceto porque há um idioma comum de tratamento de erros. Vamos ver do que estou falando: open FILE, $file or die Não foi possível abrir $filen; O operador die imprime seu operando e termina o programa. O operador or realiza uma avaliação curta de circuito, short circuit evaluation, que significa que ele só avalia o estritamente necessário, lendo da direita para a esquerda. Como or e || são equivalentes, podemos assumir que seria igualmente correto escrever: open FILE, $file || die Não foi possível abrir $filen; 38
- 40. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Infelizmente, porque o || tem maior precedência que o or essa expressão computa $file || die Não foi possível abrir $filen primeiro, que carrega o valor de $file, então o die nunca é executado, mesmo que o arquivo não exista. Uma forma de evitar esse problema é usar o or. Outra forma é usar a função call syntax para open. O que segue funciona porque a função call syntax é avaliada na ordem que esperamos. open(FILE, $file) || die Não foi possível abrir $filen; Gostaria de comentar que existem duas variáveis especiais que podem gerar mais mensagens de erro úteis. die $0: Não foi possível abrir $file: $!n; Em Perl (e em bash script), a variável $0 contém o nome do programa que está rodando e $! contém uma descrição textual da mensagem de erro mais recente. Esse idioma é tão comum que é uma boa idéia encapsulá-lo em uma subrotina: sub croak { die $0: @_: $!n} (Pegamos o nome croak emprestado de Programming Perl, de Wall, Christiansen e Orwant.) 6.5 A semântica das subrotinas Anteriormente vimos que o nome especial @_ em uma subrotina se refere à lista de parâme- tros. Ou melhor ainda, os elementos da lista de parâmetros são apelidos, aliases, para os valores escalares providos como argumentos. Um alias é uma forma alternativa de se referir a uma variável. Em outras palavras, @_ pode ser usado para acessar e modificar variáveis que são usadas como argumentos. Por exemplo, swap pega dois parâmetros e troca seus valores: sub swap { ($_[0], $_[1]) = ($_[1], $_[0]); } Em uma atribuição em lista, a parte da direita é avaliada antes da realização de qualquer atribuição, então não há necessidade de uma variável temporária para fazer a troca. O seguinte código testa a troca: my $um = 1; my $dois = 2; swap($um, $dois); print $um, $doisn; Como previsto, a saída é 2, 1. Como swap tenta modificar seus parâmetros, é ilegal invocá-lo com valores constantes. A expressão swap(1,2) retorna: Modification of a read-only value attempted in ./swap.pl Por outro lado, podemos chamá-lo com uma lista: 39
- 41. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF my @lista = (1, 2); swap(@lista); print @listan; Quando uma lista aparece como um argumento, ela é achatada; ou seja, os elementos da lista são adicionados à lista de parâmetros. Então o código a seguir não troca duas listas: my @lista1 = (1, 2); my @lista2 = (3, 4); swap(@lista1, @lista2); print @lista1 @lista2n; Ao invés de trocá-las, o swap pega uma lista de quatro valores escalares como parâmetros e troca os dois primeiros. A saída do programa é 2 1 3 4. 40
- 42. Capítulo 7 Lição 6- Hashes 7.1 Operadores de pilha Com a implementação simples de uma pilha, podemos usar os operadores push e pop. O push adiciona um elemento ao fim do array; o pop remove o último elemento. my @lista = (1, 2); push @lista, 3; Neste ponto, @lista contém 1 2 3. my $elt = pop @lista; Agora $elt possui 3 e @lista volta a conter 1 2. Quando estamos usando uma lista como pilha, os nomes push e pop são apropriados. Por exemplo, um uso de pilha é reverter os elementos de uma lista. A seguinte subrotina pega uma lista como parâmetro e retorna uma nova lista com os mesmos elementos em ordem invertida. sub rev { my @pilha; foreach (@_) { push @pilha, $_; } my @lista; while (my $elt = pop @pilha) { push @lista, $elt; } return @lista; } O primeiro loop pega cada elemento da lista de parâmetros e põe com push cada um em uma pilha local. O segundo loop pega cada elemento em ordem de pilha com pop e o coloca em uma nova lista com push. Esta lista (@lista) é, ao fim da rotina, o valor de retorno. 7.2 Operadores de fila Nós já vimos shift, que remove e retorna o primeiro elemento de uma lista. Da mesma forma que pushpop implementam uma pilha, push e shift implementam uma fila. Além do mais, unshift adiciona um novo elemento ao início de um array. shift e unshift são freqüentemente usados para analisar um fluxo de (partes de) strings (stream of tokens). 41
- 43. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 7.3 Hashes Um hash é uma coleção de valores escalares, como um array. A diferença é que os elementos de um array são ordenados e acessados com números chamados índices. Os elementos de um hash são desordenados e acessados utilizando valores escalares chamados keys (chaves). Assim como valores escalares, que são identificados pelo prefixo $, e como os arrays, que são identificados com o prefixo @, os hashes são iniciados com um sinal de porcentagem ( % ). Da mesma forma como o índice de um array aparece em colchetes, a chave (key) de um hash aparece entre chaves. my %hash; $hash{Um} = Número 1; $hash{Dois} = Número 2; $hash{Três} = Número 3; A primeira linha cria um hash local chamado hash. As próximas três linhas designam valores com as chaves ’um’, ’dois’ e ’três’. Mesmo sendo as chaves strings, não precisamos colocá-las entre aspas, pois o Perl já entende chaves de hashes automaticamente como strings. Os hashes são algumas vezes chamados de arrays associativos porque eles criam associa- ções entre chaves e valores. Em nosso exemplo, a chave Dois é associada com a string Número 2. O operador keys retorna uma lista das chaves de um hash. A expressão keys %hash re- torna Dois Um Três. Note que as chaves não estão em qualquer ordem particular; depende de como o hash é implementado, e isso pode mudar se rodarmos o programa outra vez (ainda que provavelmente não). Aqui está um loop que itera uma lista de chaves e que imprime os valores correspondentes: foreach my $key (keys %hash) { print $key = $hash{$key}n; } O resultado deste loop é algo como: Dois = Número 2 Um = Número 1 Três = Número 3 O uso de parênteses no código não é uma coincidência. Os parênteses também podem ser usados para designar um conjunto de pares chave-valor a um hash. %hash = ( Um = Número 1, Dois = Número 2, Três = Número 3, ); Uma outra forma de se percorrer um hash é com o operador each. Cada vez que é chamado, ele retorna o próximo par chave-valor do hash como uma lista de dois elementos. Internamente, o each mantém controle de quais pares já foram listados (já que eles não ficam em nenhuma ordem particular). O seguinte trecho de código é uma forma comum de se percorrer um hash: while ((my $chave, my $valor) = each %hash) { 42
- 44. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF print $chave = $valorn; } Por fim, o operador values retorna uma lista dos valores de um hash. my @valores = values %hash; É claro, podemos percorrer a lista de valores, mas não há forma de, através de um dado valor, capturar sua chave correspondente. Na verdade, pode haver inclusive mais de uma chave associada a um mesmo valor. 7.4 Tabela de freqüência Um uso para um hash é contar quantas vezes uma palavra é utilizada em um documento. Para demonstrar esta aplicação, vamos começar com uma cópia do grep.pl que escrevemos anteriormente. Ele contém uma subrotina que abre um arquivo e percorre suas linhas. Com algumas poucas mudanças, ele fica assim: sub read_file { my $arquivo = shift; open (ARQUIVO, $arquivo) || croak Não pude abrir $arquivo; while (my $line = ARQUIVO) { read_line $line; } } Enquanto read_file pega cada linha do arquivo, ela chama a read_line para processar as linhas. O read_line usa o operador split para quebrar a linha em palavras, depois percorre a lista de palavras. sub read_line { our %hash; my @lista = split , shift; foreach my $palavra (@lista) { $hash{$palavra}++; } } O primeiro parâmetro do split é uma expressão regular que indica onde se deve separar (split) a string. Neste caso, a expressão é trivial; é o caractere de espaço em branco. A primeira linha da subrotina cria o hash. A palavra-chave our indica que é uma variável global, então nós poderemos acessá-la a partir de outras subrotinas. O motor desta subrotina é a expressão $hash{$palavra}++, que encontra o valor no hash que corresponde à palavra dada e o aumenta em um. Quando uma palavra aparece pela primeira vez, o Perl magicamente faz a coisa certa, criando um novo par chave-valor e inicializando o valor em 0. Para imprimir os resultados, podemos escrever outra subrotina que acesse a variável global hash: 43
- 45. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF sub print_hash { our %hash; my @list = keys %hash; print @list n; } 7.5 Ordenação Lembremos do código com que trabalhamos há pouco: sub print_hash { our %hash; my @list = keys %hash; print @list n; } O operador sort ordena os elementos de uma lista, usualmente na ordem determinada pelo operador de comparação de string. Por exemplo, a seguinte versão de print_hash imprime as chaves em ordem alfabética: sub print_hash { my @list = sort keys our %hash; print @listn; } Se quisermos a lista ordenada em uma ordem diferente, podemos prover uma subrotina es- pecial que compara dois valores e retorna 1 se o primeiro for maior, -1 se o segundo for maior e 0 se eles forem iguais. Por exemplo, para ordenar os valores numericamente, poderíamos prover a seguinte subrotina: sub numericamente { $a = $b } Dentro da subrotina, os nomes especiais $a e $b se referem aos elementos comparados. Agora podemos usar o sort desta forma: my @list = sort numericamente values our %hash; Os valores do hash são ordenados do menor para o maior. Infelizmente, isto não nos ajuda a encontrar as palavras mais comuns, porque não podemos encontrar uma palavra associada através do seu valor. Por outro lado, podemos prover uma subrotina comparativa que compara chaves verificando seus valores associados. sub porvalor { our %hash; $hash{$b} = $hash{$a}; } E então ordenar as chaves pelos valores da seguinte forma: my @list = sort porvalor keys our %hash; 44
- 46. Capítulo 8 Lição 7- Hashes 2 8.1 Conjunto e membros Hashes são freqüentemente utilizados para checar se um elemento é membro de um conjunto. Por exemplo, podemos ler a lista de palavras em /usr/share/dict/words e montar um hash que contenha uma entrada para cada palavra. A seguinte subrotina pega uma linha do dicionário e cria para ela uma entrada em um hash: sub dict_linha { our %dict; my $word = lc shift; chomp $word; $dict{$word}++; } A primeira linha declara o hash global chamado %dict. A segunda linha pega o parâmetro e o converte para minúsculas. A terceira linha utiliza chomp para remover o caractere de nova linha do fim da palavra. A última linha da subrotina cria a entrada no dicionário. Agora podemos checar se uma palavra está no dicionário testando se há definida uma entrada no hash com a chave dada. O operador definido diz se uma expressão foi definida. if (!dened $dict{$word}) { print *} Quando o corpo de um if é pequeno, é comum escrevê-lo em uma única linha e omitir o ponto-e-vírgula na última expressão do bloco. Também é comum tirar vantagem da seguinte sintaxe alternativa print *if !defined $dict{$word}; que simplifica um pouco a pontuação. 8.2 Referências a subrotinas Neste ponto nós nos encontramos percorrendo dois arquivos, um dicionário e um texto, e realizando diferentes operações sobre as linhas. É claro, poderíamos copiar o código que abre e percorre um arquivo, mas poderia ser melhor generalizar read_file de forma que ele pegue um segundo argumento que é referencia a subrotina que ele deveria utilizar para processar cada linha. 45
- 47. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF sub read_file { my $file = shift; my $subref = shift || read_line; open (FILE, $file) || croak Não foi possível abrir $file; while (my $line = FILE) { $subref-($line); } } A segunda linha utiliza shift para ler o segundo parâmetro. Se o resultado for undefined (ou seja, se não houver um segundo parâmetro), então ele usa o valor padrão read_line, que é uma referência a uma subrotina. Estritamente falando, $read_line é o nome da subrotina, a qual a contra-barra faz uma referência. Note que $subref é uma variável escalar, o que é uma dica de que referências são variáveis escalares. Dentro do loop vemos a sintaxe para chamar uma subrotina quando temos uma referência a ela. O operador - é uma das várias formas de de-referenciar uma referência, ou seja, utilizar o valor ao qual uma referência se refere. O argumento em parênteses é só um argumento como os outros que já havíamos visto. Agora para ler o dicionário podemos chamar read_line com um segundo parâmetro. read_le /usr/share/dict/words, dict_line; Novamente, a expressão dict_line é uma referência à subrotina cujo nome é tecnicamente dict_line. 8.3 Hashes como parâmetros Quando um hash é passado como parâmetro, ele é convertido em uma lista de chaves e valores alternados. Por exemplo, a seguinte subrotina sub print_hash { print @_n; } produz a seguinte saída: Três Número 3 Um Número 1 Dois Número 2 Uma solução é converter a lista novamente a um hash: sub print_hash { my %hash = @_; while ((my $key, my $value) = each %hash) { print key = $valuen; } } Para a maior parte das aplicações, a performance dessa solução seria suficiente, mas no caso de envolver um hash muito grande, seria melhor passar o hash por referência. 46
- 48. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Quando invocamos print_hash, passamos uma referência ao hash, que criamos com o opera- dor contra-barra. print_hash %hash; Dentro de print_hash, designamos a referência a um valor escalar nomeado $hashref, e então usamos o prefixo % para de-referenciá-lo; ou seja, para acessar o hash ao qual $hashref se refere. sub print_hash { my $hashref = shift; while ((my $key, my $value) = each %$hashref) { print $key = $valuen; } } Referências podem ser sintaticamente pitorescas, mas elas são úteis e versáteis, então vamos continuar a vê-las eventualmente. 8.4 Gerador Markov Para demonstrar alguns dos atributos que temos conhecido, tentaremos desenvolver um pro- grama que lê um texto e analisa a freqüência da combinação de várias palavras e depois gera um novo e aleatório texto cujas palavras aparecem com as mesmas freqüências. O resultado é muitas vezes divertido e sem sentido, beirando às vezes uma paródia. O primeiro passo é analisar o texto observando todas as combinações de três palavras. Para cada prefixo de duas palavras, gostaríamos de saber todas as palavras que podem se seguir, e com que freqüência cada aparece. Por exemplo, nas palavras imortais de Elvis love me tender, love me true. o prefixo love me aparece duas vezes, seguido ou de tender ou de true. Inclusive o prefixo me tender, que é seguido de lovee tender, love, que é seguido de me. Para completar a análise, podemos construir um hash que mapeia dos prefixos até lista de palavras que podem se seguir. me tender, = love love me = tender, true. tender, love = me Enquanto percorremos um arquivo, podemos contruir um conjunto de prefixos mantendo uma fila de três palavras, adicionando cada palavra nova ao seu fim e removendo uma outra do seu início. Novamente, podemos utilizar read_file, fornecendo-lhe uma referência a uma subrotina chamada triple_line. read_file $file, triple_line; triple_line simplesmente quebra a linha em palavras e chama triple_word: sub triple_line { my @list = split , shift; foreach my $word (@list) { triple_word $word; } 47
- 49. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF } Em triple_word, armazenamos o prefixo mais recente em uma variável global chamada prefix: sub triple_word { our @prefix; my $word = shift; if (@prefix == 2) { print @prefix = $wordn; shift @prefix; } push @prefix, $word; } Quando o tamanho do prefixo é 2, podemos imprimir uma entrada e remover uma palavra do ínicio da fila. Caso contrário, somente adicionamos a palavra ao final. A saída é: love me = tender, me tender, = love tender, love = me love me = true. O que precisamos agora é de um hash que mapeia de cada prefixo a uma lista de palavras. Existem várias formas de se fazer isso. A mais simples é guardar a lista de palavras como uma string, que pode ser armazenada como um valor em um hash por ser escalar. Mas se as listas forem longas, podemos ter uma performance melhor guardando as palavras em um array. Um array não é um valor legal em um hash, mas uma referência a um array é. Aqui está uma versão de triple_word que utiliza um hash para mapear de um prefixo a uma referência de array. sub triple_word { our (@prefix, %hash); my $word = shift; if (@prefix == 2) { my $key = join , @prefix; my $key = join , @prefix; my $aref = $hash{$key}; push @$aref, $word; $hash{$key} = $aref; shift @prefix; } push @prefix, $word; } No if, o operador join concatena os elementos de @prefix em uma string que podemos usar como chave. As próximas três linhas fazem o trabalho propriamente dito. Primeiro olhamos a chave e pegamos a referência a um array. Para de-referenciar o array, adicionamos o prefixo @ ao valor escalar $aref, e usamos push para anexar a nova palavra. A terceira linha só é necessária se vamos criar uma nova entrada. Se a chave estiver já na 48
- 50. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF tabela, então modificar o array é tudo o que temos de fazer. Note que as declarações our e my podem se aplicar a uma lista de variáveis. 8.5 Texto aleatório Agora que analisamos o texto original, gostaríamos de gerar um texto aleatório que tenha as mesmas combinações de palavras com a mesma freqüência. O primeiro passo é escolher um prefixo aleatório do hash. O operador rand escolhe um número aleatório (ponto flutuante) entre 0 e seu parâmetro (até, mas não incluso, o parâmetro). Então a expressão rand @list escolhe um índice aleatório de uma lista dada (porque quando a lista é avaliada em contexto escalar ela contém seu tamanho). A subrotina rand_elt escolhe e retorna um elemento aleatório da lista de parâmetros. sub rand_elt { $_[rand @_] } Agora escolhendo uma chave aleatória do hash é fácil: my $prefix = rand_elt keys %hash; Em seguida capturamos o prefixo no hash, separamos a string de palavras em uma lista e escolhemos um elemento aleatório. my $words = $hash{$prefix}; my $word = rand_elt split , $words; Finalmente, podemos formar o prefixo seguinte separando o prefixo antigo, trocando (com shift) a primeira palavra e anexando a nova. my @triple = split , $prefix; shift @triple; $prefix = @triple $word; 49
- 51. Capítulo 9 Lição 8- Objetos 1 9.1 Introdução Quando dizemos que uma linguagem é orientada-a-objetos, normalmente queremos dizer que ela possui capacidades sintáticas especificamente projetadas para suportar programação orientada a objeto. Segundo esta definição, o Perl não é realmente uma linguagem orientada-a- objetos. Por outro lado, existem muitas maneiras de se escrever programas orientados-a-objetos em Perl, e muitos dos atributos desta linguagem são bem adequados para tanto. No nível mais básico, um objeto é uma referência. Começando aí, esta lição apresentará as várias características do Perl que são tipicamente utilizadas para se escrever programas orientados-a-objetos. 9.2 Pacotes Não obstante podermos pensar em qualquer referência como um objeto, normalmente fica- mos mais à vontade atribuindo objetos a classes. Em Perl podemos criar uma classe definindo um pacote (package) e depois utilizando o operador bless para atribuir objetos à nova classe. A expressão package marca o início de um novo pacote. Toda variável subseqüente e declarações de subrotina são adicionadas ao pacote atual, até o fim da fila corrente (ou bloco de código) ou até outra expressão package. O exemplo a seguir declara uma variável global chamada value e então inicializa um pacote chamado Fred. Dentro do novo pacote podemos criar outra variável com o mesmo nome sem conflitos, porque o novo pacote tem seu próprio escopo semântico. A expressão print se refere à variável no pacote atual, que tem o valor home. our $value = away; package Fred; our $value = home; print valuen; Sendo bem rígido, aquilo que temos chamado de variáveis globais são na verdade variáveis de pacotes. Todas as variáveis pertencem a um pacote; se você não criar o seu próprio, o nome padrão é main. Para se referir a uma variável em outro pacote, devemos utilizar um nome completo (fully- qualified name), que inclui o nome do pacote e o nome da variável. No exemplo anterior, pode- ríamos acessar a primeira variável com a expressão $main::value. 50
- 52. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 9.3 O operador Bless Qualquer referência pode ser considera um objeto, mas o tipo mais comum de objeto é uma referência ao um hash. As chaves do hash são as variáveis de instância do objeto. Então, a maneira mais simples de se criar um objeto é criar uma referência ao hash. Já vimos uma forma de se fazer isso, utilizando o operador blackslash (contra-barra). my %hash; my $hashref = %hash; Outra forma de se fazer a mesma coisa é usar chaves: my $nobody = { }; my $person = { name = Amélia Pulino, webpage = ameliapulino.com}; O primeiro exemplo cria um hash vazio e faz $nobody se referir a ele. O segundo exemplo cria um hash como dois pares chave-valor. Agora somente temos de dizer ao Perl que este objeto pertence a uma classe particular. O segundo exemplo declara um pacote Person, cria um objeto atribui o objeto à classe Person. Package Person; my $person = { name = Amélia Pulino, webpage = ameliapulino.com}; bless $person, Person; Agora, quando invocarmos um método nesse objeto (o que já vamos aprender), o Perl sabe em pacote encontrar o método. 9.4 Métodos Um método é só uma subrotina que pega um objeto como se fosse seu primeiro parâmetro. Por exemplo, name pega uma Person como parâmetro e retorna o valor da variável de instância name. sub name { my $self = shift; my %hash = %self; return $hash{name}; } name é o exemplo de um método acessor, visto que ele provê acesso a uma das variáveis de instância. Para invocar este método, podemos simplismente passar um objeto de Person como um pa- râmetro. my $name = name $person; Ou podemos utilizar o operador flecha ’ - ’: my $name = $person-name; 51
- 53. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF O último pode ajudar a manter a ilusão de que estamos utilizando uma linguagem orientada- a-objeto. Freqüentemente é conveniente prover um único acessor que tanto seta quanto lê uma variável de instância. sub name { my $self = shift; if (@_) { $self-{name} = shift }; return $self-{name}; } Novamente, o primeiro parâmetro é o objeto. Se há um segundo parâmetro, ele é utilizado para re-setar name. De qualquer forma, o valor atual de name é retornado. E novamente, existem duas formas de se invocar esse método. O objeto pode aparecer explicitamente como o primeiro parâmetro, desta forma: name $person, Nella B. Yenwod; Ou podemos utilizar o operador flecha. Infelizmente, não podemos usar este operador com uma lista de parâmetros: $person-name Nella B. Yenwod; # ERRADO Mas podemos resolver o problema com os parênteses: $person-name(Nella B. Yenwod); Em situações como esta, entusiastas do Perl gostam de dizer There’s more than one way to do it- TMTOWTDI - ou seja, há mais de uma forma de fazê-lo. Aqueles que não gostam tanto, por outro lado, respondem o FORHOTDW, For obscure reasons, half of them don’t work; ou seja, por razões obscuras, metade delas não funcionam. 9.5 Construtores Um construtor é um método, qualquer método, que cria e retorna um novo objeto. Por convenção, contrutores são chamados new. Aqui está um construtor Person: sub new { my $self = { @_ }; bless $self, Person; } Os parâmetros são uma lista de chaves e valores que são utilizados para inicializar o hash. Então podemos invocar o construtor assim: my $person = new(name = Amélia Pulino); Porém é mais comum invocá-lo usando o nome da classe: my $person = Person-new(name = Amélia Pulino); Neste caso, o nome da classe é enviado como primeiro parâmetro na lista, então podemos usá-lo como segundo parâmetro para bless: 52
- 54. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF sub new { my $class = shift; my $self = { @_ }; bless $self, $class; } Esse é um formato padrão para a construtores de objetos. Sempre que formos escrever uma nova classe, podemos começar copiando esse método. 53
- 55. Capítulo 10 Lição 9- Objetos 2 10.1 Imprimindo Objetos Para fins de debugging, vamos quase sempre querer um método que imprima o estado de um objeto. Aqui está uma simples solução: sub imprimir { my $self = shift; while ((my $key, my $value) = each %$self) { print $key = $valuen; } } Por conta do argumento ser uma referência a um hash, temos de usar o termo %$self para o dereferenciar. Este método simplesmente imprime as chaves e valores do hash. Se alguns dos valores são referências, o Perl imprime o tipo de referência e seu identificador único. Podemos querer adicio- nar código a esse método para imprimir o conteúdo do objeto de uma forma mais informativa. 10.2 Pilhas Para demonstrar um objeto mais interessante, vamos escrever a implementação de uma pi- lha. Para desenvolver o código gradualmente, vamos começar com uma pilha de número. Eis a declaração do pacote e o construtor: package Pilha; sub new { my $class = shift; my $self = { aref = [ ], next = 1 @_}; bless $self, $class; } As variáveis de instância são referências a um array, (sabiamente dito aref) e a um número chamado next que acompanha a próxima posição disponível no array. A expressão [ ] cria a referência a um array com um único elemento, uma string vazia. Não utilizaremos o primeiro elemento do array, então estamos colocando lá a string vazia para ocupar esse lugar. O valor inicial de next é o índice da primeira posição que vamos utilizar, 1. Como de hábito, é uma boa idéia ter um método que imprima o estado de um objeto. 54
- 56. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF sub print { my $self = shift; my $next = $self-{next}; my $aref = $self-{aref}; print array = @$arefn; print next = $nextn; } Visto que self-{aref} é uma referência a um array, nós temos de o dereferenciá-lo para impri- mir seu conteúdo. $self-{next} é um escalar, então tudo o que temos de fazer agora é imprimi-lo. 10.3 Pilhas - Adicionar O método adicionar pega dois parâmetros, a pilha e o valor que queremos adicionar. Ele põe o valor na próxima posição disponível no array e então o incrementa. sub adicionar { my ($self, $value) = @_; my $index = $self-{next}; $self-{aref}[$index] = $value; $self-{next}++; } $index é uma cópia local da variável de instância next. Podemos usar seu valor como índice à aref, mas para que atualizemos o next temos que usar o termo $self-{next}. É motivo de surpresa que possamos acessar os elementos de um array usando as chaves. Afinal, $self- {aref} é uma referência a um array, e não o próprio array, e normalmente o Perl não dereferencia automaticamente. Considere os seguintes exemplos: my @array = ( 1, 2, 3 ); my $aref = [ 1, 2, 3 ]; A primeira linha cria a lista e a atribui a um array chamado @array. A segunda linha cria a referência a um array e atribui a um escalar chamado $aref. Nós podemos usar os colchetes para acessar os elementos de @array, então o termo $array[1] tem o valor 2. Mas a expressão $aref[1] é ilegal. Vamos ter uma resposta como: Global symbol @arefrequires explicit package name E isso porque o Perl pensa que estamos perguntando pelo segundo elemento de um array chamado @aref. A solução usual é utilizar o operador flecha, como em $aref-[1], que derefe- rencia $aref e então pega o elemento 1. Então, se colocarmos uma referência a array em um hash, da seguinte forma: my %hash; $hash{aref} = $aref; como acessamos seus elementos? Poderíamos pensar que deveríamos usar o operador flecha novamente, como em $hash{aref}-[1]. Isso funciona, na verdade, mas não é a solução mais comum. Acontece que podemos pegar a referência do hash e a dereferenciar ao mesmo tempo, como em $hash{aref}[1]. Neste momento pode ser que você esteja zonzo, isto é normal. Ignore. Podemos testar os métodos adicionar e imprimir colocando alguns números aleatórios em uma pilha: my $pilha = Pilha-new; for (my $i=0; $i10; $i++) { $pilha-adicionar (rand 100); } $pilha-imprimir; 55
- 57. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Se tentarmos, vamos provavelmente ver um array de dez números aleatórios entre 0 e 100, e o valor do next deverá ser 10. 10.4 Pilhas Remover Eis aqui um método remover que remove e retorna o primeiro elemento de um array e move o último elemento para a primeira posição. sub remover { my $self = shift; my $aref = $self-{aref}; my $resultado = $aref-[1]; $aref-[1] = pop @$aref; $self-{next}; return $resultado } Como de costume, a primeira linha pega o parâmetro. A segunda linha faz uma cópia local da referência de array aref. Se o valor de uma variável de instância é uma referência, então podemos desempacotá-lo, un- pack it, designando-o a uma variável local. Por ser uma referência, podemos utilizá-la tanto para ler quanto para escrever o array. As próximas três linhas (1) guardam o primeiro elemento da pilha, que é o resultado que vamos retornar, (2) move o último elemento da pilha para a frente (por razão que se esclarecerá), e (3) decrementa next, que o seta como o índice da posição não-disponível que acabamos de esvaziar. Podemos testar remover com o seguinte loop: for (1..10) { my $valor = $pilha-remover; print $valorn; } O operador .. constrói uma lista de elementos de 1 a 10. Quanto a expressão for é aplicada a uma lista, ela se comporta como uma expressão foreach. Se rodarmos esse código, ele imprimirá os elementos da pilha, mas não em ordem numérica, ainda (e nem sequer na ordem em que foram adicionados). Uma alternativa melhor é implementar esvaziar: sub esvaziar { my $self = shift; return $self-{next} == 1; } Então podemos usar a expressão until para esvaziar a pilha: until ($pilha-esvaziar) { my $valor = $pilha-remover; $valor-imprimir; } O until é o mesmo que o while, só que com a condição invertida. 10.5 Módulos Já vimos como usar um módulo existente com o use. Agora vamos ver como criar um novo módulo. Em um programa orientado à objetos, um módulo é usualmente um arquivo que define um pacote. Começando com a nossa implemenação de pilha, podemos criar um módulo em poucos passos: 1 - renomeie o arquivo pilha.pl, que tem a extensão de um programa, para pilha.pm, que indica tratar-se de um módulo Perl. 56
- 58. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 2 - remova ou comente o código de teste. Quando um programa usa um módulo, o Perl o executa no momento da compilação. Pode-se colocar código executável em um módulo se se quiser, mas na maior parte das vezes o módulo só contém subrotinas e declaração de variáveis; 3 - a linha shebang no início do arquivo é desnecessária, já que jamais vamos executar um módulo a partir da linha de comando; 4 - A última expressão do módulo deve conter um valor verdadeiro, que indique que o módulo foi executado com sucesso. Por convenção, a última expressão é 1. 57
- 59. Capítulo 11 Lição 10- Callbacks e Pipes 11.1 Introdução Neste capítulo, vamos desenvolver dois programas. Um, chamado get.pl, usa HTTP para baixar um arquivo de um site. Outro, chamado mirror.pl, pega uma URI como parâmetro e usa o get.pl para baixá-lo. Na medida em que este for descobrindo links não visitados, o mirror cria novos processos para baixá-los. Esses programas demonstram o uso tanto dos callbacks, que provêem uma forma flexível de interagir com o código existente em módulos, quanto dos pipes, que provêem uma forma simples de comunicação entre processos. Na medida em que formos andando, vamos brincar com alguns módulos padrões (e com alguns nem tanto) do Perl como URI, HTTP::Request, HTML::Parser e IO::Select. 11.2 URIs Uma das característics mais poderosas do Perl é a sua extensa biblioteca de módulos. Muitos desses módulos estão disponíveis na Comprehensive Perl Archive Network (CPAN), convenien- temente localizada em cpan.org. Alguns módulos são mais padrões que outros. Alguns módulos centrais do Perl (Perl Core Mo- dules) podem ser considerados parte da linguagem. Outros módulos, como aqueles que vamos usar neste capítulo, estão incluídos na vasta maioria das instalações do Perl. Diferentes módulos oferecem diferentes interfaces. Aqueles que vamos ver tendem a ser orientados à objetos. Eles definem uma nova classe de objetos e os métodos que neles operam. Outros, como POSIX, provêem um conjunto de subrotinas. Para esquentar, vamos começar com uma classe simples chamada URI, que é sigla para Uniform Resource Identifier. Uma URI é basicamente a mesma coisa que uma URL, que identifica uma fonte na World Wide Web. Eis um programa que pega uma URL em forma de string, cria um novo objeto URI e o converte para a sua forma canônica: use URI; sub main { my $uris = shift || http://www.slashdot.com; my $uri = URI-new($uris)-canonico; $uris = $uri-como_string; print $urisn; 58
- 60. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF } main @ARGV; a primeira linha do main pega o parâmetro da lista de argumentos da linha de comando. Se a lista é vazia, ela usa o valor padrão http://www.slashdot.com. A segunda linha cria um objeto URI, e então invoca canonico, que retorna o objeto original se ele já está em sua forma canônica ou um novo objeto se, por exemplo, o original usa maíusculas ou um número de porta redundante. Por exemplo: $ ./uri.pl HTTP://www.Slashdot.org:80/Index.htmlhttp://www.slashdot.org/Index.html canonico converte HTTPem httpe torna o nome da máquina todo minúsculo. Como o nome do arquivo (Index.html) é sensível a caso, o ’I’ maiúsculo foi mantido. O especificador de porta :80 é desnecessário porque 80 é a porta padrão para um servidor web. O módulo URI também provê métodos que extraem as várias partes de uma URI: my $scheme = $uri-scheme; my $authority = $uri-authority; my $path = $uri-path; O scheme é normalmente o nome do protocolo, como httpou ftp. O authority é usual- mente o nome da máquina que provê esse fonte. O path é o nome completo do arquivo (incluindo os diretórios pais). 11.3 HTTP GET Para pegar um arquivo de um servidor web, o cliente deve enviar um pedido de HTTP GETe esperar por uma resposta. A biblioteca Perl da WWW (LWP) provê um conjunto de objetos e de métodos que tornam quase trivial implementar um cliente web. Os três componentes que usaremos são UserAgentn, Request e Response. use LWP::UserAgentn; use HTTP::Request; use HTTP::Response; Objetos de Request representam as mensagens enviadas do cliente ao servidor; Objetos Response representam as respostas. O UserAgentn provê a capacidade de enviar e receber essas mensagens. Eis a forma mais simples de um pedido HTTP GET: my $ua = LWP::UserAgent-new; my $pedido = HTTP::Request-new(GET = $uri); my $resposta = $ua-pedido($pedido); print $resposta-conteudo; A primeira linha simplesmente cria um UserAgent. A segunda linha cria o objeto Request, especificando a URI e o fato de que é um pedido GET(em oposição ao HEADou POST, por exemplo). Para pegar um arquivo, dizemos ao UserAgent para procesar o pedido. O resultado é um objeto Response que contém o conteúdo do arquivo juntamente com o cabeçalho. A última linha extrai e imprime o conteúdo. 59
- 61. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Para mais informações sobre todas as três classes (e mais) veja a documentação LWP em http://search.cpan.org/dist/libwww-perl/. 11.4 Callbacks Na página anterior, usamos o método request da classe UserAgent para baixar um arquivo inteiro e então escrever seu conteúdo em um arquivo local. Mas freqüentemente a performance de redes de longo alcance é baixa (comparada a uma performance local), além de ser imprevisí- vel. Pode ser mais eficiente começar escrevendo no arquivo assim que o primeiro pacote chegar, de forma que possamos distribuir o esforço na espera por pacotes da rede e no acesso a disco. O método request pode aceitar um segundo argumento, uma referência a uma subrotina. Na medida em que pacotes chegam, request chama a função dada, passando em porções do arquivo. A subrotina que é passada como parâmetro e então chamada pelo receptor é dita um callback. Exemplo: sub callback { my $porcao = shift; print FILE $porcao; } Agora podemos chamar request desta forma: open FILE, , $arquivo or croak Não foi possível abrir $arquivo; my $request = HTTP::Request-new(GET = $uri); my $response = $ua-request($request, callback); 11.5 Espelhando O nosso próximo passo é transformar o programa em uma ferramenta que espelhe (mirrors) uma página web. Ou seja, nós gostaríamos de criar um arquivo (ou diretório) local que tenha o mesmo nome e conteúdo que aquele no site remoto. Para fazer tanto, vamos escrever algumas linhas de código para criar um diretório, se ne- cessário, e então abrir o arquivo. Dado a parte do ’caminho’ (path) da URI, vamos encontrar o diretório pai usando o método dirname do pacote File::Basename. my $path = $uri-path; my $dir = $uri-authority . File::Basename::dirname $path; O próximo passo é criar o diretório. my $res = system mkdir -p $dir; if ($res != 0) { croak Não foi possível criar o diretório $dir}; O sistema cria um subprocesso e executa o comando dado. Neste caso, o comando é mkdir, que é o comando Linux para criar um novo diretório. A opção -p instrui o mkdir a criar qualquer diretório pais que forem necessários e a não reclamar se algum deles já existir. Infelizmente, os valores de retorno de muito comandos Linux não seguem a convenção do Perl. No Perl, qualquer valor verdadeiro indica o sucesso e os valores falsos, o erro. Para muitos comandos Linux, o valor 0 indica sucesso e todos outros são códigos de erro. 60
- 62. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF O último passo é juntar o nome do arquivo e abrir o arquivo: my $arquivo = $uri-authority . $path; open FILE, , $arquivo or croak Não foi possível abrir $arquivo; Estamos usando a parte authorityda URI como diretório de topo, de forma que todas as páginas que pegarmos a partir de um mesmo site vão parar em um mesmo diretório. 11.6 Analisando Enquanto lemos o conteúdo de uma página da web, podemos também querer extrair os links que ela contém. A forma mais simples de fazê-lo é procurar pelos padrões que casam com a tag a. Mas há um módulo chamado HTML::Parser que é ainda mais acessível (assim que se aprende como usá-lo), e que nos dá outra chance de utilizar os callbacks. Antes de analisar, vamos criar o objeto Parser. our $p = HTML::Parser-new( start_h = [$start_tag, tagname, attr]; ) Os parâmetros que enviamos ao construtor são, como de costume, uma lista de variáveis de instância e seus valores. Nesse caso, a variável de instância é start_h. Um manipulador (handler) é um tipo de callback que é invocado para lidar com um tipo de evento. O Parser utiliza manipuladores para vários outros tipos de eventos, aliás. O valor de start_h é uma lista que contém uma referência ao callback, que é sabiamente chamado start_tag, e também uma string que especifica que informação deveria ser passada como parâmetro ao callback. Nesse caso, queremos que o nome da tag um hash que contenha os atributos que aparecem na tag. Por exemplo, o seguinte código HTML gera um link textual. a href=http://exemplo.compágina da weba Quando esse código é analisado, ele gera três eventos. O primeiro é uma tag de abertura com nome de tag ’ a ’ e um hash de atributos que contém uma entrada, href = http://exemplo.com. O próximo evento é um evento textual com o texto página da web. O último evento é uma tag de finalização com o nome de tag ’ a ’ (e nenhum atributo). Eis uma versão de start_tag que espera por links a e imprime a URI a qual eles se referem. sub start_tag { my ($tagname, $attr) = @_; if ($tagname eq a) { my $href = $attr-{href}; print $hrefn; } } O objeto analisador é incrementante, o que significa que podemos invocar parse repetida- mente, passando porções de quaisquer tamanhos de código HTML. Essa capacidade funciona bem com o código da seção anterior que armazena o arquivo que chega em porções. Podemos modificar callback de forma que ele armazene cada porção e o passe para o Parser. sub callback { my $linha = shift; 61
- 63. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF our $p-parse($linha); print FILE $linha; } Callbacks são uma forma versátil de integrar um módulo com um programa. A maior contra- partida é que o fluxo da execução no programa pode se tornar complicado. Neste caso, quando uma porção de um arquivo chegar, o UserAgent invoca callback, que passa a porção ao Parser. Se, por sua vez, a porção contém uma tag de inicialização, o Parser invoca start_tag. 11.7 URIs absolutas e relativas As URIs que vimos até então têm sido absolutas, o que significa que elas incluem scheme, authority e path. As referências, no entanto, que aparecem em tags a podem ser relativas, o que significa que elas só incluem um path. Por exemplo, http://exemplo.com/index.html é a URI absoluta de um arquivo. Se esse arquivo contém uma URI relativa como referência, assumimos que a referência é relativa ao pai do arquivo corrente. Por exemplo, uma referência à projetos.html apontaria a http://exemplo.com/projetos.html. O pai do arquivo corrente é dito a URI base. A classe URI provê métodos para converter URIs relativas para absolutas, e vice-e-versa. O método abs converte uma URI relativa a uma absoluta, dada a URI base como parâmetro. Eis um exemplo: my $base = URIs-new(http://exemplo.com/index.html); my $rel = URIS-new(projetos.html); my $abs = $rel-abs($base); print $absn; A saída deste fragmento de código é http://exemplo.com/projetos.html. 11.8 Processos múltiplos Neste ponto nós temos um programa que baixa uma URI dada, armazena o resultado com um nome de arquivo apropriado, e que imprime as URIs de quaisquer links que encontrar. Vamos usar este programa como componente de um robot, que é um programa que percorre um website baixando arquivos e links até pegar todos os arquivos (ou ao menos todos os arquivos que podem ser acessados seguindo os links a partir da URI inicial. Por várias razões, é útil ao fazer programas como este, fazê-los multithreaded, ou seja, capaz de lidar com múltiplos processos concorrentes. As razões são: - redes são lentas comparadas ao processamento local, então freqüentemente é mais rápido rodar diversas conexões de rede ao mesmo tempo; - a performance das redes é muito variável. Quando uma conexão se torna lenta ou pára, outra poderia estar fazendo progresso. É claro, se temos múltiplas conexões ao mesmo site, elas competem umas com as outras pe- los recursos na rede e no servidor. Então tem um ponto em que aumentar o número de conexões deixa de ser interessante. 62
- 64. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 11.9 Planejamento familiar Nas próximas duas páginas, vamos desenvolver um programa pai que cria processos filhos para baixar arquivos. O programa pai iniciará com uma única URI, e criar um único filho para baixá-la. Assim que o filho descobrir links não visitados, o pai criará mais filhos para baixá-los. O papel do pai será controlar o número de filhos que vão rodar concorrentemente e manter uma lista de URIs que esperam para ser baixadas. Eis o loop principal do programa: sub main { our @lista = @_; our %visto; our $procs = 0; our $s = IO::Select-new(); while (1) { while (@lista 0 $procs 6) { get shift @lista; } my @pronto = $s-pode_ler; foreach my $marq (@pronto) { processar $marq; } last if (@lista == 0 $procs == 0); } } @lista é a lista de URIs que esperam para ser baixadas. Inicialmente pegamos a lista de argumentos da linha de comando. %visto é um hash que contém as URIs que já baixamos. Antes de adicionar um URI à @lista, garantimos que não foi ainda baixada, checando o hash do $%visto. $procs é o número de processos filhos rodando em concorrência. $s é um objeto IO::Select, que provê uma interface conveniente para a chamada de sistema select. Bem no meio do loop principal, main, invocamos pode_ler neste objeto para pegar uma lista de manipuladores de arquivos que têm dados prontos para ser lidos; isto é, a lista de pro- cessos filhos que encontraram um link. O loop principal contém dois loops internos. O primeiro controla o número de processos filhos; o segundo coleta links dos filhos e os adiciona à lista. O loop principal termina quando @lista se torna vazia e não há mais processos filhos. 11.10 Fazendo filhos Cada vez atravessado o loop principal, checamos @lista e criamos até 6 processos filhos. Para cada elemento da lista, invocamos get. 63
- 65. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF sub get { our (%visto, $procs, $s); my $uris = shift; open my $marq, ./get.pl $uris |or croak não pode bifurcar; $visto{$uris}++; $procs++; $s-adicionar($marq); } Nós utilizamos antes o operador open para abrir arquivos. Aqui, estamos usando o open para criar um pipe. Um pipe é um processo filho que se comunica com o processo pai através de um manipulador de arquivo. Neste caso, o processo filho gera a saída usando o operador print, que o pai também lê através do manipulador de arquivo. Se o operador open tiver sucesso, atualizamos o %visto e $procs, e então adicionamos o novo manipulador de arquivo, $marq, à lista de manipuladores de arquivos sendo monitorada pelo objeto Select. Voltando ao loop principal, quando invocamos pode_ler, ele nos diz quais dos manipuladores de arquivos estão prontos para ser lidos. 11.11 Respondendo aos pais pode_ler não completa até que um ou mais manipuladores de arquivos estejam prontos. Quando ele completa, nós percorremos a lista de manipuladores de arquivos e chamamos pro- cessar para cada um. sub processar { our (@lista, %visto, $procs, $s); my $marq = shift; my $linha = $marq; chomp $linha; if ($linha eq done) { close $marq; $s-remove($marq); $procs; } else { push @lista, $linha unless defined $visto{$linha}; } } processar usa o operador angle para ler uma única linha do manipulador de arquivos dado, e usa chomp para remover o caractere de nova linha. Às vezes não é uma boa idéia usar o operador angle com select, mas neste caso, sabemos que sempre que um processo filho produzir dado, ele produzirá uma linha inteira. Então se um manipulador de arquivo estiver pronto para ser lido, estaremos prontos para ler exatamente uma linha inteira. Em uma situação diferente, o operador angle poderia bloquear esperando um processo filho produzir o resto de uma linha. processar lida com dois casos. Se a linha que lemos esta pronta, então sabemos que o 64
- 66. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF processo filho terminou e que podemos fechar o manipulador de arquivos, removê-lo da lista no objeto Select e decrementar o número de processos em concorrência. Se a linha é um link descoberto por um processo filho, adicionamos à lista de URIs esperando para ser baixadas, a não ser que ela já esteja em %visto. 65