Programozás során az egyik legfontosabb művelet az összehasonlítás. Így tudjuk felmérni a változók viszonyát. Az összehasonlító operátorok visszatérési értéke logikai: vagy igaz, vagy hamis az állítás. Ezen műveletek elvégzésére a következő operátorok állnak rendelkezésre:
Egyenlőség (==): két darab egyenlőség jellel jelöljük, akkor igaz, ha a két változó tartalma egyenlő. Ez az operátor nem vizsgálja a típusok azonosságát: például egy string és egy integer egyenlő, ha a tartalmuk megegyezik.
FIGYELEM!
Mivel ezúttal az echo függvény kevés lenne a válaszok kiíratására, ezért a var_dump függvényt fogjuk használni, amely olvasható formában jeleníti meg az eredmény típusát (ez esetben bool (vagyis logikai)) és az értékét (itt: true vagy false).
-----------------------
<?php
$szam = 12; //integer
$szoveg = '12'; //string
var_dump($szam == $szoveg); // Kiírja: bool(true)
?>
-----------------------
Megjegyzés
A fenti példában a kiírt "bool(true)" jelentése: igaz. A hamis értékre bool(false) lenne a válasz, a későbbi leckékben látni fogjuk, hogyan kell ezekkel a visszatérő értékekkel dolgozni.
Azonosság (===): a három darab egyenlőség jel azonosságot jelöl. A fenti operátorhoz képest annyival tud többet, hogy csak akkor lesz igaz az értéke, ha a két változó típusa is megegyezik.
-----------------------
<?php
$elso_szam = 22; //integer
$masodik_szam = 22; //integer
var_dump($elso_szam === $masodik_szam); // Kiírja: bool(true)
?>
-----------------------
Nem egyenlő (!= vagy <>): akkor igaz, ha a két változó értéke nem egyenlő. Ez az operátor se vizsgál típust.
-----------------------
<?php
$szam = 23; //integer
$szoveg = '24'; //string
var_dump($szam != $szoveg); // Kiírja: bool(true)
?>
-----------------------
Nem azonos (!==): a fenti operátorral megegyező működés, típusvizsgálat mellett.
-----------------------
<?php
$elso_szoveg = 'első szöveg'; //string
$masodik_szoveg = 'második szöveg'; //string
var_dump($elso_szoveg !== $masodik_szoveg); //Kiírja: bool(true)
?>
-----------------------
Kisebb (<): akkor igaz, ha az első változó szigorúan kisebb, mint a második. Ez az operátor aritmetikai összehasonlítást végez, így a string típusú változók tartalmát számként értékeli. Ha nem értelmezhető számként, akkor az értéke 0 lesz!
-----------------------
<?php
$elso_szam = 23; // integer
$szoveg = '24'; // string
var_dump($elso_szam < $szoveg); // Kiírja: bool(true)
?>
-----------------------
Figyeljük meg a string kiértékelését:
-----------------------
<?php
$elso_szam = -1; // integer
$szoveg = 'alma'; // string
var_dump($elso_szam < $szoveg); // Kiírja: bool(true)
/*Magyarázat: mivel a $szoveg számértéke 0, így a -1 -gyel
összehasonlítva az eredmény igaz. */
?>
-----------------------
Nagyobb (>): a fenti operátorral megegyező működés, ezúttal viszont az első változó szigorúan nagyobb, mint a második.
Kisebb, vagy egyenlő (<=): az eredmény akkor igaz, ha a két változó egyenlő, vagy az első kisebb, mint a második.
Nagyobb, vagy egyenlő (>=): az eredmény akkor igaz, ha a két változó egyenlő, vagy az első nagyobb, mint a második.
Érdekesség
A 7-es php-ban be fognak vezetni egy új operátort, nevezetesen a háromirányú összehasonlító operátort (<=>) - a formája miatt a szakzsargon "űrhajó operátorként" is ismeri. A kiértékelésnek 3 eredménye lehet:
- Ha egyenlőek, az érték: 0 ( Pl.: 1 <=> 1)
- Ha az első kisebb, mint a második, az érték: -1 ( Pl.: 1 <=> 2)
- Ha az első nagyobb, mint a második, az érték: 1 (Pl. 2 <=> 1)
Gyakorlati haszna
Feltételezzük, hogy azt szeretnénk vizsgálni, hogy két változó közül melyik a nagyobb. Ebben az esetben a hagyományos módon így tehetjük meg:
-----------------------
<?php
$a = 22;
$b = 14;
echo ($a < $b) ? -1 : (($a > $b) ? 1 : 0); // Kiírja: 1
/*Mivel az első változó nagyobb, mint az első,
így a fenti felsorolás 3. pontja lesz érvényes.*/
?>
-----------------------
A fenti példa az új operátorral így néz ki:
-----------------------
<?php
$a = 22;
$b = 14;
echo $a <=> $b; // Kiírja: 1
?>
-----------------------
Tanács
Mivel az operátor nem támogatott a régebbi verziókban, így a használatát mindenképpen verziófüggően javasoljuk.
FIGYELEM!
Mivel a lebegőpontos értékeket kerekítve tároljuk, ezek összehasonlítása a hagyományos módon nem javasolt. Ezen számok esetében az alábbi kerülő megoldást alkalmazhatjuk. Először eldöntjük, hogy hány tizedes pontosságig vizsgáljuk, majd a két változó különbségének abszolút értékét ezen referenciaértékhez hasonlítjuk:
-----------------------
<?php
$elso_szam = 1.123456789;
$masodik_szam = 1.123456781;
$pontossag = 0.00001; // 5 tizedes pontosságig vizsgálódunk!
var_dump( abs($elso_szam - $masodik_szam) < $pontossag); // Kiírja: bool(true)
?>
-----------------------
A fenti példában láthatjuk, hogy valóban az első 5 tizedesig a két változó értéke egyenlő.
----------------------------------------------
Feladatok
1. Vegyünk két változót, amelyek egész szám típusúak, majd vizsgáljuk meg, hogy az első kisebb-e, mint a második! A kiíráshoz használjuk a var_dump függvényt!
2. Két tetszőleges típusú és tartalmú változót vizsgáljunk meg azonosságra, és írjuk ki az eredményt var_dump segítségével!
3. Két, egyenként 9 tizedes értékű számot 4 tizedes pontosságig vizsgáljunk meg egyenlőségre!
