A Aldeia Numaboa ancestral ainda está disponível para visitação. É a versão mais antiga da Aldeia que eu não quis simplesmente descartar depois de mais de 10 milhões de pageviews. Como diz a Sirley, nossa cozinheira e filósofa de plantão: "Misericórdia, ai que dó!"

Se você tiver curiosidade, o endereço é numaboa.net.br.

Leia mais...

Informática Numaboa - Tutoriais e Programação

Linguagem Perl - Operadores

Sex

21

Nov

2008


10:56

(6 votos, média 3.00 de 5) 


Neste tutorial são apresentados os operadores da linguagem Perl e a forma como são usados. Alguns exemplos deixam mais claras as aplicações. Vamos lá, arregacem as mangas!

Operador de Atribuição

Sem dúvida nenhuma, é o operador mais usado. Para atribuir um valor a uma variável escalar, o operador de atribuição é o sinal de igual =. Exemplos:

$Nome = "Pedro Bó"; $Codigo = 4711;

Operadores Relacionais

Os operadores relacionais também são conhecidos como operadores de comparação. São utilizados quando se quer comparar dois valores, por exemplo, o valor atual de uma escalar comparado a um valor fixo. Exemplos:

if($RazaoDeViver == 42) { print "Você entendeu a vida !\n"; } if($RazaoDeViver != 42) { print "Você não entendeu nada da vida !\n"; } if($RazaoDeViver > 42) { print "Você está louco ?\n"; } if($RazaoDeViver < 42) { print "Você é um nanico frente a vida !\n"; } if($Idade >= 18) { print "Você está liberado para ver estas bobagens !\n"; } if($Idade <= 17) { print "Você nem tem idade para estas bobagens !\n"; } if($Senha eq "HexaSexo") { print "Você tem acesso ao sexo na sala hexadecimal!\n"; } if($Senha ne "HexaSexo") { print "É melhor ter sexo unidimensional na sua casa!\n"; } if($Nome gt "Y") { print "Você é mesmo sempre o último!\n"; } if($Nome lt "B") { print "Você consegue mesmo ser sempre o primeiro!\n"; } if($Nome ge "ZZ Top") { print "Sua banda preferida é a ZZ Top ou algo muito perverso!\n"; } if($Nome le "Abba") { print "Sua banda preferida é Abba ou algo muito light!\n"; } if($Idade =~ /[^0-9]/) { print "Isto nem número é!\n"; }

Na Perl existem diferenças entre operadores relacionais para números e para sequências de caracteres. No tutorial expressões regulares pode ser encontrado um operador relacional especial.

Para testar se dois valores numéricos são iguais, são utilizados dois sinais de igual ==. Para conferir se dois valores numéricos são diferentes, usa-se um ponto de exclamação (que significa não) seguido de um sinal de igual !=. Para constatar se um valor numérico é maior ou igual a outro, é usado um sinal de maior seguido de um sinal de igual >=. Para verificar se um valor numérico é maior que outro, aplica-se o sinal de maior >. Para verificar se um valor numérico é menor ou igual a outro, é usado um sinal de menor seguido de um sinal de igual <=. E, finalmente, para verificar se um valor numérico é menor que outro, o sinal de menor < é utilizado.

Para testar se duas strings são iguais, coloca-se eq (eq = equal = igual) entre as strings testadas. Da mesma forma, para verificar se duas strings apresentam diferenças, utiliza-se ne (ne = not equal = não iguais) entre elas. Para constatar se uma das strings é maior que outra, ou seja, está adiante na ordem alfabética, gt (gt = greater than = maior que) é utilizado. Da mesma forma, para verificar se é menor, ou seja, está mais atrás na ordem alfabética, usa-se lt (lt = less than = menor que). Para ver se uma string é maior ou igual a outra, usa-se ge (ge = greater or equal = maior ou igual) entre elas. Finalmente, para verificar se é menor ou igual, usa-se le (le = less or equal = menor ou igual).

Para comparar o valor de uma escalar, numérica ou de caracteres, com o valor de uma expressão regular, utiliza-se o operador de comparação =~.

Operadores Matemáticos

Para efetuar cálculos com valores numéricos são necessários os operadores matemáticos. Exemplos:

$FazCem = 83 + 17; $FazCem = 113 - 13; $FazCem = 4 * 25; $FazCem = 450 / 4.5; $FazCem = 450 / 2 - 125; $FazCem = 10 * (2 + 8); $x = $FazCem % 4; if($x == 0) { print $FazCem, " é um ano bissexto\n"; } /* Notações Especiais: */ $Numero = 100; $Numero++; # Incrementa $Numero em 1 $Numero--; # Diminui $Numero em 1 $Numero += 10; # Aumenta $Numero em 10 $Numero -= 10; # Diminui $Numero em 10

As operações matemáticas são indicadas com os sinais habituais. Com + obtém-se uma soma, com - uma subtração, com * uma multiplicação e com / uma divisão.

O operador % oferece uma operação especial, o assim chamado módulo de divisão. O módulo de divisão guarda o resto da divisão de um valor por outro. Por exemplo, ao fazer um módulo de divisão 13 % 5 o resultado obtido é 3. Isto porque 13 dividido por 5 dá 2 e o resto é 3.

Pode-se criar uma cadeia de operações matemáticas onde, naturalmente, vale a clássica regra de precedência "ponto antes do traço". A regra de precedência indica a sequência em que as operações serão realizadas: módulo, multiplicação e divisão antes da soma e da subtração. Assim, $Resultado = 10 * 2 + 8; será 28 porque a multiplicação ocorre antes da soma. Se quisermos que a soma seja efetuada antes de multiplicação, precisamos indicar a soma entre parênteses para forçar a precedência. Assim, $Resultado = 10 * (2 + 8); será 100.

As notações especiais que aparecem no exemplo acima podem ser utilizadas para abreviar operações de soma ou subtração. Assim, $Numero++; é uma abreviação de $Numero = $Numero + 1; e $Numero--; é o mesmo que $Numero = $Numero - 1; Do mesmo modo, $Numero += 10; é uma abreviação de $Numero = $Numero + 10; e $Numero -= 10 é o mesmo que $Numero = $Numero - 10;.

O operador ++ também é utilizado como operador de incremento e -- como operador de decremento.


Operadores lógicos

Quando se quer formular condições complexas em diretivas relacionais ou loops, utiliza-se os operadores lógicos, um tipo especial de operador relacional. Exemplo:

#!/usr/bin/perl $Tentativas = 1; $Valor = 0; $min = 66; $max = 77; Entrada: print "Digite um número entre ", $min, " e ", $max; $Valor = ; chop($Valor); if($Valor < $min || $Valor > $max) { if($Valor =~ /[^0-9]/) { print "Isto não era um número.\n\n"; $Tentativas++; goto Entrada; } if($Tentativas < 3 && $Valor < $min) { print "Seu número foi muito baixo.\n\n"; } elsif($Tentativas < 3 && $Valor > $max) { print "Seu número foi muito alto.\n\n"; } elsif($Tentativas >= 3 && $Valor < $min) { print "Seu número foi novamente muito baixo!\n\n"; } elsif($Tentativas >= 3 && $Valor > $max) { print "Seu número foi novamente muito alto!\n\n"; } $min = abs($Valor - $min); $max = $min + abs($max - $min); $Tentativas++; goto Entrada; } if($Tentativas > 1) { print "Está vendo, assim a gente aprende!\n"; } else { print "Você acertou na primeira!\n"; }

Com o operador lógico && (AND lógico) é possível associar duas ou mais condições através de "E", isto é, ambas ou todas as condições precisam ser satisfeitas para que a condição global seja satisfeita. Com o operador lógico || (OR lógico) associa-se duas ou mais condições inclusive através de "OU", isto é, se uma das condições for atendida, a condição global é satisfeita.

Operadores de bits

Operadores bit a bit são para profissionais acostumados a lidar com bits. Para utilizar corretamente um operador deste tipo é preciso estar familiarizado com o sistema de notação binário e com a arquitetura interna de processadores. É por isso que os operadores bit a bit são mencionados apenas de passagem.

  • >> desloca bits para a direita
  • << desloca bits para a esquerda
  • & define a condição "E" (AND) numa máscara de bits
  • | define a condição "inclusive OU" (OR) numa máscara de bits
  • ^ define a condição "exclusive OU" (XOR) numa máscara de bits
  • ! define a condição "NÃO" (NOT) numa máscara de bits
  • ~ define a condição "complemento" numa máscara de bits

Operador de Concatenação de Strings

Com um ponto . é possível agregar uma string a outra, ou seja, concatenar duas strings. Exemplo:

#!/usr/bin/perl @Objetos = ("FHC ","ACM ","Lula ","Zé Dirceu "); @Predicados = ("ama ","reverencia ","enriquece ","respeita "); @ObjDir = ("o encantamento ","as alegrias ","o princípio ","o furor "); @ObjInd = ("do poder.","do parlamento.","da capital.","do clientelismo."); @Indice = (0..3); print "FRASES"."ALEATÓRIAS\n\n"; while($i < 10) { $j = 0; sleep(2); $Frase = ""; srand(time()); foreach $j (0..3) { $Indice[$j] = rand(3); } $Frase = $Frase.$Objetos[$Indice[0]]; $Frase = $Frase.$Predicados[$Indice[1]]; $Frase = $Frase.$ObjDir[$Indice[2]]; $Frase = $Frase.$ObjInd[$Indice[3]]; print $Frase, "\n"; $i++; }

Com o operador ponto (.) pode-se concatenar tanto strings quanto variáveis com strings. O exemplo acima cria frases aleatórias baseadas em matrizes de frases que são definidas no início do script.

Operador para Replicar Strings

Em Perl é possível "multiplicar" sequências de caracteres através do operador x. Exemplo:

#!/usr/bin/perl print "A"."h" x 10, "!\n"; # gera a saída de "Ahhhhhhhhhh!"

Coloca-se o operador x logo depois a string que se quer replicar. Após o operador, indica-se quantas vezes a sequência de caracteres deve ser repetida.


Precedência de Operadores

Quando são avaliadas expressões com uma ou mais operações que não estejam agrupadas explicitamente através de parênteses, a Perl utiliza uma série de regras pré-estabelecidas para determinar a ordem em que as operações serão realizadas. Estas regras são chamadas de Regras de Precedência e determinam a hierarquia dos operadores.

Hierarquia 1 , (delimitador)
Hierarquia 2 =   +=   -=   &=   ^=   |= (atribuição)
Hierarquia 3 ?: (condição se-então)
Hierarquia 4 .. (definição de área em arrays)
Hierarquia 5 || (OU lógico)
Hierarquia 6 && (E lógico)
Hierarquia 7 |   ^ (OU bit a bit - inclusive/exclusive)
Hierarquia 8 & (E bit a bit)
Hierarquia 9 ==   !=   eq   ne (igual/não igual)
Hierarquia 10 <   <=   >   >=   lt   le   gt   ge (condicional maior/menor)
Hierarquia 11 <<   >> (deslocamento de bits)
Hierarquia 12 +   -   . (adição, subtração, concatenação de strings)
Hierarquia 13 *   /   %   x (multiplicação, divisão, módulo, replicar)
Hierarquia 14 =~   !~ (coincidências em expressões regulares)
Hierarquia 15 ** (potenciação)
Hierarquia 16 !   ~   - (operadores de bits)
Hierarquia 17 ++   -- (incrementação/decrementação)

Com a ajuda de parênteses pode-se influenciar a precedência dos operadores e avaliar expressões da forma desejada. Exemplo:

#!/usr/bin/perl $EstatisticaOficial = 3.29 * 3 + 4.71; $MinhaEstatistica = 3.29 * (3 + 4.71); print "A estatística oficial diz ",$EstatisticaOficial,"\n"; print "Minha Estatistica diz ",$MinhaEstatistica,"\n";mfx broker выплатыкейс визажисталобановский классподводные видеокамерыоптимизация сайта профессиональная Лобановскийотзывы класс

Informações adicionais