Každý zápis, jehož vyhodnocením získáme nějakou hodnotu, je výrazem. Připomeňme, že s výrazy se setkáváme již od počátku seriálu. Například konstanty (tedy samotná čísla nebo řetězce), proměnné, příkaz print jsou všechno výrazy. Dnes si uděláme jejich systematičtější přehled a značně rozšíříme arzenál operátorů, kterými se určuje, jak se má výraz vyhodnocovat.

Trochu nepřesně lze říci, že výraz se středníkem na konci se stává příkazem. Proto, pokud jakémukoliv příkazu odejmeme středník, získáme výraz. Příkaz tedy má také nějakou hodnotu - a to i když není potřebná. Například, k čemu nám je, že příkaz print vrátí hodnotu 1? Většinou k ničemu, nicméně z principu je vyhodnocení nezbytné, neboť musí jít vyhodnotit každý výraz. Dokonce lze říci, že program je posloupností výrazů a středníků.

Pravdivostním výrazem myslíme výraz, který se vyhodnocuje na typ pravda / nepravda (například test u podmínek). Ve skutečnosti je ale každý výraz pravdivostní. Vyhodnocením libovolného výrazu je totiž možné získat pravdu nebo nepravdu. I přesto se teď zaměřme jen na výrazy tvořené relačními, logickými a pro zajímavost i bitovými operátory.

Způsoby vyhodnocování

Začněme ukázkou. Co vytisknou následující příkazy?

print 9 > 6;
print 9 > 18;

V prvním případě bylo vytisknuto 1, ve druhém případě "" (tedy prázdný řetězec). Proč? Číslo 9 je skutečně větší než 6. Výraz se tedy vyhodnotí jako pravda a tiskne se hodnota true. Protože Perl neobsahuje žádný speciální booleovský datový typ, uchovávající pouze hodnoty false a true, tiskne se místo true hodnota 1. Naopak prázdný řetězec značí false.

Obvyklou konvencí je, že úspěšně vykonaný příkaz vrátí pravdivou hodnotu a neúspěšně vykonaný nepravdivou. Zkuste na základě tohoto a předchozího odstavce určit, co se vytiskne následujícím příkazem:

print print "";

Test porovnání dvou hodnot můžeme užít v podmínce:

$a = 3;
$b = 2;

if ($a > $b){# $a je skutečně větší než $b (3 > 2). Výsledkem tohoto výrazu je 1 - tedy true
    print '$a je větší než $b';
    print "\n";
}
else{
    print '$b je větší než $a';
    print "\n";
}

Všimněme si, že jsme použili apostrofy jako označení řetězce. To proto, aby se místo $a a $b nevytiskly jejich hodnoty. (i když by to v tomto případě zas tolik nevadilo)

Zkusme ještě další příklad:

if ($zisk < 0){
    if ($zakazky == 0){
        $bankrot = 1;
    }
    else{
        $zamestnancu *= 3/4;
    }
}
elsif ($zisk > 1e7){
    $plat *= 1.05;
}

Operátory pro porovnávání (relační operátory):

Výsledky porovnávání čísel jsou intuitivní - řídí se zákony matematiky.

Ale jak se porovnávají řetězce? Perl vezme první znak levého operandu a porovná jej s pravým. To samé s druhým atd. Každý znak bere jako číslo, určené jeho ASCII hodnotou. První odlišnost, kterou Perl objeví rozhodne o výsledku porovnání. Není-li žádná odlišnost, výrazy jsou si rovny.

$a = 4;
$b = 8;

#výraz $a == $b bude vyhodnocen jako false. 4 není rovno 8
if ($a == $b){ 
    print "$a == $b\n";
}

#výraz $a != $b bude vyhodnocen jako true. 4 není rovno 8.
if ($a != $b){ 
    print "$a != $b\n";
}

#výraz $a > $b bude vyhodnocen jako false. 4 není větší než 8.
if ($a > $b){ 
    print "$a > $b\n";
}

#výraz $a != $b bude vyhodnocen jako true. 5 * 4 je větší než 2 * 8.
if (5 * $a >= 2 * $b){ 
    print "5 * $a >= 2 * $b\n";
}

#'a' je v ASCII tabulce paradoxně až za 'A', takže je větší.
#Platí, že jakékoliv malé písmeno je vždy větší než jakékoliv velké písmeno.
if ("a" gt "A"){ 
    print "a > A\n";
}

#u číselného porovnávání se Perl řídí matematicky správně, u řetězců to ale zdánlivě neplatí.
#"1slon" bude vyhodnocen jako 1, "slon" jako 0. 1 > 0
if ("1slon" == "slon"){ 
    print "1slon > slon\n";
}

#slon sice není 1slon, ale je to myš. Oba výrazy budou vyhodnoceny jako 0, tudíž se rovnají.
if ("slon" == "myš"){ 
    print "slon == myš\n";
}

Operátor <=> vrací hodnotu 1, je-li pravý výraz větší než levý, hodnotu -1, je-li levý výraz větší než pravý nebo hodnotu 0, jsou-li výrazy na obou stranách stejné.

$a = 1;
$b = 2;

print $a <=> $b; #-1
print $b <=> $a; #1
print $a <=> 1;   #0

Logické operátory

Obyčejné testy většinou nestačí. Občas potřebujeme podmínku typu je-li a > b a zároveň a > d. Od toho jsou logické operace.

Céčkovský zápis operátorů má stejný význam jako operátory, liší se jen v prioritě.

Konjunkce je splněna, jsou-li oba její operandy true. Disjunkce je splněna, je-li alespoň 1 její operand true (je-li true první operand, druhý je přeskočen a už se nevyhodnocuje - výsledek by to neovlivnilo; této vlastnosti můžeme použít při konstrukcí podmínek bez řídících konstrukcí).

Defined-or dělá totéž jako logické nebo až na to, že levý operand je testován na definovanost (nikoliv na pravdivost). Nebudeme se jím zatím zabývat, avšak jde o užitečný nástroj pro konstrukci podmínek bez řídících konstrukcí.

Negace vrací opačnou hodnotu než její operand. Jde o unární operátor.

$a = 4;

#1 je true, $a také, proto je test vyhodnocen jako true
if (1 and $a){ 
    print "1. test\n";
}

#1 je true, ale prázdný řetězec ne, proto je test vyhodnocen jako false
if (1 and ""){ 
    print "2. test\n";
}

#1 je true, výsledek je taky true
if (1 or ""){ 
    print "3. test\n";
}

#1 je true, výsledek je taky true
if (1 or 2){ 
    print "4. test\n";
}

#1 je true, negace obrací výraz, takže test je false
if (!1){ 
    print "5. test\n";
}

#1 and "MP" je true, potom je true i 0 or (1 and "MP"). Tento celý výraz je operandem
#druhého or a protože je true, je i tato operace or true. Výsledek negujeme a dostáváme false.
if (!(0 or (1 and "MP") or ($a and ""))){ 
    print "6. test\n";
}

Přiřazení jako test podmínky

Jako test se hojně používá i přiřazení (nejčastěji ve spojení se čtením dat ze souboru, databáze apod.). Přiřazujeme-li hodnotu true, je i celý test true. Přiřazujeme-li hodnotu false, je test také false.

if ($a = 0){ #0 je false
    print "TRUE\n";
}
else{
    print "FALSE\n";
}

Připomeňme, že to není porovnávání. To bychom museli použít operátor ==.

Příklad - absolutní hodnota

Zkusme napsat program, který vypíše absolutní hodnotu čísla. Stačí vynásobit hodnotu číslem -1, pokud je záporná.

#!/usr/bin/env perl
use strict;

my $hodnota = -3;

if ($hodnota < 0){
    $hodnota *= -1;
}

print "$hodnota\n";

Chceme-li, dá se podmínka pomocí podmínkového operátoru zahrnout přímo do funkce print.

#!/usr/bin/env perl
use strict;

my $hodnota = 3;

print $hodnota < 0 ? $hodnota * -1 : $hodnota . "\n";

V tomto případě se nejdříve vyhodnotí výraz $hodnota < 0 ? $hodnota * -1 : $hodnota a poté se tiskne.

Bitové operátory

Ještě se zmiňme o dalším typu operací - bitových. Pokud vás nezajímají, klidně tuto část přeskočte, protože se s nimi běžný člověk nesetkává často.

Bitové operace mají význam jen v případě celočíselných operandů (zadáme-li desetinné číslo, Perl si desetinnou část odřízne). Podívejme se na tabulku bitových operátorů.

Bitové operátory fungují tak, že je operand (nebo operandy) převeden do dvojkové soustavy. U operátorů &, | a ^ Perl postupně porovnává bity na stejných pozicích.

Následující tabulka ilustruje význam bitových operátorů:

bitové not

Každý výsledný bit je doplňkem bitu operandu do 1. Funguje tudíž na různých počítačích jinak (podle rozsahu čísla). Zkusíme negaci pro 110101110000101:

    0b11111111111111111111111111111111
$a  0b00000000000000000110101110000101
    ----------------------------------
~$a 0b11111111111111111001010001111010

bitové and

Pokud jsou v pravém i levém operandu bity na stejných pozících 1, výsledkem na daném bitu je 1. V ostatních případech je výsledkem 0.

$a = 1631;
$b = 55;
print $a & $b; #23

1631 a 55 vyjádříme ve dvojkové soustavě. Odtud je zřejmé, jak se k výsledku došlo.

$a      0b11001011111    1631
$b      0b     110111      55
        -------------     ----
$a & $b 0b00000010111      23

bitové or

Pokud jsou v operandech oba bity na stejných pozicích 0, výsledkem bitu na dané pozici ve výsledku je 0. Vyskytne-li se v jednom z nich 1 (tedy všechny ostatní případy), výsledkem je 1.

$a = 1322;
$b = 986;
print $a | $b; #2042

To je zřetelné odtud:

$a      0b10100101010    1322
$b      0b 1111011010     986
        -------------    ----
$a | $b 0b11111111010    2042

bitové xor

Číslice 1 a 0 nebo 0 a 1 se vyhodnotí jako 1, v ostatních případech je výsledkem 0.

$a = 30549;
$b = 6806;
print $a ^ $b; #28099

Bitově:

$a      0b111011101010101    30549
$b      0b001101010010110     6806
        -----------------    -----
$a ^ $b 0b110110111000011    28099

bitový posun

Operátor >> umazává zprava bity, operátor << (zleva) přidává nuly.

$a = 61;
$b = 2;
print $a >> $b; #15
print $a << $b; #244

Bitově:

$a        0b  111101     61
$b                 2      2
        ----------    ---
$a >> $b  0b    1111     15
$a << $b  0b11110100    244