Perl Brasil

Pesquisar

Documentação

Artigos

Planeta

Eventos

Comunidade

r10 - 28 Sep 2008 - MarcoLima

NOME

perlintro -- uma breve introdução ao Perl

voltar para o topo

DESCRIÇÃO

Este documento tem por intenção dar a você uma breve introdução à linguagem de programação Perl, com referências para documentações mais aprofundadas. É um guia inicial para aqueles que são novos na linguagem, e provê apenas informações para que você esteja apto a ler códigos escritos em Perl por outras pessoas e entender o que este faz, ou ainda escrever seus próprios programas iniciais. Este documento introdutório não tem por objetivo ser completo, e também não deseja ser totalmente correto. Em alguns casos, a perfeição foi sacrificada para que o objetivo de transparecer uma idéia seja alcançado. Você está avisado a seguir esta introdução com mais informações do manual encontradas no manual completo do Perl, cujo índice pode ser encontrado em the perltoc manpage. Neste documento, você encontrará referências para outras partes da documentação de Perl. Você pode ler esta documentação utilizando o comando perldoc ou o mesmo método que você está utilizando para ler este documento.

O que é o Perl?

O Perl é uma linguagem de programação de uso geral, originalmente desenvolvida para manipulação de textos, que agora é utilizada para uma infinidade de tarefas incluindo administração de sistemas, desenvolvimento web, programação de redes, desenvolvimento de interfaces gráficas, e muitos outros. A linguagem foi escrita para ser prática (fácil de utilizar, eficiente, completa) ao invés de bonita (pequena, elegante, mínima). Suas maiores características são sua facilidade de uso, que inclui o suporte tanto para programação procedural quanto para programação orientada à objetos, tem um poderoso suporte incluso na linguagem para processamento de textos, e uma das maiores coleções de módulos escritos por terceiros, o CPAN. Outras definições do Perl são dadas em the perl manpage, the perlfaq1 manpage e sem dúvida em outros lugares. A partir destas informações, podemos determinar que Perl é uma coisa diferente para cada pessoa, mas muitas pessoas pensam que é, no mínimo interessante, escrever sobre ela.

Executando programas Perl

Para executar um programa Perl, a partir da linha de comando do Unix: 
    perl meuprograma.pl
Um método alternativo é colocar isto como a primeira linha do seu script: 
    #!/usr/bin/env perl
... e então executar seu script como /caminho/do/script.pl. O script deverá ser marcado como executável antes, então execute chmod 755 script.pl antes (no Unix). Para mais informações, incluíndo instruções para outras plataformas como Windows e Mac OS, leia the perlrun manpage.

Visão básica da sintaxe

Um programa ou script Perl consiste em um ou mais comandos. Cada comando é simplesmente escrito no script, um após o outro. Não há necessidade de existir uma função main() ou algo do tipo. Os comandos Perl são finalizados com um ponto-e-vírgula: 
    print "Alo, mundo";
Os comentários inicializam com um sustenido (#): 
    # Isso e' um comentario
Espaços em branco são irrelevantes: 
    print
        "Alo, mundo"
        ;
... exceto dentro de strings com aspas: 
    # isto deve imprimir o texto com uma quebra de linha no meio
    print "Alo
    mundo";
Aspas duplas ou aspas simples podem ser utilizadas em torno de strings: 
    print "Alo, mundo";
    print 'Alo, mundo';
Entretanto, apenas aquelas strings com aspas duplas podem ``interpolar'' variáveis e caracteres especiais como nova-linha (\n): 
    print "Alo, $nome\n";     # funciona!
    print 'Alo, $nome\n';     # exibe $nome\n literalmente
Números não necessitam de aspas: 
    print 42;
Você pode utilizar parênteses para argumentos de funções ou omití-los de acordo com seu gosto. Elas são necessárias apenas para deixar claro a precedência das operações. 
    print("Alo, mundo\n");
    print "Alo, mundo\n";
Informações mais detalhadas sobre a sintaxe do Perl pode ser encontrada em the perlsyn manpage.

Tipos de variáveis em Perl

Perl tem três variáveis principais: scalars, arrays e hashes.

Scalars

Uma variável scalar representa um único valor: 
    my $animal = "camelo";
    my $resposta = 42;
Valores de variáveis scalar podem ser strings, inteiros ou números com ponto flutuante. O Perl irá converter entre os tipos de acordo com a necessidade. Não é necessário pré-declarar os tipos de suas variáveis. Variáveis scalar podem ser utilizados de diversos modos: 
    print $animal;
    print "O animal e' $animal\n";
    print "O quadrado de $resposta e' ", $resposta * $resposta, "\n";
Existem algumas variáveis scalar ``mágicas'' com nomes que se parecem com pontuação ou lixo. Estas variáveis especiais são utilizadas para todos os tipos de propósitos, e estão documentadas em the perlvar manpage. A única que você precisará conhecer agora é $_, que é a ``variável padrão''. Ela é utilizada como o argumento padrão para um grande número de funções no Perl, e é atribuída implicitamente em algumas construções de iteração. 
    print;          # exibe o conteudo de $_ por padrao

Arrays

Um array representa uma lista de valores: 
    my @animais = ("camelo", "lhama", "coruja");
    my @numeros = (23, 42, 69);
    my @misturados   = ("camelo", 42, 1.23);
O índice inicial de uma variável array é zero (0). Esta é a maneira que você extrai elementos de um array: 
    print $animais[0];              # exibe "camelo"
    print $animais[1];              # exibe "lhama"
A variável especial $#array informa o índice do último elemento de um array: 
    print $misturados[$#misturados];       # último elemento, exibe 1.23
Você pode pensar em usar $#array + 1 para informar quantos items existem em um array. Não se incomode com isso. Utilizando @array onde Perl espera encontrar um valor scalar (``em um contexto escalar''), ele irá devolver o número de elementos do array: 
    if (@animais < 5) { ... }
Os elementos que estamos extraindo do array começam com um $ porque você está extraindo um único valor do array -- você pede um valor scalar, você recebe um valor scalar. Para extrair diversos valores de uma variável array: 
    @animais[0,1];                         # devolverá ("camel", "llama");
    @animais[0..2];                        # devolverá ("camel", "llama", "owl");
    @animais[1..$#animais];         # devolverá todos exceto o primeiro elemento
Isto é chamado de ``array slice''. Você pode fazer diversas coisas úteis com listas: 
    my @ordenados    = sort @animais;
    my @invertidos = reverse @numeros;
Existem diversos arrays especiais também, como @ARGV (os argumentos de linha de comando que foram passados para o seu script) e @_ (os argumentos passados para um subrotina). Estas variáveis estão documentadas em the perlvar manpage.

Hashes

Um hash representa uma coleção de pares de chave/valor: 
    my %cores_de_frutas = ("morango", "vermelho", "banana", "amarelo");
Você pode utilizar um espaço em branco e o operador => para uma leitura mais agradável: 
    my %cores_de_frutas = (
        morango  => "vermelho",
        banana => "amarelo",
    );
Para obter um elemento de um hash: 
    $cores_de_frutas{"morango"};           # retorna "vermelho"
Você pode obter a lista de chaves ou lista de valores com as funções keys() e values(). 
    my @frutas = keys %cores_de_frutas;
    my @cores = values %cores_de_frutas;
As variáveis hash não tem uma ordem interna particular, porém você pode ordenar as chaves (utilizando a função sort()) e iterar entre elas. Como as variáveis especiais scalar e array, existem também variáveis especiais hash. A mais conhecida delas é a variável %ENV, que contém as variáveis de ambiente. Leia tudo sobre elas (e outras variáveis especiais) em the perlvar manpage. Variáveis scalar, array e hash são documentadas mais detalhadamente em the perldata manpage. Tipos de dados mais complexos podem ser construídas utilizando referências, que permitem você construir listas e hashes dentro de listas e hashes. Uma referência é um valor scalar e pode referir-se a qualquer outro tipo de dados do Perl. Armazenando uma referência como o valor de um array ou um elemento de um hash, você pode facilmente criar listas e hashes dentro de listas e hashes. O seguinte exemplo mostra uma estrutura de hash de hash de 2 níveis utilizando referências anônimas para hash. 
    my $variaveis = {
        scalar  =>  {
                     descricao => "item unico",
                     simbolo => '$',
                    },
        array   =>  {
                     descricao => "lista ordenada de itens",
                     simbolo => '@',
                    },
        hash    =>  {
                     descricao => "pares chave/valor",
                     simbolo => '%',
                    },
    };
    print "Scalars comecam com um $variaveis->{'scalar'}->{'simbolo'}\n";
Maiores informações neste tópico de referências podem ser encontradas em the perlreftut manpage, the perllol manpage, the perlref manpage e the perldsc manpage.

Escopo de variáveis

Apesar de todos os exemplos na seção anterior utilizarem a sintaxe:tax: 
    my $var = "valor";
O comando my não é requerido; você pode utilizar apenas: 
    $var = "valor";
Entretanto, a utilização acima irá criar variáveis globais em todo o seu programa, o que é uma má prática de programação. my cria uma variável em um escopo léxico, ao invés do escopo global. Estas variáveis são escopadas no bloco (isto é, diversos comandos envoltos por chaves { }) em que foram definidas. 
    my $a = "foo";
    if ($alguma_condicao) {
        my $b = "bar";
        print $a;           # exibe "foo"
        print $b;           # exibe "bar"
    }
    print $a;               # exibe "foo"
    print $b;               # nao exibe nada; $b saiu de escopo.
Utilizando my em conjunto com use strict; no início de seus scripts Perl, significa que o interpretador irá avisar certos erros de programação mais comuns. No exemplo acima, o último print $b irá causar um erro em tempo de compilação e prevenir você de executar o programa. A utilização de strict é muito recomendada.

Construções condicionais e de iteração

Perl possui a maioria de construções condicionais e de iteração, exceto pela construção case/switch (caso você realmente a queira, existe o módulo Switch no Perl 5.8 e mais atual, e no CPAN. Veja a seção de módulos abaixo para obter mais informações sobre módulos e CPAN). As condições podem ser qualquer expressão Perl. Veja uma lista de operadores na próxima sessão, para informações sobre comparações e operadores lógicos booleanos, que geralmente são utilizados em comandos condicionais.

if
    if ( condição ) {
        ...
    } elsif ( outra condição ) {
        ...
    } else {
        ...
    }
Existe também a versão de negação de if: 
    unless ( condição ) {
        ...
    }
Esta construção é utilizada como uma forma de leitura mais fácil de if(condição).
Note que as chaves são necessárias em Perl, mesmo que você tenha apenas uma linha no bloco. Entretanto, existe uma maneira de fazer seus blocos condicionais de uma linha parecerem mais naturais: 
    # o modo tradicional
    if ($zippy) {
        print "Yow!";
    }
    # o modo Perl, utilizando a condição após o comando
    print "Yow!" if $zippy;
    print "Nao temos bananas" unless $bananas;

while
    while ( condição ) {
        ...
    }
Há também a versão de negação do while, pela mesma razão que temos o unless: 
    until ( condição ) {
        ...
    }
Você também pode utilizar o while como uma pós-condição: 
    print "LA LA LA\n" while 1;          # repete para sempre

for
Exatamente como C: 
    for ($i=0; $i <= $max; $i++) {
        ...
    }
O estilo de iteração for do C dificilmente é necessária no Perl, pois este provê um modo mais amigavel de iterar listas, com o comando foreach.

foreach
    foreach (@array) {
        print "Esse elemento e' $_\n";
    }
    # não é necessário utilizar a variável padrão $_
    foreach my $chave (keys %hash) {
        print "O valor de $chave e' $hash{$chave}\n";
    }
Para maiores detalhes em construções de iteração (e algumas que não foram mencionadas aqui) veja the perlsyn manpage.

Operadores e funções embutidas

O Perl vêm com uma grande seleção de funções embutidas. Algumas daquelas que nós já vimos incluem print, sort e reverse. Uma lista delas é informada no início de the perlfunc manpage e você pode facilmente obter mais infomações sobre qualquer função utilizando perldoc -f função. Operadores do Perl são documentados em detalhes em the perlop manpage, porém aqui estão alguns dos mais comuns:

Aritiméticos
    +   adição
    -   subtração
    *   multiplicação
    /   divisão

Comparação numérica
    ==  igualdade
    !=  desigualdade
    <   menor que
    >   maior que
    <=  menor ou igual a
    >=  maior ou igual a

Comparação de strings
    eq  igualdade
    ne  desigualdade
    lt  menor que
    gt  maior que
    le  menor ou igual a
    ge  maior ou igual a
(Por quê separamos comparações numéricas e de string? Por que nós não temos tipos especiais de variáveis, e o Perl necessita saber quando ordenar numericamente (onde 99 é menor que 100) ou alfabeticamente (onde 100 vêm antes de 99)).

Lógica booleana
    &&  and (e)
    ||  or     (ou)
    !   not    (não)
(and, or e not não estão na tabela acima como descrição dos operadores -- eles também são operadores. São mais fáceis de ler do que operadores do estilo de C, porém possuem precedências diferentes de && e amigos. Verifique perlop para maiores detalhes.)

Diversos
    =   atribuição
    .   concatenação de string
    x   multiplicação de string
    ..  operador de intervalo (cria uma lista de números) -- N.T.: range operator
Diversos operadores podem ser combinados com =, como por exemplo: 
    $a += 1;        # mesmo que $a = $a + 1
    $a -= 1;         # mesmo que $a = $a - 1
    $a .= "\n";     # mesmo que $a = $a . "\n";

Arquivos e I/O

Você pode abrir um arquivo para entrada ou saída de dados utilizando a função open(). Ela é documentada em detalhes em the perlfunc manpage e the perlopentut manpage. Aqui está um resumo: 
    open(ENTRADA,  "entrada.txt")   or die "Nao foi possivel abrir o arquivo entrada.txt para leitura: $!";
    open(SAIDA, ">saida.txt") or die "Nao foi possivel abrir o arquivo saida.txt para escrita: $!";
    open(LOG, ">>meu.log")    or die "Nao foi possivel abrir o arquivo meu.log em modo 'append': $!";
Você pode ler de um filehandle aberto utilizando o operador <>. No contexto escalar, ele lê uma única linha de um filehandle, e em contexto de lista lê o arquivo inteiro, atribuíndo cada linha a um elemento da lista: 
    my $linha  = <ENTRADA>;
    my @linhas = <ENTRADA>;
Ler todo o arquivo de uma única vez é chamado slurping. Este procedimento pode ser útil porém pode trazer problemas de memória. A maioria do processamento de texto em arquivos pode ser feito uma linha por vez com as construções de iteração do Perl. O operador <> é visto com mais freqüência em um comando while: 
    while (<ENTRADA>) {     # atribui à variável $_ uma linha de cada vez
        print "Acabei de ler essa linha: $_";
    }
Nós já vimos como imprimir para a saída padrão utilizando print(). Entretanto, print() pode ter um primeiro parâmetro opcional especificando em qual filehandle ele irá imprimir: 
    print STDERR "Este e' seu ultimo aviso.\n";
    print SAIDA $registro;
    print LOG $mensagem;
Quando você não tiver outras operações com seus filehandles abertos, você deve fechá-los (utilizando o comando close()). Sendo bem honesto, o Perl irá finalizá-los para você caso você esqueça. 
    close ENTRADA;

Expressões Regulares

O suporte à expressões regulares no Perl é intensa e profunda, e é extensamente documentada em the perlrequick manpage, the perretut manpage e outros lugares. Um resumo:

Combinação simples
    if (/foo/)            { ... }  # verdadeiro se $_ contém "foo"
    if ($a =~ /foo/) { ... }  # verdadeiro se $a contém "foo"
O operador de combinações // é documentado em the perlop manpage. Ele executa a combinação por padrão na variável $_, ou pode ser utilizado em outra variável utilizando o operador =~ (também documentado em the perlop manpage).

Substituições simples
    s/foo/bar/;                     # substitui foo com bar em $_
    $a =~ s/foo/bar/;          # substitui foo com bar em $a
    $a =~ s/foo/bar/g;        # substitui TODAS AS INSTÂNCIAS de foo com bar em $a with bar in $a
O operador de substituições s/// é documentado em the perlop manpage.

Expressões regulares mais complexas
Você não precisa fazer combinações apenas com strings fixas. Você pode combinar qualquer coisa que você quiser utilizando expressões regulares mais complexas. Elas são documentadas em the perlre manpage, porém aqui está uma consulta rápida: 
    .                           um único caractere
    \s                         um caractere de espaçamento (espaço, tabulação, nova-linha)
    \S                         um caractere não-espaçamento
    \d                         um dígito (0-9)
    \D                         um caractere não-dígito
    \w                         um caractere de palavra (a-z, A-Z, 0-9, _)
    \W                        um caractere de não-palavra
    [aeiou]                 combina um único caractere do conjunto dado
    [^aeiou]               combina com um único caractere de fora do conjunto dado
    (foo|bar|baz)       combina com qualquer uma das alternativas especificadas
    ^                          início da string
    $                          final da string
Quantificadores podem ser utilizados para especificar quantos items da expressão anterior você quer combinar, onde ``expressão'' pode ser tanto um caractere, um dos meta-caracteres listados acima, ou um grupo de caracteres ou meta-caracteres entre parênteses. 
    *                    nenhum ou mais da expressão anterior
    +                    um ou mais da expressão anterior
    ?                     nenhum ou um da expressão anterior
    {3}                 combina exatamente 3 da expressão anterior
    {3,6}              combina entre 3 e 6 da expressão anterior
    {3,}                combina 3 ou mais da expressão anterior
Alguns exemplos: 
    /^\d+/                string que começa com um ou mais dígitos
    /^$/                    string vazia
    /(\d\s){3}/         três dígitos, cada um seguido por um caractere de espaçamento (por exemplo "3 4 5 ")
    /(a.)+/                combina uma string em que cada par de caracteres, o primeiro seja a letra a (por exemplo "abacadaf")
    # Esta iteração lê da STDIN, e imprime apenas as linhas que não estão em branco:
    while (<>) {
        next if /^$/;
        print;
    }

Parênteses para captura de dados
Assim como agroupamento, os parênteses também servem para um segundo propósito. Eles podem ser utilizados para capturar os resultados de parte da combinação da expressão regular para posterior utilização. Os resultados são armazenados nas variáveis $1, $2 e assim por diante. 
    # uma maneira rápida e suja de separar um endereço eletrônico em partes
    if ($email =~ /([^@]+)@(.+)/) {
        print "Nome do usuario: $1\n";
        print "Nome do host: $2\n";
    }

Outras funcionalidades das expressões regulares
Expressões regulares em Perl também suportam backreferences, lookaheads e todos outros tipos de detalhes complexos. Leia sobre elas em the perlrequick manpage, the perlretut manpage e the perlre manpage.

Escrevendo subrotinas

Escrever subrotinas é fácil:: 
    sub log {
        my $mensagem = shift;
        print LOGFILE $mensagem;
    }
O que é aquele shift? Os argumentos de uma subrotina estão disponíveis através do array especial chamado @_ (veja the perlvar manpage para mais detalhes). O argumento padrão para a função shift é @_. Então, my $mensagem = shift; extrai o primeiro item da lista de argumentos e o atribui em $mensagem. Podemos manipular @_ de outras maneiras: 
    my ($mensagem, $prioridade) = @_;       # comum
    my $mensagem = $_[0];                          # incomum, e muito feio
As subrotinas podem também retornar valores: 
    sub quadrado {
        my $num = shift;
        my $resultado = $num * $num;
        return $resultado;
    }
Para maiores informações sobre como escrever subrotinas, veja the perlsub manpage.

Programação orientada à objetos em Perl

A programação orientada à objetos em Perl é relativamente simples e é implementada utilizando referências que sabem em qual tipo de objeto elas são baseadas, no conceito de Perl sobre o que são pacotes. Entretanto, este tipo de programação está muito além do escopo deste documento. Leia the perlboot manpage, the perltoot manpage, the perltooc manpage e the perlobj manpage. Como um programador Perl iniciante, a utilização mais comum de orientação a objetos em Perl será a utilização de módulos escritos por terceiros, que está documentada abaixo.

Utilizando módulos Perl

Os módulos de Perl provêm diversas funcionalidades para ajudá-lo a não reinventar a roda, e podem ser obtidos do CPAN (http://www.cpan.org/). Um grande número de módulos populares são incluídos com a distribuição padrão do Perl. As categorias dos módulos vão desde manipulação de textos à protocolos de rede e integração com banco de dados à gráficos. Uma lista categorizada dos módulos também está disponível no CPAN. Para aprender como instalar módulos obtidos do CPAN, leia the perlmodinstall manpage. Para aprender como utilizar um módulo em particular, utilize perldoc Modulo. Geralmente você irá utilizá-lo desta maneira: use Modulo, que irá dar acesso às funções exportadas ou à interface orientada à objetos do módulo. Você encontra questões e respostas relacionadas à diversas tarefas comuns, e ainda sugestões de módulos para utilizar em the perlfaq manpage. the perlmod manpage descreve os módulos de Perl em geral. the perlmodlib manpage exibe uma listagem dos módulos que foram instalados em sua instalação Perl. Se você necessita escrever módulos para o Perl, você irá encontrar bons conselhos em the perlnewmod manpage.

voltar para o topo

AUTOR

Kirrily ``Skud'' Robert <skud@cpan.org>

voltar para o topo

TRADUÇÃO

Igor Sutton <igor@izut.com>

voltar para o topo