Pode-se, por exemplo, atribuir um valor a uma variável escalar. O operador de atribuição, nestes casos, é o sinal de igual =. Exemplos:

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

Utiliza-se os operadores relacionais 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 módulo 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 sinal 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 é, com certeza, 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 ter certeza de que um valor numérico é menor que outro, o sinal de menor < é utilizado.

Para testar se duas cadeias de caracteres são iguais, coloca-se eq (eq = equal = igual) entre as cadeias testadas. Da mesma forma, para verificar se duas cadeias de caracteres apresentam diferenças, utiliza-se ne (ne = not equal = não iguais) entre elas. Para constatar se uma das cadeias de caracteres é 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á à frente na ordem alfabética, usa-se lt (lt = less than = menor que). Para ver se uma cadeia de caracteres é maior ou igual que outra, insire-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 =~.

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 característica 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 ou 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.

Quando se quer formular condições complexas em diretivas relacionais ou loops, utiliza-se os operadores lógicos (ou operadores relacionais). Exemplo:

#!/usr/bin/perl

$Tentativas = 1;
$Valor = 0;
$min = 66;
$max = 77;
Entrada:
print "Digite um número entre ", $min, " e ", $max;
$Valor = <STDIN>;
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ê com certeza foi uma criança boazinha!\n";
}

Com o operador 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 || 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 bit a bit são coisa para profissionais. Para utilizar corretamente um operador desse tipo é preciso entender um bocado da 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 "complementar" numa máscara de bits

Com um ponto . é possível agregar uma string à outra, ou seja, concatená-las. 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++;
}

Pode-se concatenar variáveis com cadeias de caracteres (strings) como também cadeias de caracteres com . .

O exemplo acima cria frases aleatórias baseadas em listas de elementos das frases, as quais são definidas no início do script.

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!"

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

Quando são avaliadas expressões com uma ou mais operações que não estejam agrupadas explicitamente através de parênteses, o 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.

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";