NAME

Início rápido

LANGUAGE

pt-BR

ABSTRACT

Este tutorial é um guia de início rápido para não programadores sem experiência. Ele procura cobrir o básico e faz isso de forma gradual.

DESCRIPTION

Este tutorial é um guia de início rápido para não programadores sem experiência. Ele procura cobrir o básico e faz isso de forma gradual.

TUTORIAL

Alô, mundo!

Vamos começar com um simples exemplo. Este exemplo é muito comum em tutoriais e livros de programação, e exibe "Alô, mundo". Experimente executar o programa a seguir, você deve conseguir ver a saída correta.

say 'Alô, mundo!'

Aqui, say é uma função que aceita argumentos e os imprime na tela.

Exercício

Experimente consertar o código abaixo para que exiba 'Tchau':

say ''

__TEST__
like($stdout, qr/Tchau/, 'Deve exibir Tchau');

Cinto de segurança

Programadores às vezes cometem erros escrevendo código válido na sintaxe da linguagem, mas que possuem problemas de lógica e geram bugs difíceis de detectar.

Para identificar erros de digitação e outras "pegadinhas", Perl oferece dois pragmas muito úteis: strict e warnings. Recomenda-se usar esses pragmas em todos os seus programas e módulos. Cada exemplo deste tutorial usa implicitamente essas duas linhas antes, elas só não são mostradas para poupar espaço.

Você não precisa entender o código abaixo, apenas veja a diferença entre usar os pragmas de segurança

use strict;
use warnings;

$x += 1;
$y .= 'string';

say 'ok';

e não usá-los

no strict;
no warnings;

$x += 1;
$y .= 'string';

say 'ok';

Números

Números são inteiros (1, -2, 5) e reais (1.2, 1e5). Não há nenhuma diferença entre eles. Perl trata ambos os tipos da mesma forma e converte automaticamente.

Experimente imprimir na tela os seguintes números:

say 1;
say 4.4;
say 1.2e10;

Como pode ver, as declarações são separadas por ;. Isso é como um ponto usado em textos para separar frases.

Operadores aritméticos

Manipulações aritméticas básicas incluem: + (adição), - (subtração), * (multiplicação), / (divisão), ** (expoente) e % (módulo, resto da divisão).

say 1 + (10/5) * 3

Exercício

Exiba o resultado de 5 elevado a 6.

say
__TEST__
like($code, qr/\*\*/, 'Operador ** deve ser usado');
like($stdout, qr/15625/, 'Deve ser 15625');

Strings

Strings são textos livres declarados usando aspas simples ou aspas duplas. A diferença não é importante agora. Em nosso exemplo de Alô Mundo, o 'Alô, mundo' era uma string.

say 'foo'

Operadores e funções básicos para strings

Strings podem ser concatenadas (juntadas) usando o operador . (ponto).

say 'foo' . 'bar'

Com o operador x você pode repetir strings.

say 'foo' x 3;

Normalmente você quer manipular strings para obter seu tamanho, encontrar um símbolo ou substring e assim por diante. As funções básicas incluem length(), substr(), index(), rindex().

say length 'foo';
say substr 'foo', 1, 2;
say index 'foo', 'o';
say rindex 'foo', 'o';

Exercício

Imprima a posição da string 'bol' dentro da string 'Futebol'.

say
__TEST__
like($code, qr/index/, 'Função index deve ser usada');
like($stdout, qr/4/, 'Deve ser posição 4');

Listas

Listas são, bem, listas de valores. Elas são declaradas usando parênteses.

say (1, 2, 3, 5)

Normalmente é possível usar faixas de valores para poupar tempo:

say (1 .. 5)

Isso também funciona com caracteres.

Exercício

Imprima a lista de caracteres de 'b' a 'm'.

say
__TEST__
like($stdout, qr/bcdefghijklm/, 'Deve imprimir bcdefghijklm');

Listas podem naturalmente agrupar não só números, mas também strings:

say (1, 'oi', 2, 'tudo bem?')

Listas usadas dentro de outras listas são 'achatadas':

say (1, (2, 3, 4), 5)

Atribuição e variáveis

Atribuição, em linguagens de programação, é uma operação que armazena um valor em algum lugar da memória do computador, que pode ser acessado por um nome. Esse local de armazenamento é chamado de variável.

Em Perl 5 há três tipos principais de dados: escalares, arrays e hashes (ou arrays associativos). Escalares (scalars) podem armazenar strings e números. Arrays são listas ordenadas de escalares cujo valor é acessado por um índice. Hashes são listas não ordenadas de escalares cujo valor é acessado por chaves. Variáveis que armazenam escalares, arrays e hashes são prefixados com $, @ e %, respectivamente.

Variáveis costumam ser declaradas usando a palavra-chave my. Por exemplo:

my $x = 1;
say $x;

Exercício

Atribua a uma variável chamada y a string 'Alô, mundo! e imprima seu conteúdo.

my $
say
__TEST__
like($code, qr/my\s+\$y/, 'Variável $y deve ser criada');
like($stdout, qr/Alô, mundo!/, 'Deve imprimir "Alô, mundo!"')

Escalares

Dependendo do que a variável guarda (um número, uma string) você poderá usar diferentes operadores.

Digamos que você queira somar dois valores numéricos:

my $x = 1;
my $y = 2;

say $x + $y;

Ou talvez você queira concatenar duas strings diferentes:

my $x = 'Alô';
my $y = 'Você';

say $x . $y

Se você tentar usar + em strings ou . em números as variáveis serão automaticamente convertidas aos seus tipos apropriados.

my $x = 1;
my $y = '2 vezes';

say $x . $y;
say $x + $y;

Como pode ver no segundo exemplo a string '2 vezes' foi convertida para um número, o 2.

Exercício

Concatene e imprima a string 'Resultado=' seguida da soma de 42 com 13.

my $x = ;
my $y = ;

say

__TEST__
like($stdout, qr/Resultado\s*=\s*55/, 'Deve exibir "Resultado=55"');

Arrays

Arrays podem armazenar listas de escalares.

my @array = (1, 2, 3);

say @array;

A manipulação básica de arrays incluem obter o elemento pelo seu índice (começando de 0), obtendo o último índice, empilhando e retirando elementos.

my @array = (1, 2, 3);

# obtém o terceiro elemento
say $array[2];

# obtém o índice do último elemento
say $#array;

push @array, 4;
say @array;

pop @array;
say @array;

shift @array;
say @array;

unshift @array, 0;
say @array;

Como você provavelmente percebeu, ao acessar um elemento do array nós trocamos @ por $, porque o elemento do array é um escalar, e escalares usam o símbolo $.

Exercício

Crie um array com a lista (1, 2, 3, 4) e imprima o terceiro elemento.

my @array = ;
say 

__TEST__
like($stdout, qr/3/, 'Deve imprimir 3')

Hashes

Hashes ou arrays associativos são coleção não ordenadas de escalares que podem ser acessados por uma chave. Essa chave normalmente é uma string.

my %hash = ('chave1', 'valor1', 'chave2', 'valor2');

Em vez de usar vírgula para separar chaves e valores, Perl oferece um operador mais legível, o =>. Por exemplo:

my %hash = (chave1 => 'valuor1', chave2 => 'valor2');

Manipulação básica de hashes

Para acessar um elemento de um hash, colocamos a chave desejada entre chaves {}. Assim como arrays, a variável armazenada é um escalar, então usamos o símbolo $.

my %hash = (chave1 => 'valor1', chave2 => 'valor2');

say $hash{chave1};

Obtendo todas as chaves e valores de um hash

my %hash = (chave1 => 'valor1', chave2 => 'valor2');

say keys %hash;
say values %hash;

Contexto

Contexto é um conceito muito importante em Perl. Existem dois contextos principais: escalar e lista. O contexto normalmente afeta como as funções e variáveis vão se comportar. Isso é parecido com a linguagem natural.

O uso mais popular de contexto é obter o tamanho de um array, por exemplo. Normalmente, quando usamos um array em contexto de lista, ele retorna todos os seus elementos. Mas quando usamos em contexto escalar ele retorna seu tamanho.

my @array = (1, 2, 3);

my @array2 = @array; # contexto de lista
say @array2;

my $length = @array; # contexto escalar
say $length;

Operadores lógicos e de comparação

Antes de introduzirmos os operadores correspondentes em Perl, aqui veremos o básico de álgebra Booleana.

Álgebra Booleana é uma variação da álgebra onde em vez de números temos valores de 'verdade' 0 e 1, onde 1 é chamado verdadeiro e 0 é chamado falso.

Como na álgebra tradicional há operadores como +, *, etc. Os mais básicos são chamados NÃO, E e OU. Como já te contamos, na álgebra Booleana os valores só podem ser Verdadeiro e Falso. Isso significa que eles não só podem ser usados em diferentes operações, como o resultado dessas operações é sempre Verdadeiro ou Falso. Vejamos como isso funciona.

Verdadeiro e Falso

Não existem valores reservados para Verdadeiro e Falso em Perl. Em Perl, Verdadeiro é tudo que não é Falso, onde Falso é tudo que é convertido para 0: o próprio 0, '' (string vazia) e a palavra reservada undef, por exemplo, que indica valores não definidos.

NÃO (NOT)

O operador NÃO é um operador unário, o que significa que ele opera em um único valor. Em Perl, o operador NÃO é o símbolo !. A tabela-verdade do NÃO:

x	!x
0	1
1	0

Vejamos o resultado desse operador em diferentes valores. No exemplo a seguir adicionamos 0 para valores Falsos para que eles não sejam convertidos em uma string vazia pela função say.

say !0;
say !1 + 0;
say !'string that converts to 1' + 0;
say !'';

E (AND)

O operador E é um operador binário, ou seja, que opera em dois valores. Em Perl, o operador E é o símbolo &&. A tabela-verdade do E:

x	y	&&
0	0	0
1	0	0
0	1	0
1	1	1

Vejamos qual o resultado obtido ao usar esse operador em diferentes valores. No exemplo a seguir adicionamos 0 a valores Falsos para que eles não sejam convertidos em strings vazias pela função say.

say 1 && 1;
say 0 && 1;
say 0 && 0;
say 'string' && 1;

OU (OR)

O operador OU também é um operador binário, ou seja, também opera em dois valores. Em Perl, o operador OU é o símbolo ||. A tabela-verdade do OU:

x	y	\|\|
0	0	0
1	0	1
0	1	1
1	1	1

Vejamos qual o resultado de usar esse operador em diferentes valores. No exemplo a seguir nós adicionamos 0 a valores Falsos para que não sejam convertidos em strings vazias pela função say.

say 1 || 1;
say 0 || 1;
say 0 || 0;
say 'string' || 0;

Prioridade

Assim como na álgebra tradicional, na álgebra Booleana os operadores possuem diferentes prioridades, ou seja, alguns são avaliados antes de outros. A ordem dos operadores Booleanos é:

! && ||

Combinações

NÃO, E e OU podem ser combinados em uma única expressão. Você também pode usar parênteses para mudar a ordem das avaliações:

say (1 || 0) && 1

Exercício

Corrija a declaração abaixo introduzindo parênteses para que a operação exiba a string vazia em vez de 1.

say  !1 || 1 && 1
__TEST__
is($stdout, "\n", 'Deve exibir a string vazia');

Operadores de comparação

Operadores de comparação também retornam Verdadeiro e Falso, mas são usados com números e string. Como o Perl não diferencia números e strings, existem grupos de comparação diferentes para números e strings.

==	!=	<	<=	>	>=
eq	ne	lt	le	gt	ge

Vamos tentar esse exemplo:

say 1 == 1;
say 10 > 2;
say 3 <= 3;

say 'foo' ne 'bar';

Condicionais

Declarações condicionais permitem que você mude o fluxo do seu código. Declarações condicionais operam com os valores Booleanos que você aprendeu anteriormente, e incluem if/else/elsif e unless.

Quando o resultado de uma expressão entre parênteses é verdadeiro, o bloco entre chaves é executado:

if (1 == 1) {
    say 'Verdadeiro';
}

if (1 == 0) {
    say 'Falso';
}

Quando também quiser fazer algo sempre que a expressão for falsa, basta usar else:

if (0) {
    say 'Verdadeiro';
}
else {
    say 'Falso';
}

Quando quiser testar várias expressões em sequência, use elsif:

my $x = 1;

if ($x == 0) {
    say 'x é zero';
} elsif ($x < 0) {
    say 'x é menor que zero';
} else {
    say 'x é maior que zero';
}

Há também uma forma mais curta para declarações com if:

my $x = 5;
say 'Verdadeiro' if $x > 0;

O unless é o oposto do if, que executa o bloco quando a expressão é avaliada como falsa.

my $x = 5;
say 'Verdadeiro' unless $x == 0;

Que é a mesma coisa que escrever:

my $x = 5;
say 'Verdadeiro' if !($x == 0);

Como você sabe, em Perl os valores verdade são tudo que não é avaliado como zero, então a comparação com 0 normalmente pode ser omitida:

my $x = 5;
say 'Verdadeiro' unless $x;

Exercício

Corrija o código abaixo para que exiba 'Olá' em vez de Até logo' usando operadores lógicos e sem mudar o valor de $x.

my $x = 0;

if ($x) {
    say 'Olá';
}
else {
    say 'Até logo';
}
__TEST__
like($code, qr/\$x = 0/, 'Não deve mudar o valor de $x');
like($stdout, qr/Olá/, 'Deve exibir "Olá""');

Laços (Loops)

Laços, ou 'loops', são blocos que executam várias vezes. Costumam ser usados em ações repetitivas, manipulando estruturas de dados inteiras, etc.

For/Foreach

O laço Foreach ("para cada") costuma ser usado para varrer listas ou arrays. Por exemplo:

foreach my $elemento (1, 2, 3, 4, 5) {
    say $elemento;
}

Naturalmente, você também pode passar um array:

my @array = (1 .. 5);
foreach my $elemento (@array) {
    say $elemento;
}

Como você pode ver, criamos uma variável especial $elemento que se transforma em cada um dos elementos do array, em cada iteração. Cuidado, pois ao mudar o valor de $elemento você muda o valor original no array:

my @array = (1 .. 5);
foreach my $elemento (@array) {
    $elemento *= 2;
}

foreach my $elemento (@array) {
    say $elemento;
}

Exercício

Imprima apenas os valores pares entre 0 e 10:

foreach my $element (...) {
    if (...) {
        ...
    }
}
__TEST__
like($stdout, qr/0\n2\n4\n6\n8\n10/, 'Deve imprimir apenas elementos pares');

While

O While ("enquanto") é um laço mais avançado que executa enquanto a expressão avaliada for verdadeira.

my $i = 10;
while ($i > 0) {
    say $i;

    $i = $i - 1;
}

Assim que a expressão $i > 0 se tornar falsa, o laço para de rodar.

Exercício

Exiba apenas os valores ímpares entre 0 e 10:

my $i = ;
while ($i ...) {
    if (...) {
        ...
    }
}
__TEST__
like($stdout, qr/1\n3\n5\n7\n9/, 'Deve imprimir valores ímpares');

Saíndo do loop

Em muitos casos você quer terminar o loop sem ter que esperar até ele acabar de rodar. Você pode fazer isso usando a palavra-chave last:

my $i = 0;
while ($i < 100) {
    last if $i == 10;

    say $i;

    $i = $i + 1;
}

Esse laço não vai iterar 100 vezes porque nós interrompemos ele quando o $i vale 10.

Variável Padrão

A variável especial mais utilizada é a $_, que é a variável escalar padrão. Para entender melhor como ela funciona vamos olhar alguns exemplos.

Você já está familiarizado com a função say. Ela imprime na tela tudo que você passar pra ela como argumento. Mas o que acontece quando você não passa nenhum argumento? Ela pega o valor que estiver na variável $_.

$_ = 'Hello';
say;

Claro que você normalmente não precisa dessa funcionalidade, mas pode ser muito útil dentro de laços, por exemplo:

say for (1 .. 10);

Por padrão, o laço for define a variável $_ com o valor atual da iteração, e então chamamos o say para imprimi-lo.

Muitas funções do Perl usam a variável padrão quando nenhum argumento é passado.

Subrotinas

Subrotinas são funções que aceitam argumentos e podem retornar um resultado. Normalmente, subrotinas são usadas para evitar código duplicado, deixando tudo mais claro e fácil de entender.

Digamos que você queira converter 5 milhas para quilômetros. Você pode escrever algo assim:

# Converta 5 milhas para km
say 5 * 1.609344

Mas e se você quisesse converter 10 milhas para quilômetros, ou converter qualquer outro número? Nesse caso podemos criar uma subrotina e usá-la várias vezes.

sub milhas_para_quilometros {
    my ( $milhas ) = @_;

    return $milhas * 1.609344;
}

say milhas_para_quilometros(5);
say milhas_para_quilometros(10);
say milhas_para_quilometros(42);

Essa subrotina precisa de um pouco de explicação. A linha que diz my ( $milhas ) = @_ é chamada atribuição de argumentos. Em Perl, todos os argumentos passados para a sua subrotina ficam no array padrão @_ (que também é uma variável especial do Perl, como o $_). Você pode, claro, usar todas as funções de manipulação de arrays na variável padrão de array.

Exercício

Escreva e use uma subrotina que converta quilômetros em milhas e imprima a conversão de 4, 6 e 9 quilômetros em milhas (1 km são 0.621371192 milhas).

sub quilometros_para_milhas {
    my ...

    return ...
}

say quilometros_para_milhas(4);
say quilometros_para_milhas(6);
say quilometros_para_milhas(9);

__TEST__
like($stdout, qr/2.485484768\n3.728227152\n5.592340728/,
    'Deve imprimir os valores corretos')

AUTHOR

Viacheslav Tykhanovskyi, vti@cpan.org

TRANSLATOR

Breno G. de Oliveira, garu@cpan.org

POD ERRORS

Hey! The above document had some coding errors, which are explained below:

Around line 3:: Non-ASCII character seen before =encoding in 'Início'. Assuming UTF-8

Files

quick-start.pt-BR.pod

Latest commit

History

quick-start.pt-BR.pod

File metadata and controls

NAME

LANGUAGE

ABSTRACT

DESCRIPTION

TUTORIAL

Alô, mundo!

Exercício

Cinto de segurança

Números

Operadores aritméticos

Exercício

Strings

Operadores e funções básicos para strings

Exercício

Listas

Exercício

Atribuição e variáveis

Exercício

Escalares

Exercício

Arrays

Exercício

Hashes

Obtendo todas as chaves e valores de um hash

Contexto

Operadores lógicos e de comparação

Verdadeiro e Falso

NÃO (NOT)

E (AND)

OU (OR)

Prioridade

Combinações

Exercício

Operadores de comparação

Condicionais

Exercício

Laços (Loops)

For/Foreach

Exercício

While

Exercício

Saíndo do loop

Variável Padrão

Subrotinas

Exercício

AUTHOR

TRANSLATOR

POD ERRORS