O documento fornece uma visão geral da linguagem Perl, incluindo sua criação, pontos fortes e fracos, semelhanças com outras linguagens e exemplos de código. Ele aborda estruturas de controle como if-else, unless, while, for e foreach, além de operações aritméticas e manipulação de strings. Também discute o funcionamento de subprogramas e rotinas, destacando a flexibilidade na passagem de parâmetros.

1. Tiago Roberti Sampaio

2. Criação
 Criada por Larry Wall em 1987
 Originária do shell scripting,
AWK, SED e a linguagem C
 Nome em referência à Parábola da Pérola, de
Mateus 13

3. Pontos Fortes
 Estável e multiplataforma
 Arrays indexados e associativos
 Processamento de cadeia (strings) e pattern
matching através de expressões regulares
 Adequada para o desenvolvimento utilizando
metodologias ágeis.
 Alocação de memória automática
 General Public License, Licença artística

4. Pontos Fracos
 O código é difícil de ler/perceber e pode
tornar-se demasiado obscuro
 Não tem suporte fácil para estruturas

5. “As três principais virtudes de um programador são:
impaciência, preguiça e arrogância.”

6. Semelhanças
 Linguagem C: variáveis, expressões,
atribuições, blocos de código delimitados,
estruturas de controle e sub-rotinas.
 Shell Script: Variáveis escalares são
precedidas por “$”.
 Lisp: Listas.
 AWK: Arrays Associativas (hash).
 SED: Expressões regulares.

7. Tipos de Dados
O Perl é considerada não-tipada; as variáveis
não são restringidas a usar um único tipo.
Escalar Array Hash

8. Exemplos de Código
 A primeira linha de um código em Perl deve sempre começar com o
shebang:
 Programa Olá Mundo!
 Comentário

9. Expressão Regular
O programa a seguir lê um texto e substitui qualquer ocorrência da
string "foo" por "bar", imprimindo a linha transformada na tela:
É possível obter o mesmo resultado com uma única linha (um "one-liner"):

10. Estruturas de Seleção
if –
É igual ao if já conhecido em C/C++, é feito uma verificação e caso essa
verificação seja verdadeira, ele executa o bloco, caso contrário ele salta para o
próximo comando depois do bloco. A sua estrutura geral é:
if(expressão) {
bloco
}
if-else –
Ao contrário do if, que é uma estrutura de seleção unidirecional, o if-else é uma
estrutura de seleção bidirecional, pois é analisada a expressão da mesma forma
que é feita no if, se a expressão for verdadeira é executada a expressão do bloco
do if (bloco 1), porém caso seja falso é executada o bloco do else (bloco 2). A sua
estrutura geral é:
//if(expressão){
bloco1
}else{
bloco2
}//

11. Estruturas de Seleção
//if (expressão 1){ if(expressão 1){
bloco1 bloco1
}elsif (expressão 2){ ==> }else{
bloco2 if(expressão 2){
}
bloco2
}
}//
unless –
O unless é usado como uma forma alternativa para executar o else de um if-else,
oque significa que o bloco do unless, só é executado se a expressão for avaliada
como falsa. Isto pode ser considerado um aspecto positivo para a legibilidade do
código, pois evita que você tenha que negar uma expressão em um comando if,
para ter esse mesmo efeito, isso é, a linguagem já te oferece esse artifício, porém
é um ponto negativo para a ortogonalidade, já que faz com que a linguagem
tenha mais de uma maneira de fazer a mesma coisa. A sua estrutura geral é:
//unless (expressão){
bloco
}//

12. Estruturas de Iteração
while –
Funciona como uma estrutura if, porém com o adicional de que o bloco dele é
executado enquanto o valor da expressão for verdadeira. Sua forma geral é:
while (expressão){
bloco
}
until –
Seu funcionamento é igual ao do while, ele executa o bloco até que a expressão
seja avaliada como falsa, isso é, o mesmo que enquanto for verdadeiro.
Novamente temos um ponto negativo na ortogonalidade, pois o programador
poderia simplesmente usar a estrutura while com o mesmo propósito. Sua forma
geral é:
//until (expressão){
bloco
}//

13. Estruturas de Iteração
for –
Essa estrutura de iteração tem o diferencial de ser contado. Ele usa três
parâmetros, inicialização, expressão e incremento. Em um primeiro momento é
feito a inicialização, geralmente de uma variável que será usada na expressão,
num segundo momento, é feito a verificação da expressão, se for verdadeira é
executado o bloco, caso contrario o fluxo do programa salta para a próxima
instrução depois dessa estrutura. Caso execute o bloco, em um momento final, é
feito a parte do incremento, em seguida é novamente analisada a expressão,
formando um ciclo entre expressão-bloco-incremento. Embora isso seja um
padrão de uso, a linguagem não prende o programador a isto, o programador
pode fazer qualquer coisa (executar qualquer comando) nos campos de
inicialização e de incremento. Sua forma geral é:
for( inicialização ; expressão ; incremento ){
bloco
}

14. Estruturas de Iteração
foreach –
O foreach é uma estrutura de iteração que executa a mesma parte do código,
para cada elemento de um vetor, como se fosse um for normal que executa um
bloco n vezes, onde n é o tamanho do vetor e no inicio do bloco uma variável
escalar recebe o valor do vetor na posição i, com i variando da primeira posição
até a ultima posição do vetor. A estrutura foreach é formada por um vetor e
pode ter, ou não, uma variável escalar para receber o valor do vetor. Essa
estrutura, provê um ponto negativo na legibilidade, pois é uma estrutura que só
entende quem já tiver tido um conhecimento prévio da linguagem, porém da um
ponto positivo na escrita, pois é uma estrutura que facilita muito para um
programador percorrer um vetor. Sua forma geral pode ser da seguintes formas:
//foreach $var (@an_array) {
Bloco
}//
ou
foreach (@an_array) {
//Bloco
}

15. Instruções Compostas
if (EXPR) BLOCK
if (EXPR) BLOCK else BLOCK
if (EXPR) BLOCK elsif (EXPR) BLOCK ...
if (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
unless (EXPR) BLOCK
unless (EXPR) BLOCK else BLOCK
unless (EXPR) BLOCK elsif (EXPR) BLOCK ...
unless (EXPR) BLOCK elsif (EXPR) BLOCK ... else BLOCK
while (EXPR) BLOCK
while (EXPR) BLOCK continue BLOCK
until (EXPR) BLOCK
until (EXPR) BLOCK continue BLOCK

16. Instruções Compostas
for (EXPR; EXPR; EXPR) BLOCK
for VAR (LIST) BLOCK
for VAR (LIST) BLOCK continue BLOCK
foreach (EXPR; EXPR; EXPR) BLOCK
foreach VAR (LIST) BLOCK
foreach VAR (LIST) BLOCK continue BLOCK

17. Operações e Atribuições
aritiméticas
Operações aritméticas:
– $a = 1 + 2; # Add 1 and 2 and store in $a
– $a = 5 * 6; # Multiply 5 and 6
– $a = 9 ** 10; # Nine to the power of 10
– $a = 5 % 2; # Remainder of 5 divided by 2
– ++$a; # Increment $a and then return it
– $a++; # Return $a and then increment it

18. Operações e Atribuições
• Strings:
– $a = $b . $c; # Concatenate $b and $c
– $a = $b x $c; # $b repeated $c times
• Atribuições:
– $a = $b; # Assign $b to $a
# Faz cópia de $a
– $a += $b; # Add $b to $a
– $a -= $b; # Subtract $b from $a
– $a .= $b; # Append $b onto $a

19. Operações em Strings
$nome = “Curso de Aperfeicoamento”;
$new_string = substr($ nome, 3);
print $new_string;
# ”so de Aperfeicoamento”
$ new_string = substr($ nome, 0, 5);
print $new_string;
# ”Curso”
substr($nome_var, inicio, tamanho)

20. Simbologia

22. Subprogramas e Rotinas
sub maximum {
if ($_[0] > $_[1]) {
$_[0];
} else {
$_[1];
}}
$biggest = &maximum(37, 24); # $biggest is 37
Valor de retorno é o último avaliado.
sub printargs {
print "@_n";
}
&printargs("perly", "king");
# Example prints "perly king"
&printargs("frog", "and", "toad");
# Prints "frog and toad"

23. Subprogramas e Rotinas
Os argumentos de funções chegam no array @_. Dentro da função você
precisa pegar os argumentos dessa lista e fazer as validações necessárias.
sub escrever_dados {
my ($nome, $cidade) = @_;
print "Nome: $nome, cidade: $cidaden";
}
escrever_dados('Mary', 'Rio de Janeiro');

24. Subprogramas e Rotinas
Parâmetros a mais ou a menos na chamada à função não resultam em erro
algum. O que pode ser feito é validar dentro da função a quantidade e tipo
dos parâmetros, mas torna o código extremamente repetitivo e mais sujeito
a erros.
sub escrever_dados {
if (scalar @_ != 2) {
print "Função espera 2 argumentosn";
return 0;
}
my ($nome, $cidade) = @_;
print "Nome: $nome, cidade: $cidaden";
}
escrever_dados('Mary', 'Rio de Janeiro', 'Vai dar erro');
escrever_dados('Também vai dar erro');
escrever_dados(); # Lista vazia (scalar 0) também dá erro