Perl – Manual Básico

IntroduçãoO objetivo desta documentação é introduzir o leitor na criação e execução de scripts em Perl em ambiente UNIX. Perl significa “Practical Extraction and Report Language” e foi originalmente desenvolvida para realizar tarefas de administração de sistema. O objetivo principal da linguagem é facilitar a extração de dados e emitir relatórios. Pode-se usar o Perl em tarefas relacionadas a relatório de informações sobre sistema ou pesquisa em arquivos de texto. O Perl é uma linguagem “interpiler”. Isto significa que um programa em Perl é primeiro compilado e em seguida interpretado (não gera código executável). Entretanto, é possível encontrar um compilador de Perl a partir da versão 5.005.

Programando

Para verificar qual o número da versão da linguagem Perl instalada, digite:

$ perl -v

Vejamos agora um exemplo simples de um script feito em Perl.

# arquivo: teste1.pl
print "Meu primeiro Script Perln";


Variáveis Matrizes

Uma matriz (ou vetor ou lista) é simplesmente um conjunto ordenado de valores escalares, texto ou números, ou ambos. Uma variável de matriz é indicada pelo símbolo @. Veja o exemplo abaixo.

# arquivo: teste5.pl
@teste = (1, 2, 3, “oi”);
print “@testen”;O script acima imprime

1 2 3 oiPara imprimir um elemento da matriz por linha, digite

# arquivo: teste6.pl
@teste = (1, 2, 3, “oi”);
print “teste[0] = @teste[0]n”;
print “teste[1] = @teste[1]n”;
print “teste[2] = @teste[2]n”;
print “teste[3] = @teste[3]n”;A execução do script acima mostra

teste[0] = 1
teste[1] = 2
teste[2] = 3
teste[3] = oiNote que a contagem dos índices da matriz começa com zero. Assim, o índice 1 representa o segundo elemento da matriz. É possível que um elemento da lista seja uma outra lista. Veja o exemplo abaixo.

# arquivo: teste7.pl
@lista1 = (1, 2, 3, “oi”);
@lista2 = (“a”, “b”, @lista1, “c”);
print “@lista1 = @lista1n”;
print “@lista2 = @lista2n”;A saída correspondente ao script teste7.pl é

@lista1 = 1 2 3 oi
@lista2 = a b 1 2 3 oi cPara acrescentar um ou mais elementos a lista, pode-se usar o comando push. Para remover o último elemento da lista usa-se o comando pop. A seguir temos um exemplo do uso destes dois comandos.

# arquivo: teste8.pl
@lista = (1, 2, 3);
print “1 – @lista = @listan”;
# acrescenta um item a @lista
push(@lista, “a”);
print “2 – @lista = @listan”;
# acrescenta vários itens a @lista
push(@lista, “b”, “c”, “d”);
print “3 – @lista = @listan”;
# acrescenta lista2 a @lista
@lista2 = (“e”, “f”);
push(@lista, @lista2);
print “4 – @lista = @listan”;
# remove o último elemento de @lista
pop(@lista);
print “5 – @lista = @listan”;
print ” @lista2 = @lista2n”;
# remove o último elemento de @lista e o armazena em $var
$var = pop(@lista);
print “6 – @lista = @listan”;
print ” $var = $varn”;A execução do script teste8.pl mostra a seguinte saída

1 – @lista = 1 2 3
2 – @lista = 1 2 3 a
3 – @lista = 1 2 3 a b c d
4 – @lista = 1 2 3 a b c d e f
5 – @lista = 1 2 3 a b c d e
@lista2 = e f
6 – @lista = 1 2 3 a b c d
$var = ePara determinar o número de elementos de uma matriz, basta atribuir (=) a matriz a uma variável escalar. Para determinar o índice do último elemento da matriz, pode-se usar $#nome_matriz. Naturalmente, temos que o número de elementos de uma matriz é igual ao índice do último elemento da matriz mais 1, pois o índice do primeiro elemento é zero. O script teste9.pl mostra um exemplo onde é apresentado o número de elementos e o índice do último elemento de uma matriz.

# arquivo: teste9.pl
@teste = (“a”, “b”, “c”);
$var = @teste;
print “@teste = @testen”;
print “número de elementos = $varn”;
print “índice do último elemento = $#testen”;A saída da execução do script acima é

@teste = a b c
número de elementos = 3
índice do último elemento = 2Existem outras operações interessantes que podemos fazer com as matrizes. A seguir, o script teste10.pl nos fornece alguns exemplos.

# arquivo: teste10.pl
@teste = (“a”, “b”, “c”, “d”, “e”);
print “@teste = @testen”;
# transforma a matriz em uma string com um espaço entre cada elemento
$var = “@teste”;
print “$var = $varn”;
# transforma a matriz em uma string com um * entre cada elemento
$” = ” * “;
$var = “@teste”;
print “$var = $varn”;
$” = ” “;
# $var1 recebe o primeiro elemento da matriz, enquanto que
# $var2 recebe o segundo elemento da matriz
($var1, $var2) = @teste;
print “$var1 = $var1n”;
print “$var2 = $var2n”;
# $var recebe o primeiro elemento da matriz, enquanto que
# @teste2 recebe os outros elementos da matriz
($var, @teste2) = @teste;
print “$var = $varn”;
print “$teste2 = @teste2n”;A saída correspondente à execução do script teste10.pl é mostrada abaixo.

@teste = a b c d e
$var = a b c d e
$var = a * b * c * d * e
$var1 = a
$var2 = b
$var = a
$teste2 = b c d eComo observação final, note que nos exemplos acima não especificamos o número de elementos na definição de uma variável matriz. Isto se deve ao fato deste tipo de estrutura ser dinâmico, ou seja, as matrizes crescem e diminuem de tamanho automaticamente para se ajustarem às definições do programador. As matrizes associativas, que veremos a seguir, também possuem esta característica. O perl usa o símbolo # como marca de comentário. Toda linha que começa com # é ignorada a partir do símbolo #. A instrução print é usada para imprimir dados em um script. O n significa uma nova linha. Note que o comando print termina com um ponto-e-vírgula. Digite os dados acima em um arquivo e salve-o como teste1.pl. Para executá-lo, digite na linha de comando

perl teste1.plCaso ocorra algum erro na execução do programa, você pode executar o programa com a depuração, basta digitar

perl -d teste1.plEntrando no depurador do Perl, basta digitar s para executar linha a linha. Para sair do depurador, e portanto cancelar a execução, basta digitar q. Digite h para ver outros comandos do depurador.

É também possível fornecer apenas o nome do script para executar um arquivo. Entretanto, precisamos introduzir duas alterações:

a) O script tem de ter permissão de execução. Para isto, digite na linha de comando

chmod u+x teste1.plO comando chmod é usado para alterar as permissões de acesso aos arquivos. O parâmetro u especifica que a autorização é para o dono do arquivo, o operador + manda adicionar esta nova permissão às permissões já existentes, e o parâmetro x especifica que a permissão é de execução.

b) Devemos especificar no script a localização do Perl. Para isto, deve-se adicionar no início do script (primeira linha) o seguinte

#!/usr/bin/perlA linha acima informa ao sistema para procurar o programa /usr/bin/perl e transmitir o resto do arquivo a esse programa. Note que o diretório onde se encontra o Perl varia de sistema para sistema. O diretório acima é válido para o Conectiva Linux 4.0.

Agora, para executar o programa, basta digitar na linha de comandos

# teste1.plVocê também pode especificar um pequeno script diretamente na linha de comandos. Por exemplo, digite

# perl -e ‘print “Teste de linha de comandosn”‘

Variáveis

As variáveis Perl permitem o armazenamento de texto, números ou listas de ambos e são de três tipos: escalares, matrizes e matrizes associativas.

Os nomes das variáveis Perl consistem de números, letras e o símbolo undescore (‘_’). É importante observar que o Perl é case sensitive, i.e., o Perl diferencia letras maiúsculas e minúsculas.

Variáveis Escalares

As variáveis escalares assumem um valor único, seja uma string de texto ou um número. Pode-se alternar, ajustando uma variável string para assumir um número e vice-versa.

As variáveis do tipo escalar são indicadas pelo símbolo $ antes do nome. Por exemplo, vejamos agora o script teste2.pl que recebe o nome do usuário, armazena-o na variável $nome e depois mostra o conteúdo da variável na tela.

# arquivo: teste2.pl
print "Digite o seu nome: n";
$nome = ;
print "Bom dia, $nomen";

O comando do exemplo acima recebe dados da entrada padrão (normalmente o teclado).

São exemplos de operações numéricas que podem ser definidas com as variáveis escalares: atribuição (=, +=, -=), soma (+), subtração (-), multiplicação (*), divisão (/), resto de divisão (%), expoente (**), incremento (++) e decremento (–). O script abaixo mostra um exemplo destas operações usando três variáveis: $var1,$var2 e $var3.

# arquivo: teste3.pl
$var1 = 200;
$var2 = 30;
print "nAtribuiçãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
# soma variáveis $var1 e $var2 e armazena resultado em $var3

$var3 = $var1 + $var2;
print "nSoman";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# subtrai $var1 de $var2 e armazena resultado em $var3

$var3 = $var2 - $var1;
print "nSubtraçãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# divide $var1 por $var2 e armazena resultado em $var3

$var3 = $var1 / $var2;
# multiplica $var1 por $var2 e armazena resultado em $var3
$var3 = $var1 * $var2;
print "nMultiplicaçãon";
print "$var1 = $var1n";
print "$var2 = $var2n";

print "$var3 = $var3n";
print "nDivisãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# calcula $var2 elevado a 2 e armazena resultado em $var3

$var3 = $var2 ** 2;
print "nExpoenten";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# divide $var1 por $var2 e armazena o resto da divisão em $var3

$var3 = $var1 % $var2;
print "nResto de Divisãon";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# incrementa $var1 e armazena valor de $var1 em $var3

$var3 = ++$var1;
print "nIncrementa primeiron";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# armazena valor de $var1 em $var3 e depois incrementa valor de $var1

$var3 = $var1++;
print "nIncrementa depoisn";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# decrementa $var2 e armazena valor de $var2 em $var3

$var3 = --$var2;
print "nDecrementa primeiron";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";
# armazena valor de $var2 em $var3 e depois decrementa valor de $var1

$var3 = $var2--;
print "nDecrementa depoisn";
print "$var1 = $var1n";
print "$var2 = $var2n";
print "$var3 = $var3n";

Note que no início do string de alguns comandos print do exemplo acima usamos “” antes do símbolo $, isto indica que o Perl deve tratar $ como um símbolo qualquer, sem nenhum significado especial. Portanto, $ será apenas impresso na tela e não será interpretado pelo Perl. O resultado da execução do teste3.pl é

  • Atribuição
$var1 = 200
$var2 = 30
  • Soma
$var1 = 200
$var2 = 30
$var3 = 230
  • Subtração
$var1 = 200
$var2 = 30
$var3 = -170
  • Multiplicação
$var1 = 200
$var2 = 30
$var3 = 6000
  • Divisão
$var1 = 200
$var2 = 30
$var3 = 6.66666666666667
  • Expoente
$var1 = 200
$var2 = 30
$var3 = 900
  • Resto de Divisão
$var1 = 200
$var2 = 30
$var3 = 20
  • Incrementa primeiro
$var1 = 201
$var2 = 30
$var3 = 201
  • Incrementa depois
$var1 = 202
$var2 = 30
$var3 = 201
  • Decrementa primeiro
$var1 = 202
$var2 = 29
$var3 = 29
  • Decrementa depois
$var1 = 202
$var2 = 28
$var3 = 29

São exemplos de operações com caracteres que podem ser definidas com as variáveis escalares: atribuição (=), concatenação (.) e repetição (x). O script abaixo mostra um exemplo destas operações.

# arquivo: teste4.pl
$var1 = 'Universidade';
$var2 = 'Castelo Branco';
# junta os strings de $var1 e $var2 e armazena o resultado em $var3
$var3 = $var1 . $var2;
print "$var1 = $var1n";

print "$var2 = $var2n";
print "$var3 = $var3n";
# adiciona um espaço em branco entre os valores de $var1 e $var2
$var3 = $var1 . ' ' . $var2;
print "$var3 = $var3n";

# imprime conteúdo das variáveis sem precisar concatenar
print "$var1 $var2n";
# repete o conteúdo de $var1 2 vezes
$num = 2;
$var3 = $var1 x $num;
print "$var3 = $var3n";
# adiciona espaço ao final de $var2 e depois repete o conteúdo 3 vezes

$var3 = $var2 . ' ';
$var3 = $var3 x 3;
print "$var3 = $var3n";

O resultado do script acima é

$var1 = Universidade
$var2 = Castelo Branco
$var3 = UniversidadeCastelo Branco
$var3 = Universidade Castelo Branco
Universidade Castelo Branco
$var3 = UniversidadeUniversidade
$var3 = Castelo Branco Castelo Branco Castelo Branco

Para ver outros operadores que podem ser usados com as variáveis escalares, digite na linha de comandos

# man perlop


Variáveis Matrizes

Uma matriz (ou vetor ou lista) é simplesmente um conjunto ordenado de valores escalares, texto ou números, ou ambos. Uma variável de matriz é indicada pelo símbolo @. Veja o exemplo abaixo.

# arquivo: teste5.pl
@teste = (1, 2, 3, “oi”);
print “@testen”;O script acima imprime

1 2 3 oiPara imprimir um elemento da matriz por linha, digite

# arquivo: teste6.pl
@teste = (1, 2, 3, “oi”);
print “teste[0] = @teste[0]n”;
print “teste[1] = @teste[1]n”;
print “teste[2] = @teste[2]n”;
print “teste[3] = @teste[3]n”;A execução do script acima mostra

teste[0] = 1
teste[1] = 2
teste[2] = 3
teste[3] = oiNote que a contagem dos índices da matriz começa com zero. Assim, o índice 1 representa o segundo elemento da matriz. É possível que um elemento da lista seja uma outra lista. Veja o exemplo abaixo.

# arquivo: teste7.pl
@lista1 = (1, 2, 3, “oi”);
@lista2 = (“a”, “b”, @lista1, “c”);
print “@lista1 = @lista1n”;
print “@lista2 = @lista2n”;A saída correspondente ao script teste7.pl é

@lista1 = 1 2 3 oi
@lista2 = a b 1 2 3 oi cPara acrescentar um ou mais elementos a lista, pode-se usar o comando push. Para remover o último elemento da lista usa-se o comando pop. A seguir temos um exemplo do uso destes dois comandos.

# arquivo: teste8.pl
@lista = (1, 2, 3);
print “1 – @lista = @listan”;
# acrescenta um item a @lista
push(@lista, “a”);
print “2 – @lista = @listan”;
# acrescenta vários itens a @lista
push(@lista, “b”, “c”, “d”);
print “3 – @lista = @listan”;
# acrescenta lista2 a @lista
@lista2 = (“e”, “f”);
push(@lista, @lista2);
print “4 – @lista = @listan”;
# remove o último elemento de @lista
pop(@lista);
print “5 – @lista = @listan”;
print ” @lista2 = @lista2n”;
# remove o último elemento de @lista e o armazena em $var
$var = pop(@lista);
print “6 – @lista = @listan”;
print ” $var = $varn”;A execução do script teste8.pl mostra a seguinte saída

1 – @lista = 1 2 3
2 – @lista = 1 2 3 a
3 – @lista = 1 2 3 a b c d
4 – @lista = 1 2 3 a b c d e f
5 – @lista = 1 2 3 a b c d e
@lista2 = e f
6 – @lista = 1 2 3 a b c d
$var = ePara determinar o número de elementos de uma matriz, basta atribuir (=) a matriz a uma variável escalar. Para determinar o índice do último elemento da matriz, pode-se usar $#nome_matriz. Naturalmente, temos que o número de elementos de uma matriz é igual ao índice do último elemento da matriz mais 1, pois o índice do primeiro elemento é zero. O script teste9.pl mostra um exemplo onde é apresentado o número de elementos e o índice do último elemento de uma matriz.

# arquivo: teste9.pl
@teste = (“a”, “b”, “c”);
$var = @teste;
print “@teste = @testen”;
print “número de elementos = $varn”;
print “índice do último elemento = $#testen”;A saída da execução do script acima é

@teste = a b c
número de elementos = 3
índice do último elemento = 2Existem outras operações interessantes que podemos fazer com as matrizes. A seguir, o script teste10.pl nos fornece alguns exemplos.

# arquivo: teste10.pl
@teste = (“a”, “b”, “c”, “d”, “e”);
print “@teste = @testen”;
# transforma a matriz em uma string com um espaço entre cada elemento
$var = “@teste”;
print “$var = $varn”;
# transforma a matriz em uma string com um * entre cada elemento
$” = ” * “;
$var = “@teste”;
print “$var = $varn”;
$” = ” “;
# $var1 recebe o primeiro elemento da matriz, enquanto que
# $var2 recebe o segundo elemento da matriz
($var1, $var2) = @teste;
print “$var1 = $var1n”;
print “$var2 = $var2n”;
# $var recebe o primeiro elemento da matriz, enquanto que
# @teste2 recebe os outros elementos da matriz
($var, @teste2) = @teste;
print “$var = $varn”;
print “$teste2 = @teste2n”;A saída correspondente à execução do script teste10.pl é mostrada abaixo.

@teste = a b c d e
$var = a b c d e
$var = a * b * c * d * e
$var1 = a
$var2 = b
$var = a
$teste2 = b c d eComo observação final, note que nos exemplos acima não especificamos o número de elementos na definição de uma variável matriz. Isto se deve ao fato deste tipo de estrutura ser dinâmico, ou seja, as matrizes crescem e diminuem de tamanho automaticamente para se ajustarem às definições do programador. As matrizes associativas, que veremos a seguir, também possuem esta característica.

Matrizes Associativas

Uma matriz associativa corresponde a uma lista onde cada elemento possui dois itens: chave e valor. Uma matriz associativa é definida usando o símbolo % e é acessada usando o símbolo $.

# arquivo: teste11.pl
%nota = ("Ana", 8.5, "João", 9.2,"Pedro", "faltou");
$nome = "Ana";
print "$nome teve nota igual a $nota{$nome}n";
print "João teve nota igual a ";

print $nota{"João"};
print "n";
$nome = "Pedro";
print "$nome $nota{$nome}n";
$nota{"Maria"} = 8.9;
$nome = "Maria";
print "$nome teve nota igual a $nota{$nome}n";

$nota{0} = 8.9;
print "$nota{0} é $nota{0}n";

A execução do programa teste11.pl tem a seguinte saída:

Ana teve nota igual a 8.5
João teve nota igual a 9.2
Pedro faltou
Maria teve nota igual a 8.9
$nota{0} é 8.9

Para apagar uma chave e o seu valor associado, usa-se a função “delete”. Por exemplo, suponha que queremos eliminar a chave “Pedro” do exemplo acima. Então, basta definirmos no programa

delete $nota{"Pedro"};

Para acessar a chave e o valor de cada elemento da matriz associativa pode-se usar a função each. Cada vez que a função é chamada, ela retorna um elemento diferente da matriz.

# arquivo: teste12.pl
%nota = ("Ana", 8.5, "João", 9.2, "Maria", 10.3, "Pedro", "faltou");
while (($aluno, $grau) = each(%nota))
{
print "Nota de $aluno é $graun";

}

A saída de teste12.pl é

Nota de Ana é 8.5
Nota de Pedro é faltou
Nota de Maria é 10.3
Nota de João é 9.2

Note que as informações não foram recuperadas na mesma ordem em que foram armazenadas. Por exemplo, “Pedro” foi a última chave definida no exemplo acima, entretanto, esta é a segunda chave listada. A explicação para isto é simples. Uma matriz associativa é na realidade uma tabela do tipo hash, ou seja, existe uma função (interna do perl) que calcula em cima do valor da chave um índice dentro da tabela onde o elemento é armazenado. A recuperação da informação usando a função “each” é feita de forma sequencial, pecorrendo a tabela, e portanto, diferente da ordem de armazenamento.

Para recuperar a chave ou o valor de um elemento da matriz associativa pode-se usar a estrutura “foreach” junto com os parâmetros “keys” e “values”.

# arquivo: teste13.pl
%nota = ("Ana", 8.5, "João", 9.2, "Maria", 10.3, "Pedro", "faltou");
foreach $aluno (keys %nota)
{
print "Aluno: $alunon";

}
foreach $grau (values %nota)
{
print "nota: $graun";
}

A execução de teste13.pl nos fornece o seguinte resultado:

Aluno: Ana
Aluno: Pedro
Aluno: Maria
Aluno: João
nota: 8.5
nota: faltou
nota: 10.3
nota: 9.2

É possível converter uma matriz associativa em uma matriz comum como mostra o exemplo abaixo.

# arquivo: teste14.pl
%nota = ("Ana", 8.5, "João", 9.2, "Maria", 10.3, "Pedro", "faltou");
@lista = %nota;
print "@listan";

A saída de teste14.pl é

Ana 8.5 Pedro faltou Maria 10.3 João 9.2

O Perl possui uma matriz associativa especial chamada %ENV. Esta matriz guarda as variáveis de ambiente utilizadas pelo UNIX. Para ver o valor dessas variáveis, basta digitar o programa abaixo.

# arquivo: teste15.pl
while (($chave, $valor) = each(%ENV))
{
print "$chave = $valorn";
}


Estruturas de Controle

Operadores

a) Aritméticos

= atribuição
+= atribuição com soma
-= atribuição com subtração
+ soma
- subtração
* multiplicação
/ divisão
% resto de divisão
** expoente
++ incremento
-- decremento

b) Boolenanos (para números)

== igual a
!= diferente de
< menor que
<= menor que ou igual a
> maior que
>= maior que ou igual a
<=> retorna -1 se menor, 0 se igual, 1 se maior

c) Strings

= atribuição
. concatenação
x repetição
eq igual a
ne diferente de
lt menor que
le menor que ou igual a
gt maior que
ge maior que ou igual a
cmp retorna -1 se menor, 0 se igual, 1 se maior

d) Lógicos

&& e (AND lógigo)
|| ou (OR lógico)
! não (NOT lógico)


if

Este comando possui a seguinte estrutura

if (condição)
{
comandos
}
else
{
comandos
}O comando “if” permite testes condicionais, ou seja, um conjunto de comandos só é executado se a condição explicitada for verdadeira. Caso a condição seja falsa, são executados os comandos do “else” (se existir “else”). Além disso, é possível definir “if” dentro de um outro “if” ou dentro de um “else”.

O exemplo abaixo compara o nome fornecido pelo usuário com o nome do usuário que logou no sistema Linux.

# arquivo: teste16.pl
print “Digite o seu nome: n”; # pede que usuário digite nome
$nome = ; # recebe nome via teclado
chomp($nome); # remove caracter Enter
$nome_amb = $ENV{“USER”}; # usuário que logou a máquina
if ($nome ne $nome_amb) # compara nomes
{
print “Você não é usuário autorizadon”;
}
else
{
print “Como vai, $nome?n”;
}

for

Este comando possui a seguinte estrutura:

for (comandos iniciais; condições; incremento/decremento)
{
comandos do laço
}

onde

  • cmds.inic.: é usado para inicializar uma ou mais variáveis;
  • condições : os comandos do loop são executados enquanto estas
  • condições forem verdadeiras (testa condições e só então executa os comandos);
  • inc/dec : usado para incrementar/decrementar variáveis após cada execução dos comandos que estão dentro do laço.

O exemplo abaixo mostra três variáveis distintas: a primeira variável é incrementada em 1 a cada execução do laço, a segunda variável é decrementada em 1 e a terceira variável é incrementada em 2.

# arquivo: teste17.pl
for ($i=1,$j=3,$k=0;$i&lt;=10 && $j&gt;0 && $k&lt;10; $i++,$j--,$k+=2)
{
print "$i = $i, $j = $j, $k = $kn";
}

A saída do programa acima é

$i = 1, $j = 3, $k = 0
$i = 2, $j = 2, $k = 2
$i = 3, $j = 1, $k = 4

Note que após 3 execuções do laço, temos $i=4, $j = 0 e $k = 6, como isto não satisfaz a segunda condição ($j > 0), a execução do “for” é encerrada.

while

O comando while tem a seguinte estrutura

while (condições)
{
comandos
}

onde os comandos dentro das chaves são executados repetidamente enquanto as condições descritas pelo “while” forem verdadeiras. O exemplo abaixo solicita a identificação do usuário. Enquanto o nome fornecido não for igual ao do usuário que iniciou a sessão, o programa fica preso dentro do laço do “while”.

# arquivo: teste18.pl
$nome_amb = $ENV{"USER"};
$nome = "";
while ($nome ne $nome_amb)
{
print "Digite o seu nome: n";
$nome = ; # ler do teclado
chomp($nome); # remove caracter Enter

}
print"Como vai, $nome?n";


do while

Este comando tem a seguinte estrutura

do
{
comandos
}
while (condições)A diferença entre “do while” e “while” consiste que a primeira estrutura executa pelo menos uma vez (executa e testa), enquanto a segunda estrutura testa antes de executar a primeira vez (testa e executa). Abaixo mostramos o exemplo anterior usando a estrutura “do while”. Note que não precisamos inicializar a variável $nome neste exemplo, pois não é feito nenhum teste com esta variável antes que o usuário entre com o nome pela primeira vez.

# arquivo: teste19.pl
$nome_amb = $ENV{“USER”};
do
{
print “Digite o seu nome: n”;
$nome = ;
chomp($nome); # remove caracter Enter
}
while ($nome ne $nome_amb);
print”Como vai, $nome?n”;Podemos substituir o while do exemplo acima por um until. Neste caso, o laço é executado até que a condição se torne verdadeira. Para ver como isto funciona, experimente trocar o while acima por

until ($nome eq $nome_amb);Note que é necessário modificar a condição, pois o laço é agora executado até (until) que o nome digitado seja igual ao nome do usuário do sistema.

foreach

Este comando ler uma linha de uma matriz ou de um arquivo. No exemplo abaixo temos uma lista de filmes brasileiros e o comando é usado para imprimir esta lista. Note que a cada passo do laço, um elemento da lista é lido e armazenado na variável $nome. Se a lista fosse vazia, os comandos dentro do bloco não seriam executados.

# arquivo: teste20.pl
@filmes = ("Central do Brasil", "Gêmeas", "Bossa Nova", "Villa-Lobos");
$i = 1;
foreach $nome(@filmes)
{
print "$i - $nomen";

$i++;
}

O resultado da execução do script acima é

1 - Central do Brasil
2 - Gêmeas
3 - Bossa Nova
4 - Villa-Lobos


Arquivos

Abrir um arquivo

A sintaxe do comando é

open(nome interno, nome real)

Por exemplo,

open(ARQ,'/etc/passwd');

O comando acima abre o arquivo “/etc/passwd” para leitura e associa este arquivo ao nome ARQ. É possível substituir o segundo parâmetro por uma variável como mostramos a seguir.

$nome_arq = '/etc/passwd';
open(ARQ, $nome_arq);

Podemos também abrir um arquivo para gravação ou para adicionar no final do arquivo. Para isso, basta adicionarmos > ou >> antes do nome real do arquivo.

Ao abrir um arquivo para gravação, se este arquivo já existe, ele é destruído e criado novamente; se o arquivo não existe, ele é apenas criado. Para abrirmos o arquivo teste.txt para gravação, podemos digitar

$nome_arq = 'teste.txt';
open(ARQ, ">$nome_arq");

ou

open(ARQ, '>teste.txt');

Ao abrir um arquivo para adição, se o arquivo ainda não existe ele é criado. Para abrirmos o arquivo teste.txt para adição, podemos digitar

$nome_arq = 'teste.txt';
open(ARQ, ">>$nome_arq");

ou

open(ARQ, '>>teste.txt');

Para abrir a entrada ou a saída padrão (normalmente, teclado e tela), basta digitar

open(ARQ, '-'); # abre entrada padrão
open(ARQ, '>-'); # abre saída padrão


Ler e escrever em um arquivo

Para ler um arquivo texto, basta informar o nome do arquivo e direcionar a leitura para uma matriz.

@linhas_arq = ;Para escrever em um arquivo, usa-se o comando print seguido do nome do arquivo e da informação a ser gravada.

print ARQ “teste de gravaçãon”;

Fechar um arquivo

Para fechar um arquivo basta fornecer o nome interno (lógico) do arquivo.

close(ARQ);

Exemplos

Veja agora o exemplo completo que abre, ler, fecha e imprime o conteúdo do arquivo “/etc/passwd”.

# arquivo: teste21.pl
$nome_arq = ‘/etc/passwd’;
open(ARQ, $nome_arq);
@linhas_arq = ;
close(ARQ);
print @linhas_arq;Abaixo temos um outro exemplo de manipulação de arquivos, onde é feita a gravação de uma string no arquivo teste.txt

# arquivo: teste22.pl
open(ARQ, ‘>teste.txt’);
print ARQ “teste de gravaçãon”;
close(ARQ);

Subrotinas

No Perl pode-se definir subrotinas (funções) no início ou no fim do programa. A estrutura básica de uma subrotina é a seguinte

sub nome_da_subrotina
{
comandos da subrotina
}<pre>

Para chamar uma subrotina é preciso colocar o caracter & antes do nome da subrotina. Se não existe passagem de parâmetros na chamada, basta digitar 

<pre>&nome_da_subrotina;

Caso haja passagem de parâmetros na chamada, digite

&nome_da_subrotina(parâmetro 1, parâmetro 2, ..., parâmetro n);

Note que na especificação da subrotina não existe definição de parâmetros, entretanto, quando chamamos uma subrotina podemos passar um ou mais parâmetros. Isto se deve ao fato do Perl assumir que os parâmetros são passados através da variável especial @_. Portanto, para imprimir os parâmetros recebidos em uma subrotina, basta incluir na respectiva subrotina o seguinte comando

print "@_n";

Para acessar o i-ésimo elemento de @_, usa-se a variável especial $_[i-1]. Logo, $_[0] é o primeiro elemento de @_,

$_[1] é o segundo elemento de @_, e assim por diante.

Uma observação importante sobre subrotinas diz respeito ao escopo das variáveis: as variáveis criadas nas funções são variáveis globais, ou seja, um variável criada dentro de uma subrotina, continua a existir após o término da subrotina e pode portanto, ainda ser manipulada. Para declarar variáveis locais (são destruídas após o término da subrotina) use o seguinte comando

local(variável 1, variável 2, ..., variável n);

Abaixo mostramos um exemplo com chamada de subrotina e passagem de parâmetro. O objetivo do script é calcular o fatorial de um número fornecido pelo usuário. No programa principal pedimos ao usuário que forneça um número e usamos para ler este número e armazená-lo na variável $num. Em seguida, chamamos a função chomp() que elimina o caracter Enter digitado pelo usuário após o número. O próximo passo do programa chama a subrotina fatorial tendo como parâmetro o número digitado ($num). Note que armazenamos o resultado da execução da subrotina fatorial na variável escalar $resultado. Por último, o programa principal imprime o valor do fatorial calculado. Na subrotina fatorial, definimos duas variáveis locais: $n e $fat. A primeira variável local é usada para armazenar o parâmetro recebido (esta atribuição não é necessária, pode-se usar @_[0] no corpo da subrotina) e a segunda variável local é utilizada no cálculo do fatorial. O fatorial de $num é calculado em seguida usando o comando “for”. A última linha de comando da subrotina (“$fat;”) retorna o resultado do cálculo ao programa principal. É importante observar que é possível usar a instruçâo “return” para retornar explicitamente um valor e encerrar a execução da subrotina. Por exemplo, você pode substituir “$fat;” na última linha da subrotina fatorial por “return $fat;”.

# arquivo: teste23.pl
sub fatorial
{
local($n, $fat);
$n = $_[0];
$fat = 1;
for ($i = 1; $i <= $n; $i++)
{
$fat *= $i;
}
$fat;
}
# programa principal
print "Digite um númeron";
$num = ;
chomp($num);
$resultado = &fatorial($num);
print "Fatorial de $num é $resultadon";

Note que a variável $i criada na subrotina fatorial do exemplo acima não foi definida como variável local. Portanto, ela continua a existir após a execução da subrotina. Você pode, por exemplo, incluir o seguinte comando no final do programa principal (após ou antes do último comando print)

print "$i = $in";

Neste caso, o programa irá imprimir o valor de $i que é igual ao valor da variável $num acrescido de 1 (esta é a condição de saída do laço “for”). Outra observação importante diz respeito ao escopo das variáveis especiais do script teste23.pl: se você alterar o valor de $_[0] dentro da subrotina fatorial, o valor de $num na rotina principal também será modificado pois eles correspondem a mesma variável no Perl. Isto significa que o Perl usa passagem implícita de parâmetros por referência, ou seja, o Perl sempre trabalha com endereço de variáveis na passagem de parâmetros. Assim, ao manipularmos a variável $_[0] em uma subrotina, estamos, na realidade, trabalhando com a primeira variável definida na chamada da subrotina, apenas com um nome diferente.

O exemplo teste24.pl mostra mais um exemplo de subrotina com passagem de parâmetros. Neste programa, é calculada a média das três avalições feitas pelo aluno e é verificado se o aluno deve ou não fazer a quarta avaliação.

# arquivo: teste24.pl
sub calcula_media
{
printf "Notas: @_ n";
local($a1, $a2, $a3) = @_;
if (($a1 + $a2 >= 14) || ($a1 + $a3 >= 14) || ($a2 + $a3 >= 14) ||
($a1 + $a2 + $a3 >=15))
{
print "Parabéns! Você já estar de férias.n";
}
else
{
print "Você precisa fazer A4.n";
}
}
print "Digite a nota de A1n";
$num1 = ;
chomp($num1);
print "Digite a nota de A2n";
$num2 = ;
chomp($num2);
print "Digite a nota de A3n";
$num3 = ;
chomp($num3);
&calcula_media($num1, $num2, $num3);

Podemos aqui fazer duas observações em relação ao exemplo acima. Primeiro, podemos juntar definição e inicialização de variáveis locais em um único comando como mostra a segunda linha da subrotina calcula_media. Segundo, a subrotina calcula_media retorna valor 1, embora este valor não seja nem armazenado e nem utilizado pelo programa principal.Isto ocorre porque o último comando executado na subrotina é o “print” que, quando funciona corretamente, retorna o valor 1.

Suponha que queremos passar como parâmetro uma matriz ao invés de um conjunto de variáveis escalares. Por exemplo, no script teste24.pl, poderíamos fazer a seguinte alteração na chamada da subrotina:

@lista = ($num1, $num2, $num3);
&calcula_media(@lista);

O Perl transforma a matriz, na passagem de parâmetros, em um conjunto de variáveis escalares. Portanto, para o exemplo acima temos: $_[0] = @lista[0], $_[1] = @lista[1] e $_[2] = @lista[2]. Se neste exemplo acrescentássemos uma escalar logo após a matriz, esta variável corresponderia a $_[3] na subrotina chamada. É fácil ver que a subrotina não identifica quais as estruturas de dados que está recebendo. Tudo é passado como um conjunto de variáveis escalares.

Caso seja importante identificar, dentro da subrotina chamada, os tipos de estruturas de dados (escalar, matriz ou matriz associativa), devemos passar explicitamente o endereço (referência) das estruturas Perl para a subrotina.

Para criar a referência de uma variável basta colocar uma barra invertida (“”) antes do nome da variável. Uma referência é um escalar e portanto, pode ser usado em qualquer situação onde um escalar pode ser usado. Por exemplo,

$ref_a = $a;

faz com que $ref_a receba o endereço da variável $a. Da mesma forma, também podemos armazenar endereços de matrizes e de matrizes associativas.

Para recuperar o conteúdo de um endereço, basta colocar $, @ ou % diante da variável que contém o endereço, dependendo se a referência é de uma escalar, de uma matriz ou de uma matriz associativa, respectivamente. Podemos, então, digitar

$valor = $$ref_a;

para recuperar o valor de $a do exemplo acima.

A seguir, mostramos o exemplo teste25.pl onde uma subrotina é chamada duas vezes no mesmo programa. Na primeira chamada são passados dois parâmetros por referência (uma matriz e uma escalar) e na segunda chamada são passados três parâmetros (uma matriz e duas escalares). Note que, neste exemplo, temos alguns argumentos na definição da subrotina. Estes argumentos definem os tipos de parâmetros passados por referência. São possíveis símbolos que podemos usar como argumentos de subrotina

$ escalar
@ matriz
% matriz associativa

Além disso, o ponto-e-vírgula na lista de argumentos de teste25.pl separa os argumentos obrigatórios dos argumentos opcionais. Como última observação, note que os endereços recebidos estão entre chaves quando acessamos o conteúdo destes endereços. Isto é para evitar erro de interpretação por parte do Perl em relação à variável especial $_.

# arquivo: teste25.pl
sub imprime_lista(@$;$)
{
@letras = @{$_[0]};
$n1 = ${$_[1]};
if ($_[2])
{
$n2 = ${$_[2]};
print "@letras = @letras, $n1 = $n1, $n2 = $n2n";
}
else
{
 print "@letras = @letras, $n1 = $n1n";
}
}
# programa principal
@lista = ("a", "b");
$num1=100;
$num2=200;
print "Primeira chamada com dois parâmetrosn";
&imprime_lista(@lista,$num1);
print "Segunda chamada com três parâmetrosn";
&imprime_lista(@lista,$num1,$num2);

Manipulação de Strings

O PERL PERMITE verificar se existe uma determinada expressão dentro de uma string. A expressão a ser procurada é colocada entre duas barras para comparação. Existem dois operadores que podem ser utilizados: =~ e =!. O operador =~ retorna verdade se a expressão é encontrada e o operador =! retorna verdade se a expressão não é encontrada. O exemplo abaixo, verifica se existe a expressão ‘pensa’ na string armazenada na variável $frase.

# arquivo: teste26.pl
$frase = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
if ($frase =~ /pensa/)
{
print "Encontroun";
}
 else
{
print "Não encontroun";}

Podemos substituir o operador =~ do exemplo acima pelo operador != e ainda assim, com uma pequena alteração no código do programa, obtermos o mesmo resultado.

# arquivo: teste26.pl
$frase = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
if ($frase !~ /pensa/)
{
print "Não encontroun";
}
else
{
print "Encontroun";
}

Podemos também usar a variável especial $_ para armazenar a string que será usada na pesquisa. Neste caso, não há necessidade de especificar a variável na comparação pois $_ é a variável padrão do Perl. Veja abaixo uma nova versão para teste26.pl usando esta variável especial.

# arquivo: teste26.pl
$_ = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
if (/pensa/)
{
print "Encontroun";
}
else
{
print "Não encontroun";
}

Existem alguns caracteres especiais que podem ser usados na comparação de strings. Por exemplo,

. : substitui qualquer caracter exceto newline
^ : o início da linha ou do caractere
$ : o fim da linha ou do caractere
* : nenhum, um ou mais de um do último caractere
+ : um ou mais de um do último caractere
? : nenhum ou o último caractere
[] : define um grupo de caracteres que pode estar na string (se
existir o caractere ^ antes dos caracteres significa que o grupo de caracteres não pode estar na string)
| : representa ou

Os seguintes testes serão verdadeiros se os incluirmos no programa teste26.pl visto acima:

$frase =~ /{Pp]ens.r/ # encontra 'pensar'
$frase =~ /pr[a-z]*re/ # encontra 'procure'
$frase =~ /[Mm]a[i]*s/ # encontra 'Mas' e 'mais'
$frase =~ /Ma[i]?s/ # encontra 'Mas'
$frase =~ /[Pp]ens[a-z]*/ # encontra 'Pense' e 'pensar'
$frase =~ /pr[a-z]+/ # encontra 'procure' e 'precisam'
$frase =~ /[Pp]ens[^a]+/ # encontra 'Pense'
$frase =~ /[Pp]ens[a|e]/ # encontra 'Pense' e 'pensa'

Podemos também substituir a expressão encontrada em uma string por outra ao invés de apenas verificar se ela existe. Para isso, basta usar a estrutura

s/expressão original/nova expressão/gi

onde

s : informa que é uma substituição
g : em todas as ocorrências (se este parâmetro não for informado, apenas
a primeira ocorrência encontrada na string é modificada)
i : ignora diferenças entre letras maiúsculas e letras minúsculas

Podemos, por exemplo, incluir no programa teste26.pl:

$frase =~ s/Mas/Porém/; # altera apenas a primeira ocorrência
$frase =~ s/Mas/Porém/i; # não é case sentive
$frase =~ s/Mas/Porém/g; # altera todas as ocorrências
$frase =~ s/Mas/Porém/gi; # altera todas as ocorrências e não é # case sensitive

Note que, nos exemplos acima, estamos modificando a string armazenada na variável $frase, mas podemos também utilizar a variável especial $_ como variável padrão. Neste caso, basta digitar, por exemplo

s/Mas/Porém/; # altera apenas a primeira ocorrência de $_

É possível também dividir uma string em strings menores e colocar o resultado em uma lista. Para isto basta usar a função split.

@lista = split(/separador/, $string);

onde

@lista : é a variável matriz que recebe o resultado da operação
separador: conjunto de caracteres que indica onde a string será dividida
$string : string a ser dividida, caso não seja informado este parâmetro,
é usada a variável especial $_.

Abaixo, mostramos um exemplo onde uma string é dividida em duas outras strings e o ponto (‘.’) é escolhido como caracter separador. Note que usamos a barra invertida () antes do ponto. O motivo é que o ponto tem função especial no Perl, ao usarmos a barra indicamos que o caracter seguinte (o ponto) não deve ser interpretado.

# arquivo: teste27.pl
$frase = "Pense em si. Mas, procure pensar muito mais nos outros," .
" que precisam de você.";
print "$frasen";
@lista = split(/. /, $frase);
print "@lista[0] = @lista[0]n";
print "@lista[1] = @lista[1]n";

A saída de teste27.pl é

Pense em si. Mas, procure pensar muito mais nos outros, que precisam de você.

Bibliografia

  • Perl – Guia Completo

Ellen Siever, Stephen Spainhour e Nathan Patwardhan Editora Ciência Moderna

  • Programando para Linux

Patrick Volkerding, Eric Foster-Johnson e Kevin Reichard Makron Books




		

Deixe uma resposta

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair / Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair / Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair / Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair / Alterar )

Conectando a %s

%d blogueiros gostam disto: