Operátory
Operátor se používá pro zjištění hodnoty pomocí provedení procedury nebo operace s jednou nebo více hodnotami. Hodnota, která se používá v operaci se nazývá operand. Ve výrazu 7 + 2 jsou 7 a 2 operandy a vyhodnocením bude 9.
Základní početní operátory
| Operátor | Operace | Příklad | Popis |
| + | sčítání | 7 + 2 | součet 7 a 2: 9 |
| - | odečítání | 7 - 2 | rozdíl, kdy 2 je odečteno od 7: 5 |
| * | násobení | 7 * 2 | součin 7 a 2: 14 |
| / | dělení | 7 / 2 | podíl 7 a 2: 3.5 |
| % | zbytek | 7 % 2 | zbytek po celočíselném dělení: 1 |
PHP ignoruje mezery. Ačkoliv jsou výrazy $x=7*2; a $x = 7 * 2; ekvivalentní, druhý výraz je přehlednější a tudíž vhodnější.
Unární operátor
Znaménko - (minus) se také používá společně s jedinou numerickou hodnotou pro změnu znaménka (tzn., že z kladných čísel dělá záporná a naopak).
<?php
$a = 2;
$b = -$a; // $b je -2
$c = -4;
$d = -$c; // $d je 4
?>
Operátor přiřazení proměnné
Již víme že, operátor = (rovná se) se používá pro přiřazování hodnot proměnným.
<?php
$x = 3;
$y = $x + 4;
$Obsah = $Vyska * $Sirka;
$Text = 'Kliknutím na tlačítko OK ukončíte aplikaci.';
?>
Proměnné na levé straně od rovnítka je předána hodnota výrazu na pravé straně. Je důležité neplést si operátor přiřazení (=) s operátorem porovnání (==) !
Operátory porovnání
Operátory porovnání se používají pro testování podmínek, jimiž se budeme zabývat v další kapitole. Výrazy, které použijí operátory porovnání, budou vždy vyhodnoceny jako logická hodnota, tzn. TRUE nebo FALSE. Pokud chceme jednoduše zjistit, zda daný výraz platí, můžeme ho předat příkazu echo, ten v případě pravdy vypíše jedničku, v případě nepravdy nevypíše nic.
| Operátor | Význam | Příklad | Platí, když: |
| == | rovnost | $x == $y | $x a $y mají stejnou hodnotu |
| === | identita | $x === $y | $x a $y mají stejnou hodnotu a jsou stejného datového typu |
| < | menší | $x < $y | $x je menší než $y |
| > | větší | $x > $y | $x je větší než $y |
| <= | menší nebo rovno | $x <= $y | $x je menší nebo rovno $y |
| >= | větší nebo rovno | $x >= $y | $x je větší nebo rovno $y |
| <> | nerovnost | $x <> $y | $x se nerovná $y |
| != | nerovnost | $x != $y | $x se nerovná $y |
| !== | neidentita | $x !== $y | $x a $y nemají stejnou hodnotu nebo nejsou stejného datového typu |
Pamatujte na to, že při porovnávání PHP provádí automatické přetypování a konverze řetězců. To znamená, že pokud mají dvě proměnné po provedení konverze typu stejnou hodnotu, PHP je bude považovat za identické hodnoty a to i v případě, že mají odlišné datové typy. To nemusí až tak moc vadit, ale pokud chcete porovnat i datový typ proměnných, použijte operátor === nebo funkci gettype(). Podobně funguje operátor !==, který přísně porovnává nerovnost.
<?php
$x = '7'; // řetězec
$y = 7.0; // desetinné číslo
echo ($x == $y); // Vypíše: 1 (platí)
// V těchto případech rovnost platit nebude a echo nevypíše nic.
echo ($x === $y);
echo (($x == $y) and (gettype($x) == gettype($y)));
?>
Logické operátory
Logické operátory se používají pro kombinaci podmínek, aby mohlo být více podmínek vyhodnoceno dohromady jako jediná podmínka. Logické "a" vrátí TRUE, pouze pokud byly splněny podmínky na obou stranách. Logické "nebo" vrátí TRUE, pokud byla splněna alespoň jediná podmínka. Poslední logický operátor, logická negace, vrátí TRUE, pokud je následující výraz vyhodnocen jako nepravdivý.
| Operátor | Význam | Příklad | Platí, když: |
| && | a | $x && $y | budou $x i $y obě vyhodnoceny jako pravda |
| || | nebo | $x || $y | $x i $y nebo obě budou vyhodnoceny jako pravda |
| and | a | $x and $y | budou $x i $y obě vyhodnoceny jako pravda |
| or | nebo | $x or $y | $x i $y nebo obě budou vyhodnoceny jako pravda |
| xor | vylučovací nebo | $x xor $y | $x nebo $y bude vyhodnoceno jako pravda, nikoliv však obě |
| ! | negace | !$x | bude $x bude vyhodnoceno jako nepravda |
Všimněte si, že existují dva operátory pro logické "a" a dva operátory pro logické "nebo". Chovají se podobně, ale mají jinou prioritu. To znamená, že budou uvnitř výrazu, který obsahuje více operátorů, provedeny v jiném pořadí.
Tyto příklady by měli trochu ozřejmit použití těchto operátorů.
<?php
$h = 4;
$i = 5;
$j = 6;
echo ($h == 4 && $i == 5 && $j == 6);
// Všechny podmínky byly splněny, echo vypíše: 1
echo ($h == 3 || $i == 5);
// Zde je první část podmínky nepravdivá a druhá část je pravdivá.
// Protože stačí, aby byla pravdivá pouze jedna část podmínky,
// celý výraz je pravdivý.
echo ($i == 5 xor $j == 6);
// Obě podmínky jsou pravdivé a protože jsou
// propojeny pomocí xor, celý výraz je nepravdivý.
// Výrazy s xor jsou pravdivé pouze v případě,
// že je splněna právě jen jedna podmínka.
?>
<?php
/* Tato ukázka demonstruje použití operátoru logické negace. */
$h = 4;
$i = 5;
$j = 6;
echo (!$h == 4 && !$i == 5);
// Výraz ($h == 4 && $i == 5) je vyhodnocen jako pravdivý,
// takže díky negaci (!) jsou oba výrazy nepravdivé.
echo !($h == 4 && $i == 5);
// Takto lze použít negaci pro celou závorku,
// aby nedošlo k problémům s prioritou.
?>
<?php
// Výrazy lze uzavírat do závorek a libovolně spojovat,
// někdy se můžeme dopracovat i k takto složitému zápisu:
$h = 4;
$i = 5;
$j = 6;
echo ((($h == 4 && $j == 4) || ($h == 5 || $j == 6)) xor ($i == 6 || $j == 7));
/* Už víte, zda bude tento výraz platit? :-) */
?>
Operátor pro spojování řetězců
<?php
// Operátorem . (tečka) lze spojovat proměnné,
// konstanty, a samozřejmě i samotné řetězce.
define('PRODUKT', 'Opera');
$Verze = '9.00 Beta';
$Celek = PRODUKT . ' ' . $Verze; // 'Opera 9.00 Beta'
echo 'Používáte OS postavený na jádře: ' . PHP_OS;
?>
Ternární operátor
Doposud byly všechny operátory, kterými jsme se zabývali, unární nebo binární. Unární operátor, jako například ! (vykřičník), provádí svou operaci pouze na jediné hodnotě nebo operandu. Operátor ! vyjadřuje opačnou logickou hodnotu, než má jeho operand. Pokud je $a nepravda, pak !$a je pravda. Binární operátor, jako třeba =, se používá pro provedení operace na dvou operandech: $a = $b vezme hodnotu operandu $b a přiřadí ji $a. Viděli jsme výrazy, které obsahovaly tři hodnoty, například: $a = $b + $c;, ale tyto výrazy mají dva operátory a proto prezentují dvě prováděné operace (v tomto příkladu nejprve součet a pak přiřazení).
V PHP existuje pouze jediný ternární operátor. Ternární operátor provádí jedinou operaci se třemi hodnotami. Operátor : ? je obvykle nazýván jednoduše ternárním operátorem nebo podmíněným operátorem. Používá se pro testování logické podmínky před ? (otazníkem), hodnoty uvedené před : (dvojtečkou), která je vrácena v případě, že je podmínka pravdivá, a za dvojtečkou, která je vrácena v případě, že je podmínka nepravdivá.
<?php
$a = 2;
echo 'Proměnná $a ' . ($a == 0 ? 'je nula' : 'není nula');
?>
V tomto příkladu je prvním operandem podmínka $a == 0. Pokud je zjištěno, že je podmínka pravdivá, operace vrátí řetězec "nula", jinak vrátí řetězec "není nula". Prvním operandem musí být vždy logická hodnota. Zbývající operandy mohou být libovolného datového typu. Ternární operátor je v základu zkratkou podmínky if...else, kterou budeme probírat v dalších kapitolách.
Zkrácené přiřazování
| Zkrácený zápis | Ekvivalentní zápis |
| $x += $y | $x = $x + $y |
| $x -= $y | $x = $x - $y |
| $x *= $y | $x = $x * $y |
| $x /= $y | $x = $x / $y |
| $x %= $y | $x = $x % $y |
| $x .= $y | $x = $x . $y |
| $x++ | $x = $x + 1 |
| $x-- | $x = $x - 1 |
Operátor inkrementace nebo dekrementace (dva poslední zápisy v tabulce) se může objevovat před nebo za proměnnou, na které se provádí. Umístění operátoru určuje pořadí, ve kterém události nastanou. Pokud je umístěn za proměnnou, PHP vrátí hodnotu před inkrementací a teprve potom provede inkrementaci.
<?php
$a = 10; // $a je 10
$a++; // $ a je 11
$a = 10; // $a je 10
++$a; // $a je 11
// Na první pohled to tedy není zřejmé, ale:
$a = 10; // $a je 10
$b = $a++; // $a je 11, ale $b je 10!
// Přiřazení se provedlo před inkrementací!
$a = 10; // $a je 10
$b = ++$a; // $a je 11, $b je 11
// Přiřazení se provedlo po inkrementaci!
?>
Operátor potlačení chybových zpráv
Operátor @ (zavináč) se používá k potlačení výpisu chybové zprávy, která může nastat u nějaké funkce. To může být užitečné při ladění, ale velmi neprofesionální při normálním běhu programu. Umístit ho můžete před jakýkoliv výraz.
<?php
print (5 / 0);
// Warning: Division by zero in C:\www\test.php on line 3
// Pokud funkci print() předchází operátor @, prohlížeči chyba
// není hlášena a není vypsána žádná hodnota. Operátor může být
// uveden před jakýmkoliv výrazem. Následující dva řádky dělají
// jedno a totéž:
@print (5 / 0);
print @(5 / 0);
?>
Priority a asociativita
Pokud se v jediném výrazu vyskytne více operací, je pořadí jejich provádění určováno dvěma faktory: Prioritou a asociativitou operátorů. Priorita určuje pořadí, ve kterém budou operace prováděny. Operace násobení a dělení mají vyšší prioritu než sčítání a odčítání, a proto se provedou dříve. Pro přeskočení priority se používají závorky.
<?php
$a = 2 + 3 * 4; // $a je 14
$a = (2 + 3) * 4; // $a je 20
?>
Asociativita určuje pořadí, ve kterém se provedou operace se stejnou prioritou. Například sčítání má asociativitu zleva doprava, ale přiřazení zprava doleva.