Pegando leve, vamos ver um exemplo:

use strict;
use warnings;
my %hash = {
  cachorro => 'mamífero',
  golfinho => 'mamífero',
  tartaruga => 'réptil',
  galinha => 'galináceo'
}

E é claro que isso vai dar um erro grotesco:

Reference found where even-sized list expected at hasht.pl line 5.  (WTF!??)

Pra resolver a questão de vez, adicione o pacote diagnostics, ficando assim:

use warnings;
use strict;
use diagnostics;
my %hash = {
  cachorro => 'mamífero',
  golfinho => 'mamífero',
  tartaruga => 'réptil',
  galinha => 'galináceo'
}

Magicamente, o Perl praticamente nos dá uma aula junto com o erro:

Reference found where even-sized list expected at hasht.pl line 5 (#1)
(W misc) You gave a single reference where Perl was expecting a list
with an even number of elements (for assignment to a hash). This
usually means that you used the anon hash constructor when you meant
to use parens. In any case, a hash requires key/value pairs.

%hash = { one => 1, two => 2, };        # WRONG
%hash = [ qw/ an anon array / ];        # WRONG
%hash = ( one => 1, two => 2, );        # right
%hash = qw( one 1 two 2 );              # also fine

Ou seja, era só trocar as chaves por parênteses. Agora ficou mole, ou pelo menos bem mais fácil de entender as mensagens esquisitas dessa linguagem fabulosa!

Um array é criado ao utilizar o arroba:
@array = ( ‘um’, ‘dois’, ‘tres’ );

Um hash é criado ao utilizar a porcentagem:
%hash = ( ‘nome’ => ‘Kate’ , ‘idade’ => ’26′ );

Observe que ambos são definidos entre parênteses. A diferença fica no contexto.

Para acessar o conteúdo de um dos dois, utiliza-se o contexto scalar (utilizando a variável com cifrão).

Para acessar itens de um array, o índice é passado entre [colchetes]:
print $array[2];

Para acessar o conteúdo de um hash, o índice é passado entre {chaves}:
print $hash{nome};

Você define o array com @arroba e o hash com %porcentagem, mas ao acessar, o $cifrão deve ser utilizado.

As referências são diferentes.

Referência de array é um scalar que aponta para um array. Uma ferência de array é definida entre colchetes:
$arrayref = [ 'um' , 'dois', 'tres' ];

Referência de hash também é um scalar que aponta para um hash, definido entre chaves:
$hashref = { ‘nome’ => ‘Kate’, ‘idade’ => 26 };

Para acessar os valores, você utiliza sempre ->, seguido de colchetes para array ou chaves para hash:
$arrayref->[2];
$hashref->{nome};

Basta lembrar:

@ é array
% é hash
( ) ao definir utilizando @ ou %
$ sempre para acessar
[ ] é referência de array
{ } é referência de hash
ao acessar referências, sempre use -> antes de [] ou {}

Super simples

Quem puder contribuir…
Fará com que o Perl se torne mais acessível no Brasil.

segue o link: http://www.perl.org.br/Perldoc/WebTranslation

Acompanhem!
http://perladvent.pm.org/2008/

———- Forwarded message ———-
From: breno
Date: 2008/12/4
Subject: [Rio-pm] Calendários do Advento Natalino!
To: Perl Mongers Rio de Janeiro

O calendário Perl do advento natalino é uma tradição na comunidade desde o ano 2000. A idéia é apresentar um módulo bacana (para qualquer definição de “bacana”) do CPAN em cada dia de dezembro que antecede o Natal.

O desse ano já está no ar!

http://perladvent.pm.org/2008/

O dia 1 fala do ToolSet, um módulo que agrega todos os seus módulos mais usados em um único import, evitando assim o “ctrl-c/ctrl-v”.

Dia 2 fala de um módulo que eu particularmente acho o maior barato, o Math::Prime::TiedArray, que cria um array virtual com todos os números primos.Todos?! Todos. Afinal, é um array virtual, ele computa o número primo que ocupa a posição desejada conforme a demanda

Fiquem atentos ao site oficial do calendário! Quem tiver curiosidade é só olhar o histórico para os outros anos, e se vc acha que seu [insira módulo xodó aqui] está sendo injustiçado por não ter sido apresentado
até hoje, escreva para eles! O pessoal do calendário está sempre atrás de idéias (e escritores!!!!!)

Finalmente, mas não menos importante, já saiu também o calendário Catalyst do advento natalino, que desde 2005 complementa o calendário do Perl com dicas e módulos específicos para o Catalyst!

http://www.catalystframework.org/calendar/2008/

O dia 1 apresenta as estatísticas da pesquisa de Catalyst (que circulou inclusive pela lista, infelizmente apenas 2 brasileiros responderam).

Dia 2 mostra as diferentes formas de se implantar o Catalyst em servidores Web (servidor built-in, mod_perl, fastcgi, etc)

O dia 3 apresenta um módulo bonitão que já mencionei por aqui, o Chart::Clicker, e como usá-lo junto com o Catalyst para exibir páginas com gráficos informativos.

Como sempre, é possível ver calendários de anos anteriores, e eles também adoram voluntários!

[]s, e boas festas

-b
_______________________________________________
Rio-pm mailing list
Rio-pm@pm.org
http://mail.pm.org/mailman/listinfo/rio-pm

Comecemos pela instalação:

O uso é semelhante a qualquer biblioteca de templates, como o Smarty no PHP. Preparamos as variáveis que serão disponibilizadas e em seguida processamos determinado arquivo.

O script fica assim:

E o template:

Quem já está acostumado a utilizar templates vai precisar apenas se adaptar à sintaxe do Template Toolkit.

Em relação ao script, o trecho my $directory = (fileparse $r->filename)[1]; é uma peculiaridade do mod_perl. O diretório atual do processo não é o diretório do script, aqui ficou como sendo a raiz do sistema. Então se tentássemos carregar o template templates/musica.tt2 ele não encontraria o arquivo.

A função fileparse do módulo File::Basename retorna uma lista com o nome do arquivo, diretório e sufixo, respectivamente. Da forma como foi utilizada, o diretório do arquivo que está sendo processado é atribuído à variável $directory. Essa variável então é utilizada como base para o caminho absoluto do diretório dos templates que é passado como configuração para o Template Toolkit.

Também é importante verificar se o template foi processado corretamente. Se não houvesse a linha || die $template->error(); e o processamento do template desse erro, a função process apenas retornaria 0, sem mostrar nada na tela. Utilizando o die como demonstrado, qualquer problema vai mostrar Internal Server Error no browser e detalhes do erro no error.log do Apache.

Recomendo a leitura

• Syntax
• Directives: PRE_PROCESS, POST_PROCESS
• Filters: html
• Views

%idade = ();  # Cria uma hashing vazio.
%idade = ('jabuti', 80, 'rato', 3, 'cobra', 6);
# Outra maneira de fazer o mesmo acima.
%idade = (tuatara => 35, cachorro => 12, harpia => 40);
%idade{elefante} = 70;

Usando o operador => não é necessário usar aspas, no item a direita

Para acessar os dados de um hashing devemos usar o { e } para indicar o índice e $ precedendo a variável.

$idade_animal = $idade{jabuti};

Podemos acessar os índices dos hashings usando a função key.

# @animais agora é ('harpia', 'tuatara', 'cobra', 'elefante', 'rato', 'cachorro', 'jabuti').
@animais = keys %idade;

Há uma função parecida para os valores.

# @tempo_vida agora é (40, 35, 6, 70, 3, 12, 80).
@tempo_vida = values %idade;

Each retorna uma lista de dois elementos, contendo uma chave do hashing junto com o seu valor associado. Chamadas subsequentes  para each retornarão outro par de chave/valor até que todos os pares tenha sido retornados, nesse ponto, um array vazio será retornado.

while ( ($nome, $vida) = each %idade) ) {
print "$nome vive $vida anos\n";
}

Para saber o tamanho de um hashing basta atribuir a um scalar usando a função keys.

# o valor de $quantidade_animais é 3.
$quantidade_animais = keys %idade;

Para acessar partes de um hashing usa se a sintaxe abaixo:

# Mostra a idade da tartaruga.
$mais_velho = {'tartaruga'};

Da mesma forma que é possível dar valores a um hashing, usando uma lista é possível usar a função map para tranformar uma lista num hashing. Por exemplo, o código a seguinte cria uma hashing em que a as chaves são números e os valores seus quadrados.

%quadrado = map { $_ => ($_ * $_) } @numeros;

Segue abaixo um programa que mostra o funcionamento da variável hashing:

No Debian, o Mysql já instala o driver de conexão do Perl automaticamente, mas se não estivesse instalado, para pegar os pacotes da distribuição seria:

A interface para utilização é bem simples:

A diferença pra quem está vindo do PHP é que primeiro preparamos a query com o método prepare no objeto da conexão. O método retorna um objeto DBI::st que representa o statement, e então executamos a query com execute.

O legal na verdade é quando utilizamos parâmetros. Preparamos a query com placeholders e passamos os parâmetros pro execute.

Além de evitar preocupação com escapar os dados, queries que serão executadas mais de uma vez com parâmetros diferentes são preparadas uma única vez, com ganhos de performance consideráveis em alguns SGBDs.

E é isso. Post rápido só pra dar base pra alguma aplicação que a gente queira testar mais pra frente.

Veja a documentação da API pra detalhes interessantes:
http://search.cpan.org/~timb/DBI-1.607/DBI.pm

Inicialmente devemos criar um arquivo com a extensão .pl
Nas primeira linha devemos colocar a instrução abaixo:
#!/usr/bin/perl

Esta instrução é o caminho do interpretador do Perl.

para executar devemos usar a instrução abaixo:
$ perl exec1.pl

ou

$ ./exec1.pl

já que mencionamos o interpretador na primeira linha, lembrado de dar permissão para execução.

Seguem algumas instruções de linha de comando úteis

-w -> Solicita à Perl para avisar se há pratica de programação perigosa, pode ser usado “use warnings;”, mas só seŕa avisado dentro do contexto.
-T -> Ativa o modo “taint” da Perl. Neste modo toda entra de uma fonte externa é colocada em dúvida por padrão.
-c -> Verfica os erros de sintaxe de um script sem executar.
-d -> Executa o script usando um depurador imbutido da Perl.
-e -> Esta opção é usada quando define se que uma string seja o código a sere executado.

Scalar

Uma variável de scalar mantém apenas um único item dos dados.
Toda variável de scalar é precedida de $.

$texto = 'Ola mundo!';
$contador = 100;
$contador = 'Cem';


Em Perl a mesma variável pode conter texto e números a Perl se encarrega de converter conforme o contexto.

Questão das aspas.
Se uma string está entre aspas duplas  e contém nomes de variáveis, então essas variáveis são  substituidas por seus  valores no final da string.
Se a string está entre apóstrofes, então a subistituição da variável não ocorrerá.
É importante ressaltar que usando aspas duplas é possível usar os caracteres de especiais, como o \n \t entre outros.

O exemplo abaixo exemplifica o uso da aspas.

Array

Um array contém uma lista de valores scalars ordenados
Um array é precedido de @

@vazio = ();
@mamiferos = ('macaco', 'elefante', 'urso');
@repteis = ('jacaré', 'tartaruga', 'lagarto');
@animais = (@mamiferos, @repteis); # Obtém um array de de seis elementos.
($carnivoro, $hebivoro, $onivoro) = @repteis;


Para acessar os elementos do array dever ser usada a sintaxe abaixo:

$array[0]

Esta sintaxe pode ser usada para estabelecer e atribuir valor para um scalar.

$paquiderme = $mamiferos[1]; # valor é elefante

Quanto trabalhamos com o valor individual de array usamos o prefixo de um scalar $.

É possível acessar os últimos valores de um array usando o índice negativo.

$maritimo = $repteis[-2]; # valor é tartaruga

Para obter o tamanho de um array basta atribuir o array a um scalar.

$qtde = @animais; # valor retornado é 6

Há uma sutil diferença entre uma lista de um array

$contador = @repteis; # O conteúdo de $contador é 3
$ultimo = ('macaco', 'usro'); # O conteúdo de $ultimo é 'urso'

Algumas funções para manipulação de arrays

• push – Acrescenta os elementos da lista ao final do array. (push ARRAY, LIST)
• pop – Remove e retorna o último elementos do array. (pop ARRAY)
• shift – Remove e retorna o primeiro elemento do array. (shift ARRAY)
• unshift – Acrescenta os elementos da lista na frente do array. (unshift ARRAY, LIST)
• splice – Remove e retorna os elementos LENGTH do ARRAY que começa no elemento OFFSET e os substitui pelos elementos da LIST. Se LIST for omitida então os elementos removidos serão simplesmente apagados. se LENGTH for omitido então tudo desde OFFSET até o final do ARRAY será removido. (splice ARRAY, OFFSET, LENGTH, LIST)

Map e Grep são outras listas bastante úteis de processamento de funções.

• map – Executa o código e monta a lista com os valores de retorno sem avaliar se é verdadeiro
• grep – Executa o código e monta a lista com os valores avaliando se o código retornado é verdadeiro.

Criando uma lista de quandrados

@numeros = (1..10);
@quadrados = map { $_ * $_ } @numeros;

Cria uma lista do os valores impares

@impares = grep { $_ % 2 } @numeros;

Abaixo segue um código que mostra o uso de arrays:

O primeiro script de teste ficou assim:

use strict;
use warnings;
 
my $r = shift;
 
$r->content_type('text/html');
 
print '<h1>Funcionou!</h1>';

O script é executado pelo modperl como se fosse uma função e recebe como parâmetro um objeto do tipo Apache2::RequestRec. Quando fazemos o shift, este parâmetro passa para a variável local $r.

Para ter acesso aos dados submetidos por GET ou POST de forma legível, precisamos instanciar um objeto Apache2::Request, que recebe no construtor o RequestRec da requisição atual:

use strict;
use warnings;
 
use Apache2::Request;
 
my $r = shift;
my $req = Apache2::Request->new($r);
 
$r->content_type('text/html');
 
print '<h1>Funcionou!</h1>';

Os parâmetros passados, tanto por GET quanto por POST, estão disponíveis pelo accessor param:

use strict;
use warnings;
 
use Apache2::Request;
 
my $r = shift;
my $req = Apache2::Request->new($r);
 
$r->content_type('text/html');
 
print '<h1>Funcionou!</h1>';
 
print $req->param('variavel_por_get');
print $req->param('variavel_por_post');

Caso o nome da variável não seja passado para o accessor, ele retorna um array que pode ser iterado, como neste caso:

use strict;
use warnings;
 
use Apache2::Request;
 
my $r = shift;
my $req = Apache2::Request->new($r);
 
$r->content_type('text/html');
 
foreach my $param ( $req->param ) {
    print "$param: ", $req->param($param), "<br />";
}

Além do accessor param, os dados do POST também estão no accessor body. Para acessar uma variável exclusivamente submetida por POST fica assim:

use strict;
use warnings;
 
use Apache2::Request;
 
my $r = shift;
my $req = Apache2::Request->new($r);
 
$r->content_type('text/html');
 
print '<h1>Funcionou!</h1>';
 
print $req->body('somente_variavel_por_post');

Assim como no param, também é possível ter um array com o nome dos parâmetros passados por POST ao acessar o body sem nenhum argumento.

E é isso.

Referências:

• Apache2::Request
• Apache2::RequestRec

Os argumentos de funções chegam no array @_. Dentro da função você precisa pegar os argumentos dessa lista e fazer as validações necessárias.

Exemplo:
sub escrever_dados {
    my ($nome, $cidade) = @_;
    print "Nome: $nome, cidade: $cidade\n";
}
 
escrever_dados('Mary', 'Rio de Janeiro');

A função nesse caso recebe uma lista e os seus elementos são passados para as variáveis locais.

O que mais me incomoda é que parâmetros a mais ou a menos na chamada à função não resultam em erro algum. O que pode ser feito é validar dentro da função a quantidade e tipo dos parâmetros, mas torna o código extremamente repetitivo e mais sujeito a erros.
sub escrever_dados {
    if (scalar @_ != 2) {
        print "Função espera 2 argumentos\n";
        return 0;
    }
    my ($nome, $cidade) = @_;
    print "Nome: $nome, cidade: $cidade\n";
}
 
escrever_dados('Mary', 'Rio de Janeiro', 'Vai dar erro');
escrever_dados('Também vai dar erro');
escrever_dados(); # Lista vazia (scalar 0) também dá erro

A não ser que alguém conheça uma forma melhor. Alguém? Alguém?

Como o @_ é uma lista normal, qualquer forma de acesso é válida:
sub saudacao {
    my $nome = shift;
    print "Oi, $nome!\n";
}
 
saudacao('Mundo');
sub erro {
    die "Erro inesperado $_[0]\n";
}
 
erro('Valor inválido!');

Mas ainda acho que associar as variáveis na forma my ($nome, $cidade) = @_; fica mais claro. Exceto quando estamos trabalhando com objetos, aí acho mais claro fazer my $self = shift; antes. Mas aí já é outra história.

Divirta-se.