Tiago Roberti Sampaio

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

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

Pontos Fracos

O código é difícil de ler/perceber e pode tornar-se demasiado obscuro

Não tem suporte fácil para estruturas

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

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.

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

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

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"):

Estruturas de Seleçãoif –É 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}//

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}//

Estruturas de Iteraçãowhile –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}//

Estruturas de Iteraçãofor –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}

Estruturas de Iteraçãoforeach –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}

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) BLOCKwhile (EXPR) BLOCK continue BLOCK

until (EXPR) BLOCKuntil (EXPR) BLOCK continue BLOCK

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

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

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

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)

Simbologia

Subprogramas e Rotinassub maximum {if ($_[0] > $_[1]) {$_[0];} else {$_[1];}}$biggest = &maximum(37, 24); # $biggest is 37Valor de retorno é o último avaliado.

sub printargs {print "@_\n";}&printargs("perly", "king");# Example prints "perly king"&printargs("frog", "and", "toad");# Prints "frog and toad"

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: $cidade\n";} escrever_dados('Mary', 'Rio de Janeiro');

Subprogramas e RotinasParâ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 argumentos\n"; return 0; } my ($nome, $cidade) = @_; print "Nome: $nome, cidade: $cidade\n";} 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