Para acessar o primeiro exame clique aqui

Na próxima semana provavelmente segunda vou colocar já a disposição um simulado para quem deseja fazer a prova LPI 101, o exame será feito por um profissional da área que já fez a prova e passou se certificando na LPI 101.

Aos poucos e conforme pedidos vou colocando novos exames e simulados!

até

Daniel

O Perl é uma das linguagens mais usadas hoje em dia. PERL significa “Practical Extraction and Report Language” (linguagem prática de extração e relatório). Ela foi criada por Larry Wall para facilitar a manipulação de textos suprindo as necessidades que o shell, awk e sed não conseguiam resolver. Perl é a ferramenta para fazer o seu trabalho, de forma rápida e eficiente.

Apesar de ter sido originalmente escrita para manipulação de texto, o fato de ter o código aberto e estar licenciada nos termos da GPL, permitiu que se expandisse para as mais diversas áreas. Com Perl é possível escrever ferramentas para administração de sistema, servidores, daemons, CGIs, programar para X usando toolkits como TK, Gtk+ e QT, escrever aplicativos Gnome e KDE, usar bibliotecas em C, interfaceamento com banco de dados, entre outras coisas.

Uma das forças do Perl é a sua comunidade, que assim como a do Linux colabora com o seu desenvolvimento e uso. O maior exemplo é o CPAN (www.perl.com/CPAN/), Comprehensive Perl Active Network, que é uma coleção de módulos e bibliotecas que permitem desde codificar um cliente compatível com o ICQ até manipular todo o funcionamento do servidor de web Apache. Antes de tentar reinventar a roda, certifique-se de que alguém já não o tenha feito.

O objetivo deste artigo é introduzi-lo ao Perl, começando pelo básico da linguagem até escrever uma pequena ferramenta de administração de sistema. Não é necessário conhecer Perl, mas um conhecimento básico de qualquer linguagem o ajudará a entender melhor.

Tipos de variáveis

A maioria dos termos mais comuns será mantida em inglês uma vez que será assim que você os achará na maior parte da literatura sobre o assunto.

Os tipos de variáveis no Perl são: scalar, array, hash e filehandle.

$scalar

O scalar (representado pelo $) é o tipo de variável mais usada. Podendo representar:

• um número (ex: 1, -4, 10.897, -12e4),
• uma string (ex: “Gooolll!!!”),
• ou uma referência (mais sobre referências depois).

Assim:

$a = 4;			 	# Número 4
$b = "Erro número ";		# uma String

Como o Perl diferencia um número de uma string? Depende do contexto.

Assim:

print $b . $a;	#O '.' concatena duas strings

resultando:

Erro número 4

e:

print $b + $a;	#O '+' adiciona dois números

resultando:

4

No primeiro caso, o número 4 em $a é convertido para

a string “4″. No segundo, a string “Erro número” em $b é convertida para o número 0, já que não é possível transformá-la em outro valor. No entanto, se a string representar um número válido como “-3.14″, será convertida para o número -3.14, se o contexto pedir um número.

@array

Uma array (ou matriz) é uma lista de scalares. Para criar uma array (representada por @):

@a = (1, 2, "mar",'); 	#Uma lista de três elementos
#(scalares), 2 números e 1 string

Os parênteses têm um significado especial. Eles

colocam os scalares em um contexto de lista. No caso:

@a = (2,');

(2) é uma lista de um elemento, 2. Cada elemento de uma array pode ser acessado diretamente na forma $array[índice], em que índice é a posição do elemento na lista. O primeiro elemento tem índice 0.

Analise a situação:

$a = 33;		 #Um scalar
@a = ("trinta e três",'); #Uma  array de um elemento print $a;
print $a[0];
O que será impresso no primeiro print? E no segundo?
Resposta: 33 e "trinta e três".
Porque o $a e $a[0] estão em "espaços"
diferentes dentro do Perl. Assim, você pode ter um scalar, uma array,
um hash, um filehandle e uma função com o mesmo nome. E uma não
interfere com a outra.
Um recurso muito útil com os arrays é o slice
(fatia). 
O slice separa um pedaço de uma array.

@a = (1, 5, 4, "carro", "moto",');
#Uma array de 5 elementos
@b = @a[2..4];
#@b contém 4, "carro" e "moto"

Uma função muito usada quando se trabalha com

arrays é o sort. O sort ordena alfabeticamente uma lista. No exemplo

anterior:

@a = sort(1, 5, 4, "carro", "moto",');
#Uma array de 5 elementos
@b = @a[2..4];
#@b contém 5, "carro" e "moto"
%hash

O hash(representado por %) é um caso especial de array.

O hash é uma array cujo índice é uma string. Assim:

%hash = (,');
#criada um hash vazio
$hash{'banana'} = "R$ 1,05";
#Item banana em hash com valor
#"R$ 1,05"
$hash{"maçã"} = "R$ 0,40";
#Idem para maçã
$hash{laranja} = "R$ 0,65";
#também válido, as aspas são
#opcionais
Assim como a array, as variáveis

$a, $a[0] e $a{0} são todas diferentes e independentes.

Um hash é na verdade uma array especial. Isso permite

algumas coisas interessantes como:
@a = ("banana", 12, "uva", 40,');	
#Uma array
%frutas = @a;				
#O conteúdo de @a foi convertido para
#uma array
print $frutas{uva};			
#vai mostrar "40".
Filehandle

O filehandle é a forma que o Perl usa para se comunicar

com o mundo externo. Não existe um símbolo especial para ele,

por isso usa-se uma palavra em letras maiúsculas para evitar conflitos

com palavras reservadas.

Um filehandle pode ser a leitura de entrada, saída para

a tela (STDIN, STDOUT), a leitura ou escrita de um arquivo ou mesmo um socket

de rede (como uma conexão TCP/IP).

Funções

As funções (ou subrotinas) no Perl são

definidas pela declaração sub:
sub minha_primeira_funcao{
#código da função vem aqui
#....
}
Em que os { } definem um bloco que

contém a subrotina. No Perl, não se definem

os parâmetros das funções diretamente

como em outras linguagens.

Ao invés disso, o Perl define um array @_ que contém

uma lista com os argumentos passados para a função.
Assim:

minha_funcao(1234, $dado_a, $ar[6], $fruta{melao},');
#Chama-se    a funcao
E na definição da função:
sub minha_funcao{
$meu_dado_a = @[1]; 
$minha_frunta = @[3];
}
Ou, mais comum:
sub minha_funcao{
($senha, $meu_dado_a, $param, $minha_fruta) = @_;
#...
}
Cada item da array (@_) é copiado diretamente para o

item correspondente na primeira lista.

Para retornar um dado da função, usa-se o comando

return.

Referências

O conceito de referência é um pouco mais complicado

de entender para quem está começando e/ou tem pouca experiência

com programação. Uma referência "aponta" para

outra variável. A referência contém a localização

de outra variável. Nada melhor do que um exemplo para ajudar a entender:
$a = "Oi";	#Um scalar normal
	$b = $a;	#O $b é uma referência para o $a
O `' antes de uma variável serve para "extrair"

sua referência. Assim:
print $$b;
mostrará:
Oi
Pode-se analisar como o scalar ($) referenciado por $b. Praticamente

qualquer coisa pode ser referenciada: scalares($), arrays(@), hashes(%), filehandles

ou mesmo funções(&). Assim:
@array = ( 13, "carro", $a,'); 
#Uma array de 3 elementos
$b = @array;				
#$b é uma referência para
#@array
Assim, @$b é a array(@) referenciada por $b. Cuidado

para não usar um tipo de variável diferente da referida pela referência,

no caso usar um $ ($$b) ao invés de um @ (@$b). Isso causará um

alerta ou mesmo erro na execução do programa.

Pode não parecer óbvio o uso de referências,

mas imagine uma array com 1MB de tamanho. Se você simplesmente copiá-la

com:
@new_array = @old_array;
você terá uma cópia idêntica de @old_array.

Se @old_array tem 1MB, @new_array usará outro 1MB. Quando você

passa parâmetros para uma função, os parâmetros são

copiados para a array @_, a mesma situação ocorre. Se, ao invés

de passar parâmetro por parâmetro, for passada uma referência,

economiza-se memória e ganha-se velocidade:
@array_gigante = (,'); 
#Uma array
#gigante
funcao(@array_gigante,'); 
#passa uma referência da array
sub funcao{
$refarray = $_[1];	
#Cópia da referência
print @$refarray; 
#Usando a array normalmente
print $$refarray[2];	
#Ou o terceiro item
}
Exemplo da vida real
Nada melhor do que um exemplo útil para ver tudo funcionando

junto. Vamos fazer um analisador para o arquivo de log de acesso de um servidor

web.

Existe um formato padrão para log de servidor de acesso.

Esse formato é:
endereço ident user [data] "request"    status bytes
Endereço: 	Endereço IP (mais comum) ou nome

da máquina do cliente.

Ident: 	Resposta do ident no cliente. Normalmente 	não

usado (-).

User: 	O nome do usuário, caso ele tenha se autenticado

antes.

Data: 	A data e a hora do acesso.

Request: 	A linha de requisição enviada pelo

cliente.

Status: 	O status respondido pelo servidor.

Bytes: 	A quantidade de bytes transferidos.

Ex:
200.220.50.122 - gvtit [24/May/2000:08:19:04    -0300] "GET /it/index.html HTTP/1.0" 200 774
O que queremos:

1 - 	As páginas mais acessadas

2 - 	Os endereços(usuários) que mais acessam

o servidor

3 - 	A quantidade total de bytes transferidos

4 - 	A quantidade de bytes transferidos por página

mais acessada.

5 - A quantidade de bytes transferidos por clientes (endereços).

Não nos interessa os campos ident, user e data. Interessam-nos

apenas as entradas com status 200 (accepted).

Outros tipos de resposta serão ignorados.

Começando o programa:
#!/usr/bin/perl -w
use strict;			
my $file = $ARGV[0];	#arquivo a ser usado
A primeira linha especifica que programa executará esse

script.

O -w especifica que o Perl deve ser mais rigoroso com os alertas,

evidenciando potenciais erros.

O "use strict" força o Perl a apenas aceitar

variáveis locais, declaradas com o uso do "my". Isso ajuda

a evitar que erros de digitação possam comprometer o programa.

O "my" usado na declaração das variáveis

as forçam a ser locais. Nesse caso, as variáveis declaradas fora

de uma função não existirão dentro de uma função

e variáveis declaradas dentro de uma função deixarão

de existir quando a função termina.

Assim, se existir uma variável $a fora de uma função

e um $a dentro, elas serão independentes.

A array @ARGV é uma variável especial. Ela contém

os argumentos que foram passados pela linha de comando. Assim, estamos considerando

que o primeiro argumento é o nome do arquivo a ser usado, contendo os

logs.

Continuando:
my $linha;
open (LOG, "<$file",');	
#abre-se o arquivo para leitura
while ($linha = ){	
#loop em cada linha
#aqui elas serão processadas
}			
#fim do loop
O open abre o arquivo para leitura (<) usando o filehandle

LOG para designar o acesso a esse arquivo. A expressão

$linha = , lê uma linha do arquivo. Os <>

são responsáveis por isso. Quando o arquivo terminar será

devolvido o valor undef (indefinido) que é interpretado como falso pelo

while, encerrando assim o loop.

Dentro do loop while:
if ( $linha =~ /^(S+)s+S+s+S+s+[.*]s+"(.*)"s+(S+)s+(S+)$/    ){
$ip = $1;
$full_request = $2;
$status = $3;
$bytes = $4;
Agora um pouco de expressões regulares. Expressões

regulares são um dos recursos mais poderosos do Perl. Uma expressão

regular tenta "casar" seu conteúdo com uma variável.

No caso:
$linha =~ /^(S+)s+S+s+S+s+[.*]s+"(.*)"s+(S+)s+(S+)$/
O sinal "=~" tenta casar o conteúdo de $linha

com a expressão regular (entre //)

Vamos desmontar a expressão regular(ER):

/ 	#Especifica que é uma ER

^ 	#Deve começar pelo primeiro caracter de $linha

$ 	#Deve terminar exatamente no último caracter de

$linha

s 	#Um caracter de espaço (espaço ou tab)

S	#Um caracter diferente de espaço

.	#Um caracter qualquer

+	#Significa um ou mais caracteres iguais ao precedente

*	#	Nenhum ou mais caracteres iguais ao precedente

()	#Gravar o conteúdo dentro dos parênteses

(veja adiante)

"	#O caracter `"`

[	#O caracter `[`. `[` e `]`

tem significado especial em ER

Neste caso estamos checando se a $linha contém uma linha

de log válida. Caso não contenha, capturaremos o erro em um else

depois do bloco.

Também aproveitamos para capturar as informações

que nos interessam com o uso dos (). Serão criadas

automaticamente as variáveis $1, $2, $3 e $4 correspondendo a cada

(). Veja figura 1.

Esta parte é bem direta. %contagem_ip usa o IP do log

como chave (índice), %contagem_request usa o arquivo solicitado

e o mesmo ocorre com a soma dos bytes.

Ao terminar o loop do while, teremos todos os dados processados.

Fechamos o filehandle e podemos começar a ordenação

dos dados. Veja figura 2.

keys é uma função especial para

hashes. Ela gera uma array apenas com os índices

(chaves) do hash.

sort como vimos antes, ordena uma array alfabeticamente.
No entanto, podemos mudar a maneira de como ele ordena.

Para isso especificamos uma função dentro de um BLOCO no sort

com os valores $a e $b. $a e $b são dois elementos da array que está

sendo ordenada. Essa função tem que retornar -1 se $a < $b,

0 se $a == $b ou 1 se $a > $b. A função que faz isso é

esta:
sub ordena_hash_numerica{
	my ($a, $b, $hashref) = @_; #parâmetros de entrada
	my $c = $$hashref{$a} <=> $$hashref{$b};
	return $c;
}
No nosso caso $a e $b são chaves do hash %contagem_request

e o que queremos é ordenar o valor dos hashes. Para podermos comparar

o conteúdo do hash, tivemos que passar uma referência do hash.

O operador <=> faz a tarefa que precisamos. Ele compara

os valores à direita e à esquerda numericamente e retorna -1,

0 ou 1 correspondentemente.

O comando reverse é usado para reverter a ordem de uma

array ou lista. Assim teremos os acessos da ordem do maior para o menor, que

é a desejada. Depois de termos as chaves ordenadas por ordem de acesso,

pegamos as dez primeiras que nos interessam.

Para visualizá-las:
print "Páginas mais acessadas:

#	acessos	bytes	Páginas
";
$count = 0;
foreach $request_url (@top_ten){
			$count++;	#adiciona 1 ao $count
			print "$count	$contagem_request{$request_url}	";
			print "$bytes_request{$request_url}	$request_url
";
}
Finalizando um loop especial é o foreach. Ele executa

o BLOCO uma vez para cada elemento da array @top_ten. No entanto, a cada interação,

$request_url recebe um elemento de @top_ten. Para completar, esse processo de

ordenação e visualização tem de ser repetido para

cada item (hash) que queremos mostrar.

Veja a listagem completa na figura 3.

Note as alterações finais no programa. A primeira

foi a remoção do open do arquivo e o uso do <>. O loop usando

como parâmetro o <> é um caso especial no Perl. Nesse caso,

o Perl irá abrir para leitura todos os arquivos especificados na linha

de comando (ex: loganaliser log log.1 log.2). Caso nenhum arquivo tenha sido

especificado, a leitura será feita da entrada padrão (STDIN).

Isso possibilita, entre outras coisas, o uso de "pipes" no programa

(ex. cat arq | loganaliser).

Outra alteração é a criação

da função ordena_e_mostra, que recebe duas referências de

hashes como parâmetros. Isso possibilita que ela possa ser usada genericamente.

Note também que retiramos as arrays usadas e colocamos tudo na mesma

linha. O slice [0..9] depois do sort e reverse, na função ordena_e_mostra,

funciona por uma simples razão: uma lista especificada entre parênteses

é um array sem a variável (sem nome e sem o `@`).

Antes de mais nada, o Perl é a ferramenta para que você

tenha o seu trabalho resolvido. Com esse exemplo é possível perceber

o seu poder. Mas não para por aí. Existem muitos programas feitos

em Perl, como clientes de e-mail e até mesmo um servidor Radius, o radiator,

essencial em um provedor de internet.

para saber mais

www.perl.com
www.perl.org
www.perl.com/CPAN/
No seu computador: man perl
Livros:
Learning Perl - Schwartz & Christiansen -

Ed. O'Reilly
Programming Perl - Wall - Ed. O'Reilly

Figura 1
if ($status == 200){
#Extrai a URL:
$full_request =~ /S+s+(.*)s+S+/;

$request = $1;

#Garante que o valor é numérico
#Caso o usuário aborte, é colocado "-" no lugar
if ($bytes eq "-"){
$bytes = 0;
}
$contagem_ip {$ip}++;                     #Faz a contagem de
$contagem_request {$request}++;           #acessos
$bytes_ip {$ip}    += $bytes;             #E a quantidade de bytes
$bytes_request {$request}    += $bytes;   #transferidos
$total    += $bytes;                      #O total

}else{          #Aqui contabilizamos o número
$nao_200++;   #de páginas com status diferente de 200
}
}else{            #E o número de erros
$erros++;       #Erro são as linhas que não "casam"
}                 #com a Expressão Regular
}                 #Fim do Loop While
close(LOG,');       #Fecha o LOG

Figura 2
@keys           = keys %contagem_request;    #As chaves índices) do hash
@sorted_keys    = reverse sort{
ordena_hash_numerica($a, $b, \%contagem_request,');
}@keys;                                      #ordena @keys numericamente
@top_ten        = @sorted_keys [0..9];       #Os 10 primeiros elementos
Figura 3
#!/usr/bin/perl -w
use strict;
# declaração das variáveis
my ($ip, $full_request, $status, $bytes,');
my ($request, $total, $nao_200, $erros,');
my (%contagem_ip, %contagem_request, %bytes_ip, %bytes_request,');
while (<>){    #loop em cada linha
if ( /^(S+)s+S+s+S+s+[.*]s+"(.*)"s+(S+)s+(S+)$/ ){
$ip      = $1;
$full_request = $2;
$status    = $3;
$bytes    = $4;
if ($3 == 200){
#Extrai a URL:
$full_request =~ /S+s+(.*)s+S+/;
$request = $1;
#Garante que o valor é numérico
#Caso o usuário aborte, é colocado "-" no lugar
if ($bytes eq "-"){
$bytes = 0;
}
$contagem_ip {$ip}++;                     #Faz a contagem de
$contagem_request {$request}++;           #acessos
$bytes_ip {$ip}    += $bytes;             #E o a quantidade de bytes
$bytes_request {$request}    += $bytes;   #transferidos
$total    += $bytes; #O total
}else{                                      #Aqui contabilizamos o número
$nao_200++;                               #de páginas com status diferente de 200
}
}else{                                        #E o número de erros
$erros++;                                     #Erro são as linhas que não "casam"
}                                             #com a Expressão Regular
}                                               #Fim do Loop While
#As 10 páginas (arquivos) mais acessadas
print "Páginas mais acessadas:

#	acessos	bytes	Páginas
";
ordena_e_mostra(\%contagem_request, \%bytes_request,');
#Os 10 clientes (usuários) que mais acessam
#Não considera proxies.
print "
Clientes que mais acessam:

#	acessos	bytes	Cliente
";
ordena_e_mostra(\%contagem_ip, \%bytes_ip,');
print "
Dados Finais:
";
print "Erros:  $erros
";
print "Não 200: $nao_200
";
print "Total:  $total
";
#ordena e mostra os dados
sub ordena_e_mostra{
my ($ref_a, $ref_b)=@_;
my $count = 0;
foreach $item ((reverse sort {$$ref_a {$a} <=> $$ref_a {$b}} keys %$ref) [0..9]){
$count++;    #adiciona 1 ao $count
print "$count	";    #Mostra os dados
print "$$ref_a {$item}	";    #O item principal
print "$$ref_b {$item}	";    #Item secundário
print "$item
";    #O nome do item
}
}

Nessa agenda nós desejamos guardar os seguintes dados:

Nome da pessoa, Endereço, Telefone, Aniversário, Ocupação, Outras Notas.

Precisamos agora definir como armazenar esses dados. As variáveis do tipo scalar não nos interessam. Uma variável desse tipo pode armazenar apenas um dado de cada vez. Para os dados que queremos, precisaríamos ter para uma pessoa: $nome, $endereco, $telefone, $aniversario, $ocupacao, $outras

O primeiro problema que surge é como armazenar dados de diversos contatos juntos. Poderíamos ter variáveis scalares como $joao_endereco, $maria_aniversario e assim por diante. Mas isso não resolve o problema, pois precisaríamos saber, na hora de escrever o programa, o nome de todas as pessoas que estariam nessa agenda.

%HASHES – A variável hash é um tipo especial de variável encontrada em poucas linguagens. Uma hash associa vários nomes a um valor (scalar) cada. Podemos considerar que cada variável %hash é um minibanco de dados. Com a hash podemos ter uma estrutura um pouco melhorada dos dados: %endereco, %telefone, %niversario, %ocupacao, %outras

E podemos adicionar um contato da seguinte forma:

$endereco{`Carlos'}    = "R. 13 de Maio, 1450";
$telefone{`Carlos'}    = "555-5555";
$aniversario{`Carlos'} = "28/02";
$ocupacao{`Carlos'}    = "Dentista";
$outras{`Carlos'}      = "Primo do Mario";

Note que excluímos o nome, pois estamos usando-o como a “chave” dos hashes. Note também que estamos usando o simbolo `$’ nas variáveis. Isso indica que estamos trabalhando com os elementos das hashes. A variável $endereco{`Carlos’} é um elemento de %endereço.

Existe outro motivo para se usar o `$’. Cada elemento de um hash é um scalar. Dessa forma, pode ser armazenado strings, números e referências, da mesma forma que se faz com uma variável scalar. No entanto, os nomes das variáveis são independentes. Se tivermos uma variável chamada $endereço ela será diferente de $endereço{Carlos}. A última, apesar de ser tratada como scalar, se refere ao elemento `Carlos’ do hash %endereço.

Note que a chave de cada item é uma string (não confunda com $scalar). O uso dos `’ é opcional, caso a string não contenha espaços ou caracteres especiais. Assim, podemos ter:

$endereco{Carlos}, $endereco{`João Cunha'}, $endereco{$nome}.

No último caso, assume-se que $nome contém a string desejada. O uso de hashes resolve pequenos problemas como esses.

Imagine que o Carlos tenha um celular e eu queira o número do celular na agenda.

Um novo hash %telefone_celular resolveria, mas imagine que o Marcos tenha 1 celular, 1 telefone residencial, 2 telefones no trabalho e mais 1 para fax. Nesse caso o simples uso do hash já não fica tão fácil.

Referências

Um scalar pode armazenar uma referência para uma variável. Uma referência é a posição interna no programa em Perl, onde uma variável se encontra. Dessa forma, uma referência “aponta” para uma variável. Assim:

$a = "oi";
$b = $a;

$b contém a posição interna da variável $a. A barra `’ indica que queremos a referência da variável $a e não o seu valor. Se tentarmos ver o resultado: print $b; teremos algo como: SCALAR(0x80e2eec), que somente interessa ou faz sentido para o interpretador Perl. Referências valem para qualquer tipo de variável, assim:

%idade = (
Carlos => 26,
Amanda => 21
,');
@nomes = (`Carlos', `João', `Amanda',');
$a = \%idade;
$b = @nomes;
$c = $idade{Carlos};
$d = $nomes[1];

Note que os parênteses foram usados para declarar os valores de %idade e @nomes. No caso da hash %idade isso é possível porque um hash é visto internamente pelo Perl como uma array, com a diferença de que cada elemento tem uma “chave” (ou nome) associado a ele. Por isso, é comum encontrar o nome “Associative Array” se referindo ao hash.

As variáveis $a e $b contêm respectivamente referências para um hash e um array e as variáveis $c e $d para dois elementos do hash e array, ou seja, referências para variáveis scalares.

As referências podem ser usadas no lugar das variáveis originais às quais elas se referem. Para isso usamos uma técnica chamada de desreferenciamento. Para isso basta especificar o tipo de variável que estamos desreferenciando com o seu símbolo na frente.

Assim, %$a pode ser usado da mesma maneira que se usuaria %idade. $$a{Amanda} se refere ao elemento `Amanda’ de %idade. $$c se refere ao elemento `Carlos’. No caso de $c, não é possível desreferenciá-lo com % como em %$a, porque o tipo de referência que ele possui não é para um hash, mas sim para um scalar (mesmo que esse scalar seja um elemento de um hash).

Por outro lado, o Perl nos permite associar elementos de uma array ou hash diretamente pela referência, sem precisar desreferenciá-la. Nesse caso:

$a->{Carlos} é a mesma coisa que $idade{Carlos} ou $$c

e

$b->[1] é a mesma coisa que $nomes[1]ou $$d

Voltando à agenda de contatos, podemos ter uma idéia de como resolver a questão de vários telefones para um mesmo contato. Podemos usar referências de hash. Considerando que o Carlos tenha 3 telefones, podemos colocar todos os telefones em um lista, ou array, e guardar a sua referência:

@telefones_do_Carlos=(`55-5555',`911-3456',`33-2323',');
$telefone{Carlos} = @telefones_do_Carlos;

Agora os elementos de %telefone são na verdade referências para @arrays, que contém os dados. Para obtermos o segundo telefone da lista (o primeiro tem o índice 0), podemos fazer algo como:

print ${$telefone{Carlos}}[1];

Note que os primeiros `{}’ servem para especificarmos que estamos nos referindo a $telefone{Carlos} e não apenas $telefone. Se tivermos:

$ref = \%telefone;

O mesmo elemento poderia ser acessado:

${$$ref{Carlos}}[1];
${$ref->{Carlos}}[1];
$$ref{Carlos}->[1];

ou para simplificar:

$ref->{Carlos}->[1];

pode-se ler isso como: o segundo elemento da array referenciada pelo elemento `Carlos’ da hash referênciada por $ref. Você deve ter notado que essa forma de trabalhar, apesar de mais eficiente, nos traz de volta ao problema original.

Precisaríamos criar várias arrays como @telefones_do_Carlos para podermos referenciá-las em %telefone. Note que se @telefones_do_Carlos for alterado, as referências em $telefone{Carlos} também serão.

Variáveis Anônimas

Isso nos leva a um conceito muito interessante no Perl, chamado de variáveis anônimas. Como o nome indica, uma variável anônima é uma variável que não possui nome definido.Para isso, ela já é criada na forma de referência.

$array_ref = [ 1, 3, `oi', 45 ];
$hash_ref  = {
Laranja => '12,50',
Maçã    => `7,60'
};
$scalar_ref = "Uma string";

Ou seja, os `[]‘ criam uma array e passam sua referência para $array_ref, os `{}’ fazem a mesma coisa com um hash. No caso do scalar, não existe um símbolo especial como esses, então pegamos a referência diretamente da string com o `’. É importante notar que a única forma de existência de uma variável anônima se dá através de sua referência. Se todas as suas referências forem eliminadas (associando um outro valor a $array_ref, por exemplo), a variável anônima é destruída e apagada da memória.

Podemos reescrever o hash de telefone da seguinte forma:

$telefone{Carlos}=[`55-5555',`911-3456',`33-2323'];

Assim, $telefone{Carlos} contém uma referência para uma array (que contém os telefones).Mas se é possível facilitar a escrita dos telefones, também podemos facilitar para todos os dados do contato:

$contato = {
nome        => `Carlos',
endereco    => ` R. 13 de Maio, 145',
aniversario => "28/02",
ocupacao    => "Dentista",
outras      => "Primo do Mario",
telefone    => [`55-5555',`911-3456',`33-2323']
}

Dessa forma, sempre que quisermos nos referir ao Carlos só será necessária a variável $contato. Vamos expandindo a capacidade de dados armazenados na nossa agenda:

$contato = {
`Carlos Rocha' => {
endereco     => {
Residencial => {
endereco => `R. 13 de Maio, 145',
CEP      => `',
cidade   => `São Paulo'
},
Comercial   => {
endereco => `Av. Silva Jardim, 5445',
CEP      => '54.376-000,
cidade   => `Florianópolis'                          }
},                                     aniversario => "28/02",
ocupacao => ["Dentista", "Estudante de     Administração"]
outras      => "Primo do Mario",
telefone    => {
`555-5555'  => `comercial',
`555-5513'  => `fax',
`9114-3456' => `celular',
`333-2323'  => `residencial'
}
}
};

Mantivemos em letras minúsculas os campos não variáveis.

$contato é uma referência para um hash, onde cada “chave” é o nome da pessoa a que nos referimos.

Cada elemento (com o nome do contato) é uma referência para uma estrutura de dados desse contato.

Além do elemento `Carlos Rocha’, podem haver mais contatos na mesma hash referenciada por contato. Em quase todos os elementos, usamos hashes para montar as estruturas. O motivo é que dessa forma podemos facilmente expandir as informações ilimitadamente.

Se o Carlos comprar uma casa na praia e quisermos colocá-la na agenda, basta colocar um novo elemento `Casa de Praia’ em $contato->{`Carlos Rocha’}->{endereco}.

Ainda usamos uma array no campo `ocupacao’ porque não nos interessa saber mais informações sobre cada ocupação.

Embora o exemplo que estamos usando é o de uma agenda simples de contato, as técnicas vistas aqui podem ser empregadas em estruturas muito mais complexas para diversos tipos de aplicações.

Para finalizar, vamos escrever uma pequena sub-rotina que mostra na tela os contatos.

No próximo artigo abordaremos como armazenar e recuperar esses dados em arquivos.

sub mostra_contatos{
#$contato é o parâmetro passado para a função
my ($contato) = @_;
#Vamos predeclarar cada variável antes de usá-la
my ($nome, $ocupacao, $tipo_endereco, $telefone,');

# O foreach executa um loop para cada item da array à direita
# no caso (keys(%$contato)), gravando o valor atual na variável
# $nome
# Primeiro desreferenciamos $contato para ser tratado como um hash
# e usamos a função keys() para gerar uma lista com todas as chaves
# da hash %$contato
foreach $nome (keys(%$contato)){
print "Nome: $nome
";
print "Ocupação:
";
#agora desreferenciamos a array anônima de ocupação
foreach $ocupacao (@{$contato->{$nome}->{ocupacao}}){
print "	$ocupacao
";
}
print "Aniversário: " . $contato->{$nome}->{aniversario} . "
";
print "Endereços:
";
#Agora para a hash referenciada em endereco
foreach $tipo_endereco (keys(%{$contato->{$nome}->{endereco}})){
print "	$tipo_endereço:
";
print "		Endereço: " . $contato->{$nome}->{endereco}->{$tipo_endereco}->{endereco} . "
";
print "		CEP     : " . $contato->{$nome}->{endereco}->{$tipo_endereco}->{cep} . "
";
print "		Cidade  : " . $contato->{$nome}->{endereco}->{$tipo_endereco}->{cidade} . "
";
}

#Finalmente para os telefones
print "Telefones:
";
foreach $telefone (keys(%{$contato->{$nome}->{telefone}})){
print "	" . $contato->{$nome}->{telefone}->{$telefone} . ": $telefone
";
}

print "Outras Informações:
" . $contato->{$nome}->{outras} ."
";
}
#Agora para separar entre os contatos
print "-"x40;
}