Com o desenvolvimento das facilidades de programação para a Internet, como

PHP, ASP e outras coisas, várias pessoas tem me perguntado: Para que serve
o Perl, afinal? Tenho escutado comentários sobre a obsolescência da
linguagem frente a estas outras, muito mais modernas (será mesmo?).

Talvez seja verdade que para algumas aplicações não seja preciso usar o Perl.
Mas sem dúvida todas as coisas que se faz com outras linguagens poderiam
ser feitas usando Perl, talvez com mais poder, versatilidade e facilidade. No
lado do servidor, códigos incrustados no documento em HTML, tipo PHP ou
ASP podem ser implementados com o módulo do Apache mod_perl. No lado
do cliente, com funções muito parecidas com o javascript o vbscript há o
perlscript, um plugin para navegadores como Netscape e Explorer. E como o
Perl é uma linguagem de uso geral, aplicações para desktop, softwares de
produtividade, gerenciadores de bancos de dados, interfaces gráficas,
programação de sockets, clientes e servidores para Internet, CGI, etc. podem
ser desenvolvidos rapidamente.

Nesta apostila procuramos apresentar o Perl de uma forma bem abrangente,

permitindo uma primeira experiência com o ambiente em suas principais e mais
comuns aplicações. Para um aprofundamento dos conceitos aqui apresentados
podem ser usados os comandos /> man perl Deve ser lido ainda: /> man
perlfaq Para ler a documentação de um módulo: /> perldoc nome−do−modulo

Usos do Perl

Internet
Administração de servidores
Software em geral
Bancos de Dados

Perl (Practical Extraction and Report Language) é um ambiente de

programação de uso geral, de alto nível e fácil aprendizagem, implementável
nas principais plataformas (quase todas as distribuições de UNIX trazem o Perl
como padrão do sistema. As versões para Windows e Mac também são
perfeitas, aproveitando as características destas plataformas). Possui recursos
poderosos para processamento de strings, interação com o sistema
operacional e com a rede, além de facilidades como gerenciamento automático
de memória e casting inteligente e automático de tipos.

Apesar de se apresentar como uma linguagem de scripts, seus executáveis

funcionam compilados em tempo real, sendo rápidos e poderosos. Esta
característica facilita muito o trabalho do programador, pois os programas
podem ser desenvolvidos, modificados e testados muito facilmente e sem a
perda de tempo inerente aos procedimentos de compilação de executáveis.
Outra grande vantagem é o Perl possuir, embutido no compilador, um
depurador de excelente funcionamento.

Estes motivos tornaram o Perl a linguagem preferida para a programação de

aplicações que rodam em servidores da Internet. Os administradores de
sistemas UNIX, em especial, precisam dominar o ambiente, já que muitos
utilitários do sistemas são baseados em Perl ou o usam ostensivamente.
Mas a característica mais importante do Perl é sua condição de "Software
Livre". Os códigos, por definição, sendo uma linguagem de scripts, ficam
"abertos". Desenvolvido inicialmente para implementar um ambiente de
catalogação de erros, os códigos do primeiro Perl foram disponibilizados na
Internet por seu criador, Larry Wall. Uma multidão de programadores (os Perl
Porters) passaram a incorporar melhorias à linguagem, tornando−a completa.

O Perl pode ser obtido em http://www.cpan.org ou http://www.perl.com

Utilize os seguintes comandos para baixa−lo:
/>wget http://www.perl.com
/>cd www.perl.com

Linux

Descompacte o Perl em qualquer diretório, rode o utilitário de configuração,

compile e instale. Os comandos para obter, descompactar e instalar o Perl,
num Linux "bash" seriam:

/>tar xzvf perl.tgz

cd perl
make dep
make install

Instalando módulos com o CPAN.

Um ou dois módulos podem ser facilmente instalados manualmente, mas para

fazer a administração eficiente do sistema perl residente em uma máquina será
preciso usar o módulo CPAN (Comprehensive Perl Archive Network).

O módulo CPAN pode buscar módulos nos "site mirror" do CPAN e

desempacotá−los em um diretório dedicado.
O módulo de CPAN também implementa o conceito de nome ou versão de
módulos empacotados. Pacotes simplificam o gerenciamento e manutenção de
sistemas de módulos relacionados..

Digite na linha de comando:

/> perl −MCPAN −e Shell

Isto carregará o shell do CPAN, permitindo interações. O Modo interativo do

CPAN permite a fácil realização de algumas tarefas:

Para ajuda digite h ou ?.

Procurando os autores, pacotes, distribuição arquivos e módulos: Existe um

comando de uma única letra: ‘a ’, ‘b ’ (de "bundle"), ‘d ’, e ‘m’, para cada uma
das quatro categorias e outro, ‘i ’ para quaisquer destas.
Podem ser usados como argumentos qualquer texto ou expressão regular
(estas entre "/" e "/")

Comitê de Incentivo a Produção do Software Gratuito e Alternativo – CIPSGA

Se desejar ler o arquivo README sobre algum modulo que contenha o texto
"xml", digite: cpan> readme /xml/

make, test, install, clean, módulos ou distribuições

Estes comandos levam qualquer número de argumentos e investigam o que é

necessário para executar a ação. Se o argumento é o nome de um arquivo de
distribuição, este é processado. Se é um módulo, CPAN determina o arquivo
de distribuição no qual este módulo é incluído e o processa. Se existirem
dependências, estas são resolvidas.

Exemplo:

cpan> install OpenGL

OpenGL is up to date.
cpan> force install OpenGL
Running make
OpenGL−0.4/
OpenGL−0.4/COPYRIGHT [...]

Como executar os scripts Perl

Para rodar o script "oi_turma", que está no diretório atual digite no shell:
>perl ./oi_turma

É possível fazer do script Perl um executável. Basta seguir os passos:

1 − Acrescentar o comando abaixo na primeira linha do script:

#!/usr/bin/Perl

Substitua o caminho por outro que indique a localização do executável Perl em

sua plataforma, ou crie um alias para o mesmo para o caminho indicado no
comando acima.

2 − Mude a permissão do script para que possa ser executado pelo usuário
corrente:

>chmod +x ./oi_turma

Opções na linha de comando

Os argumentos passados pela linha de comando que contem só uma letra

podem ser agrupados
Exemplo:
#! /usr/bin/perl −spi.bak
é igual a:
#! /usr/bin/perl −s −p −i.bak

As opções mais comuns são:

−d carrega o depurador Perl

−w o Perl imprimirá em STDERR todos os avisos (sintaxe, variáveis não
inicializadas, etc).
−e executa o próximo argumento (entre aspas).

Um uso muito útil para o perl seria trocar todas as ocorrências de um texto por
outro, em determinados arquivos, salvando um backup destes.

/> perl −p −i.bak −e "s/texto antigo/novo texto/g" *.html

Isto pode ser uma solução fantástica se você precisar consertar um link
quebrado, presente em centenas de arquivos.

Fundamentos da linguagem

O Perl é um ambiente de programação muito poderoso, mas a linguagem é de

fácil aprendizagem. Apresenta características muito parecidas com C, sed,
awk, basic e shell do UNIX.

Suas melhores características estão relacionadas ao tratamento automático da

memória, conversão automática de tipos e à grande facilidade no
processamento de texto.

Entretanto quem não tem experiência em UNIX ou sed, awk e shell poderá
encontrar alguma dificuldade com a assimilação de alguns poderosos recursos.

Notação

O Perl possui um esquema de notação que se aproxima muito do usado em

"C", possuindo ainda diversas características do Basic, awk e sed. A estrutura
de inicialização do programa assume algo muito próximo do Pascal. Com o uso
dos módulos, entretanto, o Perl pode assumir a feição de outras linguagens,
como Tk ou Lisp.

Como em C, no Perl os comandos precisam ser terminados com um ";" (ponto

e vírgula).
Comentários precisam ser precedidos por "#" (sustenido). Exemplo:
# O comando abaixo imprime uma saudação
print "Oi, turma!/n";
Como você pode observar, o texto a ser impresso deve estar envolvido pelas
aspas (simples ou duplas). O caracter de nova linha é representado pelo
escape: "/n".

Não existe necessidade de se manter o comando em uma única linha. O

escape "/n" poderia ser substituído pelo caracter literal de nova linha, dentro
das aspas. O comando abaixo teria efeito idêntico:

Print
" Oi, turma!

"
;

Blocos

Os trechos do programa podem ser dispostos em blocos:

do {
print "Oi, turma!\n";
}
print "Oi, de novo";

Tipos

O Perl define 3 tipos de dados: escalares, arrays e hashs.

Escalares:
Precedidos por um cifrão ($), exemplo: $escalar.

Os escalares podem ser números, strings e referências. O compilador saberá

diferenciar que operação realizar, em cada caso. Na dúvida o valor será
considerado um string, ou este "casting" se processará automaticamente. Da
mesma forma um escalar numério interpolado em um string assumirá o tipo
string Exemplo:

$numero = 5;
print "Digite um numero:"
$input=getc();
$soma = $numero + $input;
$string = "Valores:\n numero digitado: $input\n a somar com:$numero
\nsoma:$soma\n;"

Números
Inteiros, precisão dupla, com ou sem sinal, notação científica, decimal, hexa,
octal, binário.
Strings
Sequências de caracteres. Em sua forma literal devem ser delimitadas por
aspas simples (’) ou duplas ("). Strings delimitadas por aspas duplas podem
conter variáveis interpoladas ou caracteres especiais, usando a barra de
escape. Exemplo:

$variavel= "Cyber";
$aspas_simples = ’Interatividade?\nChame o $variavel.’;
$aspas_duplas = "Interatividade?\nChame o $variavel.";
print $aspas_simples;
print "\n−−−−−−−−−−−−−−−\n";
print $aspas_duplas, "\n";

Isto imprimirá na tela:

Interatividade?\nChame o $variavel.

Interatividade?
Chame o Cyber

Repare que o último comando "print" usa uma vírgula para separar os seus
dois argumentos: o escalar $aspas_duplas e o string literal "\n". Se for preciso,
entretanto, colocar uma aspa simples numa string delimitada por aspas
simples, será necessário usar um escape antes desta (\’).

Referências

O equivalente aos ponteiros. Podem ser referenciados escalares, arrays,

hashs, funções, classes, objetos, etc. Mais à frente nesta apostila este assunto
será tratado om mais profundidade.

Arrays

Precedidos por um arroba (@). Exemplo: @Array

Listas
São coleções de escalares. Listas de literais ou variáveis podem ser
construídas com os elementos separados por vírgulas e envolvidos por
parênteses. Listas podem ser atribuídas a arrays ou a listas de variáveis.
Exemplo:

@Array = (’texto’,$foo,8,"var interpolada: $foo");

Uma lista de literais pode ser atribuida a uma lista de variáveis:
($ouro, $prata, $bronze) = ("dourado", "prateado", "bronzeado");

Podemos atribuir um array a uma lista de variáveis escalares:

@Agora = gmtime;
($dia,$mes,$ano..)=@Agora;
Acessando os elementos do array usando o indice numérico:

print $Agora(0);

Acessando os elementos do array usando o comando "foreach":

foreach $elemento (@Agora){
print $elemento;
}

Atribuindo−se um array a uma variável escalar, estaremos passando o

tamanho do array, um inteiro.

$tamanho=@Agora;
print $tamanho;

Isto imprimirá na tela:

Hashs

São coleções de escalares referenciados por uma chave definida como outro
escalar (string). São precedidos pelo sinal de percentagem (%).

Exemplo: %Hash

Podemos acessar e modificar cada par chave e valor usando as palavras

reservadas key e value ou as outras notações alternativas.

keys %Hash=(fruta,massa,liquido);
values %Hash=("pera", "lazanha", "vinho");

O comando abaixo produziria o mesmo efeito:

%Hash=(
fruta=>pera,
massa=>lazanha,
liquido=>vinho
);
Ou ainda:

%Hash=(fruta,pera,massa,lazanha,liquido,vinho);

Para acessar os dados de um hash precisamos usar a palavra−chave entre

chaves ("{" e "}")

Exemplo:
print $Hash{"fruta");

Este comando imprimirá:

pera/>_

O prompt aparecerá logo após a palavra pera porque não incluimos o caracter
"\n".

Podemos imprimir todo o Hash com os comandos:

foreach $chave (keys %Hash) {

print "$chave : $Hash{$chave}\n";
}

Controle de fluxo

O Perl usa as mesmas palavras reservadas que o C para o controle dos blocos
de programa e algumas proprias, como foreach.
if elsif
:Fim print "Isto também será impresso\n";
Variáveis especiais
O perl usa uma série de variáveis especiais que facilitam e otimizam o código. As mais
importante são $_ e @_ que sempre se referem ao ultimo valor processado.

Exemplo:

$foo="Olha, cara!"; print;

Imprimira o valor de $foo.

Arquivos − leitura e escrita

Handle de arquivo é um container que guarda o arquivo, geralmente em forma de array

Exemplo: abrindo um arquivo para escrita:

open FILE, ">arquivo.txt";

Exemplo: abrindo um arquivo para leitura e atribuindo seu conteúdo a um array:

open FILE, "arquivo.txt";

@file=;

O sinal refere−se ao conteúdo do arquivo cujo handle é FOO. Se for usado <> será
acessado o conteúdo de STDIN
O algoritmo abaixo le as entradas do console, até encontrar um final de arquivo (control
D) acumulando no string foo:

while (<>) {
$foo .=$_;

Para assuntos mais aprofundados sobre abertura e fechamento de arquivos, é bom ler
o tutorial sobre arquivos, usando o man, do GNU/Linux.

/>man perlopentut

Subrotinas

Um bloco de comandos nomeado com o comando "sub" define uma subrotina ou

função. Para executar a subrotina basta preceder seu nome pelo "&";

Exemplo:
# O comando abaixo imprimirá "Oi, Turma!!"
&oiturma;

sub oiturma {
print "Oi, Turma!!\n\n";
}
A subrotina retornara o valor de $_ ou @_, o ultimo a ser alterado, a menos que exista
o comando "return";

print $oi,&oiturma;
sub oiturma {
$oi="Oi, ";
return "Turma!!");
}

Bibliotecas

Podem ser carregadas bibliotecas com o comando "requer". Bibliotecas são arquivos
contendo sub rotinas. O valor de retorno de um script biblioteca precisa ser 1.

Usando o Perl na Internet

Devido às suas características que facilitam o processamento de strings, à

versatilidade e simplicidade da linguagem, a facilidade de manutenção do programa e
sua velocidade de execução, o Perl tornou−se o ambiente preferido para o
desenvolvimento de scripts para a CGI. Em 1996 Steven E. Brenner criou a biblioteca
cgi−lib.pl, que tornou−se uma espécie de padrão no Perl 4. Atualmente, o Perl 5
oferece uma série de módulos que facilitam muito o processamento de html, forms,
email, ftp, newsgrowps, XML WML entre outros.

Cabeçalho do HTTP 1.0

Quando um arquivo é enviado para um cliente Internet (como o Netscape, por exemplo)
pelo servidor, este deve conter um cabeçalho na forma mínima
Content−type: text/plain
Seguido de 2 caracteres de nova linha. Isto indica o typo MIME do documento,
orientando o navegador de como este deve processado

Um exemplo usando o cabeçalho completo seria:

HTTP/1.0 200 OK
Date: Thursday, 28−June−96 11:12:21 GMT
Server: NCSA/1.4.2
Content−type: text/html
Content−length: 2041

Variáveis de ambiente
A CGI usa as variáveis de ambiente na transação de pedido e envio de arquivos para
controlar e processar algoritmos.

Temos acesso a dados do cliente que fez o pedido e a detalhes deste pedido, pode−se
lidar com os protocolos de autorização, "Mime Types", cookies. Não pretendemos aqui
neste trabalho aprofundar o estudo da CGI, apenas pretendemos exemplificar o uso do
Perl.

Para Ter acesso às varáveis do CGI, use o hash %ENV:

#!/usr/bin/Perl

print "Content−type: text/plain\n\n";

foreach $var (keys %ENV) {
print “<p>$var: $ENV{$var}\n";
}

Este programa gerou na tela no meu navegador da Internet:

SERVER_SOFTWARE: Apache/1.2.4
GATEWAY_INTERFACE: CGI/1.1
DOCUMENT_ROOT: /home/httpd/html/gallerie/html/
 Lendo um <form>

Podemos chamar um script Perl de dentro de uma página HTML que contém um
O meu Apache está configurado para rodar scripts no diretório /cgi−bin/ que aponta
para o diretório real, na máquina: /home/httpd/cgi−bin/

O Formulário teria a forma:

O script abaixo deve ser salvo no diretório /home/httpd/cgi−bin/ e deve Ter permissão
para executar:
/> chmod 744 ./getenv

Note que foi usada a biblioteca cgi−lib.pl e sua rotina &ReadParse, que coloca a string
"Query" (aqui escondida pelo método post) no array @in:

#!/usr/bin/perl
# getenv
require "cgi−lib.pl";
&ReadParse;

print "Content−type: text/plain\n\n";

print "Variaveis:\n";
foreach $vari(@in){
print "$vari\n";
}

foreach $var (keys %ENV)

{ print "<p>$var: $ENV{$var}\n; }

Gerando a tela:
Módulo CGI
Poderíamos escrever o mesmo programa com o módulo CGI, gerando a saída em html.
Para um aprofundamento na questão digite:

/>perldoc CGI
Abaixo o novo script getenv:
#!/usr/bin/perl
# getenv
use CGI;
$tela=CGI::new();
print (
$tela−>header,
$tela−>start_html ( −title=>"Variaveis de Ambiente"),
$tela−>p("Variaveis:");
$tela−>dump
);
foreach $var (keys %ENV) {
print "<p>$var: $ENV{$var}\n";
}
print $tela−>end_html;

o arquivo de retorno em meu navegador foi:

O módulo CGI facilita muito a formatação da página, leitura e processamento de
cookies, escrita de tabelas, forms, etc.

Administrando bancos de dados

Módulo DB_File O módulo DB_File e a distribuição Berkeley DB em geral está presente

nos sistemas GNU/Linux, mas pode ser obtida em http://www. sleepycat.com/

Podemos ligar um arquivo com dados do tipo nome:valor a um arquivo Hash. Bancos
de dados simples podem ser desenvolvidos desta forma
Devemos usar o comando "tie" para fazer a ligação. Exemplo:

#!/usr/bin/Perl
# telefones
use DB_File;
$caderno= tie %TEL, "DB_File", "/home/ricardo/telefones.txt";
while (TRUE){ # criando um loop:

# Menu
system("clear");
print "−−−−−−−−−−−−−− Agenda de Telefones −−−−−−−−−−−−−−−−\n";
$lido=&Digitado("Entre com o comando: [A] Incluir [M] Mostrar Lista [S] Sair:", c);
if ($lido eq "A"){&Incluir;}
elsif ($lido eq "M"){&Mostrar;}
elsif ($lido eq "S"){&Sair;} } # fechando o loop
sub Digitado {
my $xx, $tx;
$tx="";
print $_[0], "\n";
while ($lendo ne 1){$xx=getc; if ($xx eq "\n"){$lendo=1;}else{$tx.=$xx;} }
$lendo=0;
print "−−−−−−−−−−−−−−−−−−−−−−−−−−> Foi lido: $tx\n";
return $tx;}

sub Incluir {
$nome=&Digitado ("Nome a incluir: ");
$tel=&Digitado("Telefone: ");
$caderno−>put($nome, $tel);}
sub Mostrar {
foreach $nome(keys %TEL){
print "Nome: $nome\n";
print "Telefone: $TEL{$nome}\n−−−−−−−−−−−−\n";}
&Digitado("Tecle enter para continuar");
}
sub Sair {exit(0);}

Para maiores detalhes sobre o módulo, digite:

/>perldoc DB_File

Bancos de dados mais complexos devem usar o módulo DBI, que servirá de interface
com servidores SQL, como mSQL, MySQL, Oracle, postgres, etc.

Interface gráfica

Módulo perlTk Pré−requisito: Tk 4.0 ou superior instalado. O Nosso objetivo aqui é

apenas apresentar o Perl/Tk. Estudos mais aprofundados dos comandos do Tk podem
ser feitos digitando:

/>perldoc Tk

O Perl/Tk é usado para criar uma interface gráfica para os programas em Perl. Com
este módulo torna−se muito fácil a criação de janelas, botões, scrolls, canvas, caixas
de texto, etc.
Olha o programa "oiturma" com uma interface gráfica:
#/usr/bin/Perl
use Tk;
$janela=MainWindow−>new;
$janela−>Button(
−text=>"Oi, Turma!!",
−command=>sub{exit})−>pack;
MainLoop;
Aqui é importante lembrar que a interface só será desenhada na tela depois do
comando "MainLoop". O método "pack" é responsável pela formatação e
posicionamento dos dispositivos na janela. Existem ainda mais dois gerenciadores de
geometria: grid e place.

A chamada de programa quando o botão é clicado pode usar uma referência:

Exemplo:
#/usr/bin/Perl
use Tk;
$janela=MainWindow−>new;
$janela−>Button(
−text=>"Oi, Turma!!",
−command=>\&Sair)−>pack;
MainLoop;
sub Sair {
exit;
}