Variáveis são áreas de armazenamento nas quais podem ser guardados dados que serão utilizados durante a execução de um programa. O conteúdo de uma variável é denominado de "valor". Os valores de variáveis podem ser alterados a qualquer tempo.

Em Perl, uma variável simples, que contenha um número ou uma sequência de caracteres, é denominada de variável escalar. Exemplos:

$Nome = "Matusalém";
$Idade = 625;
$Nome_2 = "Pedro Bó";
$Idade_2 = sqrt($Idade);

Um pequeno script Perl usando variáveis escalares:

#!/usr/bin/perl
$Valor = 123456;
$Valorzinho = substr($Valor,1,3);
print $Valorzinho;

Uma escalar, ou seja, uma variável simples, é composta por um cifrão $ seguido do nome da variável. O cifrão sempre precisa estar presente se a variável for utilizada para receber um valor ou numa operação (como no exemplo acima, onde a variável $Idade aparece dentro da função sqrt() que calcula a raiz quadrada de um número).

Observações: Os dados em Perl não são "tipados". Quando se tem uma sequência de caracteres constituída apenas por caracteres numéricos (ex. "7423.13"), pode-se efetuar cálculos numéricos com a mesma, sem nenhum problema. Da mesma maneira, pode-se tratar valores numéricos como uma sequência de caracteres. Para observar esta característica, verifique o pequeno script acima. Definiu-se $Valor como uma escalar numérica. Logo abaixo, utilizamos uma função típica para tratamento de strings, a substr().

Os parâmetros da função significam: extrair, a partir do segundo caracter, três caracteres (o segundo caracter é solicitado através do parâmetro 1 porque em Perl, assim como na maioria das outras linguagens de programação, começa-se a contar à partir do zero). O resultado obtido, "234", é armazenado na escalar $Valorzinho. Caso você já programe em outra linguagem, então você poderá avaliar o grau de liberdade que a linguagem Perl oferece no tratamento de variáveis.

Matrizes são cadeias de grupos de escalares. Em Perl, as matrizes têm uma importância primordial porque oferecem um modo muito fácil de armazenar dados e manipulá-las. Exemplo 1:

#!/usr/bin/perl
@Dados = ("Maria",23,"Curitiba","3o.Grau");
print $Dados[0], " tem ", $Dados[1], " anos, mora em ", $Dados[2],
   " e tem ", $Dados[3];

Exemplo 2:

#!/usr/bin/perl
for($i = 1;$i <= 9;$i++)
{
   $Valor = $i * $i;
   push(@Quadrados, $Valor);
}
for(@Quadrados)
{
   print $_, "\n";
}

Exemplo 3:

#!/usr/bin/perl
@Letra = ("a".."z");
print $Letra[2], "\n";

Em Perl, uma matriz é iniciada por um sinal de arroba @ seguido do nome da matriz. É possível inicializar uma matriz com valores predefinidos, como a matriz @Dados do exemplo 1. Note que os dados precisam estar entre parênteses e separados por vírgulas.

As matrizes também podem ser geradas dinamicamente, como se pode observar no exemplo 2: dentro de um loop, que conta de 1 até 9, a matriz @Quadrados é povoada dinamicamente com os quadrados dos números de 1 atá 9. Isto é possível graças ao uso da função push(), a qual adiciona elementos no final da matriz.

O exemplo 3 mostra uma variação especial. Para se povoar uma matriz com letras (de-até) ou com números (de-até) basta indicar o primeiro e o último caracter desejado, separados por dois pontos (no exemplo, a matriz @Letra é povoada com caracteres minúsculos de a até z).

Quando os valores de uma matriz são predefinidos, valem as mesmas regras das variáveis escalares: strings são indicadas entre aspas, valores numéricos não precisam de aspas. É claro que também é possível povoar uma matriz com escalares. Neste caso, a lista incorpora o valor das escalares correspondentes.

Para se referir a um determinado elemento de uma matriz, utiliza-se o nome da matriz precedido do sinal de cifrão $ (da mesma forma que nas escalares). Após o nome, segue o número do elemento da lista entre colchetes. O primeiro elemento é identificado por @NomeDaLista[0], o segundo por @NomeDaLista[1] e assim sucessivamente. No primeiro exemplo, logo acima, esta característica fica bem clara.

Ainda com referência aos 3 exemplos citados, seguem os dados das matrizes criadas e seus respectivos elementos.

É muito simples atribuir o valor de um elemento de uma lista a uma variável escalar. Basta a seguinte linha de comando: $Prenome = $Dados[0];

Também é muito simples copiar uma lista completa para outra lista. Basta o comando: @NovaLista = @Quadrados;

Pode-se armazenar strings e valores numéricos numa mesma lista, como no exemplo 1 acima. Também não existe limitação de tamanho dos elementos de uma lista. Pode-se, portanto, armazenar uma lista inteira como elemento de uma outra lista, ou seja, uma lista B dentro de um elemento da lista A. Um elemento da lista "embutida" B pode, então, ser obtido através de @ListaA[2][4] (isto é, o terceiro elemento da lista A é a lista B e, desta, solicita-se o quinto elemento).

Mesmo sem uma definição prévia, pode-se atribuir um valor a uma lista. Por exemplo, $Numeros[5] = 4321; cria a lista @Numeros com seis elementos, $Numeros[0] a $Numeros[5]. Os primeiros 5 elementos estão vazios e o sexto elemento recebe o valor 4321.

O último elemento de uma lista pode sempre ser acessado através de @NomeDaLista[-1]. O índice negativo -1 está reservado para tal fim.

Listas comuns são constituídas por uma sequência de valores que podem ser obtidos através do seu número de índice, que sempre começa com 0. Assim, o 8o. elemento de uma lista de nome @NomeDaLista pode ser obtido através de $NomeDaLista[7].

Uma lista associativa, denominada de Hash na linguagem PERL, guarda, em cada elemento da lista, dois valores: um nome e um valor. Os valores da lista, neste caso, não precisam ser acessados através do seu número de índice. Podem ser obtidos diretamente através do nome a eles associados. Exemplo:

#!/usr/bin/perl
%Dados = ("Nome", "Joana", "Idade", 23, "Grau", "Superior");
print $Dados{'Nome'}, " tem ", $Dados{'Idade'},
   " anos de idade e grau ", $Dados{'Grau'};

Um hash é inicializado em PERL através do sinal de porcento %. Quando se cria um hash com dados, estes sempre são definidos em pares: o primeiro elemento representa o nome do hash, o segundo corresponde ao valor que será obtido quando se utiliza o nome do hash. Assim, no exemplo acima, os primeiros dois elementos, "Nome" e "Joana", constituem o primeiro par hash do Hash %Dados.

Para acessar um determinado elemento dentro de um hash, utiliza-se o nome da variável hash precedida de um cifrão $, da mesma forma como em variáveis escalares simples. Após o nome da variável hash, utiliza-se um par de colchetes, dentro dos quais fica o nome do elemento hash desejado entre aspas simples. No exemplo acima obtém-se com $Dados{'Nome'} o valor correspondente "Joana".

Observações: Os Hash, ou seja, as listas associativas, têm as mesmas regras e características que as listas comuns.

Os hash são muito úteis num script CGI. É possível, por exemplo, utilizá-los para armazenar parâmetros enviados por um formulário dando ao nome hash o nome dos campos do formulário e, ao valor hash, o valor atribuído pelo usuário aos mesmos campos do formulário.

Quem conhece a linguagem C (e outras), sabe o que são ponteiros e como a programação pode se tornar eficiente com o seu uso. Referências são ponteiros para tipos de dados previamente definidos (tanto faz se escalares, listas ou hash). Através de referências é possível se obter o conteúdo de uma variável escalar, de uma lista ou de um hash da mesma forma que com o uso do nome original.

O interessante à respeito das referências em Perl é que o valor de uma variável é mantido enquanto existirem referências a essa variável. Isto é muito importante quando se trabalha com sub-rotinas, nas quais sejam definidos tipos de dados locais válidos. Exemplo:

#!/usr/bin/perl

&A();

sub B()
{
   print $$ReferenciaTexto, "\n"; # O valor existe apenas na referência!
}

sub A()
{
   my $Texto = "Isto é um pequeno texto";
   $ReferenciaTexto = \$Text; # Aqui é definida a referência
   &B();
}

O exemplo acima deixa clara a atuação de uma referência. O pequeno script Perl do exemplo contém duas subrotinas definidas como A() e B(). Inicialmente, com &A(), é chamada a subrotina correspondente. Nesta subrotina, a escalar $Texto, cuja sobrevida está restrita à subrotina A(), é definida através do uso de my.

Logo após definir a escalar, a referência é definida. A referência é definida da mesma forma que uma escalar normal. Na atribuição do valor da referência utiliza-se uma barra invertida \. A barra invertida faz com que, ao invés da referência $ReferenciaTexto receber o mesmo valor de $Texto, ela receba o endereço onde se encontra o valor de $Texto. É por esse motivo que a referência ocupa muito menos memória que a escalar.

Por último, a subrotina B() é chamada da área da subrotina A(). Na subrotina B(), o valor da referência $ReferenciaTexto é apresentado através da função print. Se, neste ponto, a diretiva fosse print $Texto;, nada seria mostrado porque a variável $Texto da subrotina A(), com seu respectivo valor, a essa altura já foi descartada. O valor sozinho, porém, ainda existe e pode ser alcançado através da referência $ReferenciaTexto.

Para se obter o valor de uma referência através de uma escalar é necessário associar dois sinais de cifrão $$ ao nome da referência, como mostrado no exemplo acima.

Observações: Se, por exemplo, uma diretiva print se referir diretamente a uma referência ao invés de se referir ao seu valor, o endereço de memória onde se encontra o valor é mostrado na sua forma hexadecimal.

As referências podem ser definidas não só para escalares, como também listas e hashs; até mesmo para elementos de listas e hashs. A tabela a seguir dá uma idéia de como devem ser as notações:

As referências (ponteiros) só são interpretadas à partir da versão 5.0 da Perl. Versões mais antigas dão mensagens de erro quando encontram referências.

Não abuse de referências. Use-as apenas quando o motivo for imperativo.