Perl

Sumário
I Sobre essa Apostila 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 Quantiﬁcadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.4 Alternância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
1

CDTC Centro de Difusã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

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 oﬁcial).
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

Parte II
Informações Básicas
5

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

É dada permissão para copiar, distribuir e/ou modiﬁcar 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 reﬂete 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

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

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

Parte III
GNU Free Documentation License
10

(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

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

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

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

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

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

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

tal como a GNU General Public License, para permitir o seu uso em software livre.
18

Capítulo 1
Introdução
1.1 Informações Bá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, eﬁciente 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
Qualiﬁcar programadores na linguagem de programação Perl.
20

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

• 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

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

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

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

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

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

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

uma lista em contexto escalar, ﬁcamos 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
(modiﬁcar 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

Se chamamos o shift sem um argumento, ele utiliza o @_ por padrão. Neste exemplo é
possível (e comum) omitir o argumento.
30

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

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

}
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

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

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

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

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

{ 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

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

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

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

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

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

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 veriﬁcando 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

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

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 undeﬁned (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 suﬁciente, mas no caso
de envolver um hash muito grande, seria melhor passar o hash por referência.
46

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

}
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

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

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

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 ﬂecha ’ - ’:
my $name = $person-name;
51

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 ﬂecha. 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

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

Perl

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (17)

Destaque

Destaque (14)

Semelhante a Perl

Semelhante a Perl (20)

Mais de Tiago

Mais de Tiago (20)

Último

Último (20)

Perl