Tutorial Perl

ÍNDICE

  1. Introdução
  2. Operadores
  3. Tipos de Dados
  4. Estruturas de Dados
  5. Subrotinas
  6. Estruturas de Fluxo
  7. Expressões Regulares
  8. Funcões

1. Introdução

A linguagem Perl (Practical Extraction and Report Language) - inicialmente concebida no ambiente Unix e hoje portada para ambientes como Windows, OS/2 e diversos outros sabores de Unix (Linux, BSD, AIX, SUN, etc.) - é uma linguagem interpretável e bastante poderosa como C, porém, bem mais simples e flexível. Ela é uma linguagem execelente para manipulação de strings e formatação de textos de um modo geral, e é justamente por isso que a mesma é também bastante utilizada para implementação de CGIs.

2. Operadores

2.1. Aritméticos

    --------------------------------------
    Operador    Descrição
    --------------------------------------
    **          Exponenciação
    +           Adição
    -           Subtração
    *           Multiplicação
    /           Divisão
    %           Resto da divisão
    .           Concatenação de strings
    x           Replicador (escalar/array)
    --------------------------------------

2.2. (In/De)cremento

    ---------------------------
    Operador    Descrição
    ---------------------------
    ++          Incremento (+1)
    --          Decremento (-1)
    ---------------------------

2.3. Comparação

    -----------------------------------------
    Numérico    String  Descrição
    -----------------------------------------
    ==          eq      Igualdade
    !=          ne      Desigualdade
    cmp         <=>     Igualdade binária (*)
    -----------------------------------------
    (*) -1 = menor; 0 = iguais; 1 = maior

2.4. Relacionais

    ----------------------------------
    Numérico    String  Descrição
    ----------------------------------
    <           lt      Menor que
    >           gt      Maior que
    <=          le      Menor ou igual
    >=          ge      Maior ou igual
    ----------------------------------

2.5. Lógicos

    ------------------------
    Operador    Descrição
    ------------------------
    !  not      Negação
    && and       boleano
    || or        boleano
    ------------------------

2.6. Atribuição

    ------------------------------------------
    Operador    Descrição
    ------------------------------------------
    =           Atribuição simples
    =      Operação seguida de atribuição
    ------------------------------------------
    opr: +, -, *, /, **, %, ., ||, &&

2.7. Equiparação

    ---------------------------
    Operador    Descrição
    ---------------------------
    =~          equipara
    !~          equipara e nega
    ---------------------------

2.8. Arquivos

    -------------------------------------
    Operador    Descrição
    -------------------------------------
    -d          Diretório
    -e          Arquivo existe
    -f          Arquivo
    -z          Arquivo possui zero bytes
    -------------------------------------

2.9. Outros

    ---------------------------------------------
    Operador    Descrição
    ---------------------------------------------
    ..          Especificador de faixa de valores
    ,           Especificador de lista
    ? ... : ... (if-then-else)
    ---------------------------------------------

3. Tipos de Dados

A Perl não faz distinção entre tipos (numéricos, alfanuméricos, lógicos, etc) de dados. A maneira como esses dados serão manipulados, dependerá do contexto no qual estão inseridos. Isto é, em um contexto numérico, um número será tratado como um número (ex: operação de adição). Porém, em um contexto literal (ex: operação de concatenação), esse mesmo número será tratado como uma string. No contexto lógico, teremos 0, "0" e "" avaliados como falso, demais valores serão avaliados como verdadeiros.

Os dados podem ser representados na forma de um escalar ou de uma lista. O escalar, é qualquer conjunto de caracteres (letras, números, simbolos, etc). A lista, é um conjunto de dados, representando uma mesma informação. Na verdade, uma lista nada mais é que um conjunto de escalares. E esse conjunto normalmente é descrito usando-se o operador especificador de lista, a "," (vírgula).

4. Estruturas de Dados

Na Linguagem Perl existem três estruturas básicas de armazenamentos de dados: o escalar, o array e o hash.

4.1. Escalar

Variável que armazena escalares. O nome de uma variável escalar deve sempre iniciar pelo caracter $, pois é através deste caracter que as variáveis escalares são identificadas como tal. Ex.:

    $nome = "Jose Paulo";
    $idade = 32;
    $sexo = M;

4.2. Array

Variável que armazena listas. O nome de uma variável array deve iniciar com caracter "@", pelo mesmo motivo do "$" em uma variável escalar. Cada elemento (um escalar) de uma lista será referenciado por um índice que corresponderá a posição do escalar dentro da lista que o mesmo esta inserido. O primeiro elemento da lista será referenciado pelo índice 0 (zero).

- Atribuindo uma lista:

@frutas = ( "maca", "laranja", "pera", "goiaba" );
- Atribuindo elementos individualmente:
$frutas[0] = "maca";
$frutas[1] = "laranja";
$frutas[2] = "pera";
$frutas[3] = "goiaba";
Obs.: Sempre que se fizer referência a um elemento em específico da lista de elementos de uma array, deve-se utilizar $ ao invés de @ no nome do array, pois o que se referencia, é um escalar. - Contabilizando elementos de um array:
$qtd_frutas = @frutas;
Obs.: Como @frutas está em um contexto escalar (sendo atribuido a uma variável escalar), $qtd_frutas irá receber, exatamente, a quantidade de elementos armazenados em @frutas.
@alimento = @frutas;
Obs.: Neste contexto (de lista) @frutas será tratada como uma lista de elementos que será atribuida ao array @alimento. Após essa instrução ser excutada, @alimento conterá a mesma lista (conjunto de elementos) existentes em @frutas.
$ultimo = $#frutas;
print $frutas[$ultimo];  # imprime "goiaba"
Obs.: O escalar $ultimo irá receber o índice do último elemento inserido em @frutas, ou seja, o valor 3 referente ao elemento "goiaba". Em contexto escalar, @frutas é igual a $#frutas + 1.

4.3. Hash

Por ser um array, um hash também terá como conteudo uma lista. A diferença em relação ao array, é que cada elemento da lista a ser atribuida ao hash deverá estar associado a um índice. Será através desses índices que cada elemento em um hash será referenciado.

Como o escalar e o array, o hash também será identificado em seu nome por um caracter especial, o %. E da mesma forma que o array, ao se fazer referência a um elemento específico, deve-se utilizar $ ao invés do % no nome do hash. O índice do hash será envolvido pelos caracteres { e } e não [ e ] como no array.

- Atribuindo uma lista:

    %funcionario = ( "m562892", "Jose", "p000001", "Andre" );

ou

    %funcionario = ( "m562892" => "Jose", "p000001" => "Andre" );

- Atribuindo elementos individualmente:

    $funcionario{m562892} = "Jose";
    $funcionario{p000001} = "Andre";
Obs.: As variáveis em perl não precisam ser obrigatoriamente declaradas para serem utilizadas, entretanto, existem dois declaradores de variáveis (my e local) que serão discutidos mais adiante. Apesar da não obrigatoriedade, é aconselhável realizar a declaração das variáveis que se deseja utilizar.

5. Subrotinas

5.1. Declaração

Em perl, a declaração de uma subrotina pode ter o escopo definido abaixo.

    sub <subrotina> {
        ($param1, $param2, ..., $paramN) = @_;

        <instrucao_1>
        ...
        <instrucao_N>

        return($retorno);
    }

onde:

    sub         palavra reservada usada para declarar a rotina
    subrotina   nome da subrotina a ser declarada
    @_          array contendo a lista de parâmetros enviados para subrotina

Obs.: Uma subrotina sempre retornará um valor. Este, corresponderá ao valor retornado pela última instrução executada ou ao valor enviado para a função "return()".

5.2. Chamada

    &<subrotina>(param1, ..., paramN);

onde:

    &                   identificador de uma função de usuário
    subrotina           nome da função
    param1, ..., paramN lista de parâmetros da função

6. Estruturas de Fluxo

Notação:

    EXPR    instrução que retorne algum valor avaliado como falso ou verdadeiro
    BLOCO   conjuntos de instruções (comandos, operações, estruturas, ...)
    [ ]     envolve valores opcionais

6.1. Desvio

    if ( EXPR ) { BLOCO } [ [ elsif ( EXPR ) { BLOCO } ] else BLOCO ]
    unless ( EXPR ) { BLOCO } [ else { BLOCO } ]

    EXPR1 ? EXPR2 : EXPR3
    EXPR1 if EXPR2
    EXPR1 unless EXPR2

6.2. Repetição

    while ( EXPR ) { BLOCO }
    until ( EXPR ) { BLOCO }

    EXPR1 while EXPR2
    EXPR1 until EXPR2

    do { BLOCO }
    do { BLOCO } while ( EXPR )
    do { BLOCO } until ( EXPR )

    for ( [EXPR]; [EXPR]; [EXPR] ) { BLOCO }
    foreach [VAR] ( ARRAY ) { BLOCO }

7. Expressões Regulares

Uma expressão regular, é um conjunto de regras que descrevem um conjunto de strings sem a necessidade de listar todas as strings neste conjunto. Se os caracteres que compõem um determinado string estão de acordo com as regras de uma determinada expressão regular, então a expressão regular é dita equiparada àquele string.

Como visto na seção "OPERADORES", exitem os operadores =~ e !~ para equiparar um string a uma determinada expressao regular. Devemos usar também o caracter / para delimitar uma expressao regular em uma equiparação.

Ex.:

    $url = "http://www.perl.com";

    if ( $url =~ /http/ ) {
        print "Página sem criptografia";
    }

    if ( $url =~ /https/ ) {
        print "Página com criptografia";
    }

    if ( $url =~ /sex/ ) {
        print "Página pornográfica";
    }
O exemplo acima nos dá uma noção do funcionamento das expressões regulares, no entanto, não elucidam claramente a definição de descrição de conjuntos feita anteriormente. Para tal, será introduzido agora um conjunto de formatadores e caracteres especiais a serem utilizados na composição das expressões regulares; que além de elucidar completamente a definição de expressões regulares dada, irão demonstrar todo o poder e funcionalidade.

7.1. Metacaracteres

- Delimitadores

    ---------------------------------------------
    ^   inicio do string
    $   fim do string
    \b  limitador de palavras => [^a-zA-Z_0-1]
    \B  nenhum limitador de palavras
    ---------------------------------------------

- Átomos

    -------------------------------------------------------
    .   qualquer caracter
    []  qualquer um dos caracteres envolvidos por "[" e "]"
    [^] nenhum dos caracteres envolvidos por "[^" e "]"
    ()  avalia uma string como sendo um único átomo
    |   uma das alternativas
    -   usado com "[]", especifica uma faixa de valores 
    -------------------------------------------------------

- Quantificadores

    ---------------------------------------------------------
    *       zero o mais ocorrências do átomo
    +       uma ou mais ocorrências do átomo
    ?       zero ou uma ocorrência do átomo
    {n}     n ocorrências do átomo
    {n,}    pelo menos n ocorrências do átomo
    {n,m}   pelo menos n, e no máximo m ocorrências do átomo
    ---------------------------------------------------------

- Especiais

    -----------------------------------------------------------
    \d  dígito => [0-9]
    \D  não dígito => [^0-9]
    \n  nova linha (lf)
    \r  returno de carro (cr)
    \t  tabulação
    \f  alimentação de formulário
    \s  caracter de espaço em branco => [ \t\n\r\f]
    \S  caracter diferente de espaço em branco => [^\t\n\r\f]
    \w  caracter alfanumérico (palavra) => [a-zA-Z_0-9]
    \W  caracter não alfanumérico => [^a-zA-Z_0-9]
    -----------------------------------------------------------

7.2. Referenciando

Ao utilizar o formatador "()", a string envolvida pelo mesmo, quando equiparada, poderá ser referenciada indiretamente na própria expressão regular ou fora dela utilizando-se: Referências - Referências

    -------------------------------------
    \1 .. \N faz referência na própria ER
    $1 .. $N faz referência fora da ER
    -------------------------------------

Ex.:

    $html = "<b>Bold<b>";

    if ( $html =~ /<(\w+)>(.*)<\/\1>/ ) {
        print "Marcador HTML: $1", "\n";
        print "Texto: $2", "\n";
    }

Obs.: Neste exemplo, "\1" será substituido pela string equiparada por (\w). E as variáveis especiais "$1" e "$2" irão receber, respectivamente, as strings equiparadas por (\w) e (.*).

7.3. Equiparando Metacaracteres

Caso deseje-se equiparar algum caracter cujo o símbolo seja algum dos formatores, deve-se precedê-lo com o caracter \.

7.4. Exemplos

    --------------------------------------------------------------------------
    ER          Equipara                            Não Equipara
    --------------------------------------------------------------------------
    a.          aa, ab, a1, a-, a3, ax, a.  
    abc         abc, aabc, abcc, aabcc  
    ^abc        abc, abcc                           aabc, aabcc 
    abc$        abc, aabc                           abcc, aabcc
    a[bB]c      abc, aBc, aabc, aaBc, abcc, aBcc  
    ^a[bB]c     abc, aBc, abcc, aBcc                aabc, aaBc
    a[bB]c$     abc, aBc, aabc, aaBc                abcc, aBcc
    a[^bB]c     aabcc                               abc, aBc, aabc, aaBc, aBcc
    ^a[^bB]c    aac, acc                            aabcc, abc, aBc
    a[^bB]c$    abc, aBc, aabc, aaBc  
    a(b|B)c     abc, aBc, aabc, aaBc, abcc, aBcc  
    a[b-e]c     abc, acc, adc, aec, aabc, accc  
    a\bc        a c, a-c, a)c, a.c                  aec, aEc, afc, a_c, a1c
    a\Bc        aec, aEc, afc, a_c, a1c             a c, a-c, a)c, a.c
    ab+         ab, abb, abbb, abbbb                a
    ab*         a, ab, abb, abbb, abbbb  
    ab{2}       abb                                 a, ab
    ab{2,}      abb, abbb, abbb                     a, ab
    ab{2,3}     abb, abbb                           a, ab, abbbb
    a(bc){2}    abcbc                               a, abc
    a(bc){2,3}  abcbc, abcbcbc                      a, abc, abcbcbcbc
    a\[bB\]c    a[bB]c                              abc, aBc
    ab\{2\}     ab{2}                               abb
    a\sb        a b                                 ab
    a\Sb        ab                                  a b
    --------------------------------------------------------------------------

8. Funcões

Será adotado a seguinte notação para a descrição das funções:

    -------------------------------------------------------------------------
    []          envolve parâmetros opcionais
    LISTA       parâmetro é uma lista
    @ARRAY      parâmetro é um array
    %HASH       parâmetro é um hash
    FILEHANDLE  parâmetro é um filehandle
    +           se parâmetro omitido, será utilizado o conteúdo do escalar $_
    -------------------------------------------------------------------------

O filehandle, é apenas um nome interno associado a um arquivo ou dipositivo através do qual os mesmos serão referenciados. Alguns dispositivos estão por padrão associados a um filehandle, exemplo:

    -----------------------------------------------------------------
    STDOUT  saída padrão (vídeo)
    STDIN   entrada padrão (teclado)
    STDERR  saída padrão para mensagens de erro (normalmente o vídeo)
    -----------------------------------------------------------------

8.1. Entrada/Saída

<FILEHANDLE>

Em contexto escalar, lê uma única linha do arquivo aberto e associado a FILEHANDLE. Em contexto de array lê todas a outras linhas restantes do arquivo.


close FILEHANDLE

Fecha o arquivo associado ao FILEHANDLE.


eof FILEHANDLE

Returna 1 se a proxima leitura de FILEHANDLE for fim de arquivo.


open FILEHANDLE [,ARQUIVO]

Abre um arquivo e o associa a um FILEHANDLE. Se ARQUIVO for omitido, uma variável escalar com mesmo nome do FILEHANDLE deve conter o nome do arquivo.

A seguinte convenção é adotada:

      ARQUIVO: abre ARQUIVO apenas para leitura (o mesmo que <ARQUIVO)
     >ARQUIVO: abre ARQUIVO para escrita, criando-o caso não exista
    >>ARQUIVO: abre ARQUIVO para modificação
    +>ARQUIVO: abre ARQUIVO para leitura/escrita

print [FILEHANDLE] [LISTA+]

Imprimi os elementos da LISTA. Se FILEHANDLE for omitido, imprime em STDOUT.

8.2. Escalares

chomp [LISTA+]

Remove caracteres de fim de linha (cr e/ou lf) de todos o elementos de LISTA. Retorna número total de caracteres removidos.


chop [LISTA+]

Remove último caracter de todos os elementos de LISTA. Retorna o último caracter removido.


length [STRING+]

Retorna a quantidade de caracteres em STRING.


lc STRING

Converte todas as letras de STRING para minúsculo.


lcfirst STRING

Converte para minúsculo o primeiro caracter de STRING.


substr STRING, OFFSET[,LEN]

Retorna uma substring de STRING. Essa substring inicia em OFFSET e tem o tamanho de LEN. Se LEN for omitido, substring inicia em OFFSET e termina no fim de STRING.


uc STRING

Converte todas as letras de STRING para mainúsculo.


ucfirst STRING

Converte para maiúsculo o primeiro caracter de STRING.

8.3. Arrays

grep [EXPR | BLOCO], LISTA

Avalia EXPR ou BLOCO para cada elemento de LISTA. Inicializa $_ com o correspondente elemento de LISTA a ser avaliado. Retonar a lista dos elementos para os quais EXPR foi avaliada como verdadeira.


join STRING, LISTA

Junta cada elemento de LISTA em uma única string, delimitando cada um dos elemento pelos caracteres especificados em STRING.


keys %HASH

Retorna uma lista contendo todos os ídices de %HASH.


pop @ARRAY

Remove e returnar o último elemento de @ARRAY.


push @ARRAY, LISTA

Adiciona LISTA ao @ARRAY.


reverse LISTA

Em contexto de array, retona os elementos de LISTA em ordem inversa. Em contexto escalar, retorna os caracteres do primeiro elemento de LISTA em ordem inversa.


scalar LISTA

Faz com que LISTA seja avaliada em contexto escalar.


sort [LISTA | BLOCO | SUBROTINA]

Retorna LISTA com seus elementos ordenados.


split /ER/, [STRING+], [LIMIT]


values %HASH

Retorna uma lista contendo todos os valores (elementos referenciados pelos ídices) de %HASH.

8.4. Arquivos

mkdir DIR, MODE

Cria um diretório e seta as permissões definidas em MODE.


rename ATUAL, NOVO

Renomeia de arquivo ATUAL para arquivo NOVO.


rmdir [DIR+]

Remove o diretorio DIR.


stat FILE

Retorna uma lista de 13 elementos, sendo estes:

    -------------------------------------------------------------------------
    Elemento    Código  Descrição
    -------------------------------------------------------------------------
    0           device  Número do dispositivo
    1           ino     Número do Inode
    2           mode    Permissões
    3           nlink   Número e "hard links" para o arquivo
    4           uid     Uid do usuario dono do arquivo
    5           gid     Gid do usuario dono do arquivo
    6           rdev    Identificador do dispositivo (alguns arquivos apenas)
    7           size    Tamanho do arquivo (em bytes)
    8           atime   Data do último acesso
    9           mtime   Data da última modificação
    10          ctime   Data de criação
    11          blksize Tamanho do bloco do dispositivo
    12          blocks  Blocos utilizados pelo arquivo
    -------------------------------------------------------------------------

unlink LISTA

Deleta uma lista de arquivos.