Az alkotóelemek

Ebben az órában már mélyebben elmerülünk a nyelv rejtelmeiben. Az alapokkal
kezdünk, így a kezdõ programozónak rengeteg új információt kell majd feldolgoznia.
Aggodalomra azonban semmi ok, bármikor vissza lehet lapozni a könyvben.
A lényeg, hogy a fejezetben leírtak megértésére törekedjünk, ne csupán
a memorizálásra.
A gyakorlott programozóknak is ajánlatos legalábbis átlapozniuk ezen óra anyag
át. Az órában a következõket tanuljuk meg:
• Mik a változók és hogyan használjuk azokat?
• Hogyan hozhatunk létre változókat és hogyan érhetjük el azokat?
• Mik azok az adattípusok?
• Melyek a leggyakrabban használt mûveletek?
• Hogyan hozhatunk létre kifejezéseket mûveletjelek használatával?
• Hogyan határozhatunk meg állandókat és hogyan használhatjuk azokat?
Változók
A változók különleges tárolók, amiket abból a célból hozunk létre, hogy értéket helyezz
ünk el bennük. A változók egy dollárjelbõl ($) és egy „tetszõlegesen” választott
névbõl tevõdnek össze. A név betûket, számokat és aláhúzás karaktereket (_) tartalmazhat
(számmal azonban nem kezdõdhet!), szóközöket és más olyan karaktereket,
amelyek nem számok vagy betûk, nem. Íme néhány érvényes változónév:
$a;
$egy_hosszabb_valtozonev;
$elalszom_zzzzzzzzzzzzzz;
Ne feledjük, hogy a pontosvesszõ (;) a PHP utasítás végét jelzi, így az elõzõekben
a pontosvesszõ nem része a változók nevének.
A változók adatokat – számokat, karakterláncokat, objektumokat, tömböket
vagy logikai értékeket – tárolnak, tartalmuk bármikor módosítható.
Amint látjuk, rengeteg féle nevet adhatunk változóinknak, bár a csak számokból
álló változónevek nem szokványosak. Változó létrehozásához (deklarálásához, vagyis
bevezetéséhez) egyszerûen csak bele kell írni azt a programunkba. Létrehoz
áskor általában rögtön értéket is szoktunk adni a változónak.
$szam1 = 8;
$szam2 = 23;
Itt két változót hoztunk létre és a hozzárendelõ mûveletjellel (=) értéket is adtunk
azoknak. Az értékadásról bõvebben a Mûveletjelek és kifejezések címû részben tanulunk,
az óra késõbbi részében. Miután értéket adtunk változóinknak, úgy kezelhetj
ük azokat, mintha maguk lennének az értékek. Vagyis a fenti példánál maradva
a létrehozás után írt
print $szam1;
hatása megegyezik a
print 8;
hatásával, feltéve, hogy a $szam1 változó értéke 8 maradt.
Dinamikus változók
Változót tehát úgy hozunk létre, hogy egy dollárjel után írjuk a változó nevét. Szokatlan,
ám hasznos, hogy a változó nevét is tárolhatjuk változóban. Tehát ha az
alábbi módon értéket rendelünk egy változóhoz
$felhasznalo = "Anna";
az megegyezik azzal, mintha ezt írnánk:
$tarolo = "felhasznalo";
$$tarolo = "Anna";
A $tarolo változó a "felhasznalo" szöveget tartalmazza, ezért a $$tarolo-t
úgy tekinthetjük, mint egy dollárjelet, melyet egy változó neve követ ($tarolo),
a $tarolo viszont ismét csak egy változó, amit a PHP a változó értékével helyettes
ít, vagyis "felhasznalo"-val. Tehát a fenti kifejezés a $felhasznalo-val
egyenértékû.
A dinamikus változók elérése ugyanúgy történik, mint a „hagyományos” változóké,
tehát a
$felhasznalo = "Anna";
print $felhasznalo;
azonos a
$felhasznalo = "Anna";
$tarolo = "felhasznalo";
print $$tarolo;
kóddal, eltekintve természetesen attól, hogy itt létrehoztunk egy $tarolo nevû
változót, melynek értéke "felhasznalo".
Az alkotóelemek 37
4
Dinamikus változókat karakterlánc-konstanssal (állandóként
meghatározott karakterlánccal) is létrehozhatunk. Ekkor a változ
ó nevéül szolgáló karakterláncot kapcsos zárójelbe tesszük:
${"felhasznalonev"} = "Anna";
Ez elsõ ránézésre nem tûnik túl hasznosnak. Ha azonban
a karakterlánc-összefûzõ mûveletjellel ciklusban használjuk
(lásd a Vezérlési szerkezetek címû ötödik órát), e módszerrel
dinamikus változók tucatjait hozhatjuk létre.
Ha egy dinamikus változót egy karakterláncon belül szeretnénk kiírni, az értelmez
õnek némi segítséget kell adnunk. Az alábbi print utasítás hatására
$felhasznalo = "Anna";
$tarolo = "felhasznalo";
print "$$tarolo";
a böngészõ nem az "Anna" szöveget jeleníti meg, mint ahogy várnánk, hanem
kiírja a dollárjelet, majd a "felhasznalo" szöveget, vagyis összességében azt,
hogy "$felhasznalo".
Ha egy változót kettõs idézõjelek közé teszünk, a PHP szolgálatkészen
beilleszti annak értékét.
A mi esetünkben a PHP a $tarolo karaktersorozatot a "felhasznalo" szö-
vegre cserélte, az elsõ dollárjelet pedig a helyén hagyta. Annak érdekében, hogy
egyértelmûvé tegyük a PHP számára, hogy a karakterláncon belüli változó egy dinamikus
változó része, kapcsos zárójelbe kell tennünk. Az alábbi kódrészlet print
utasítása
$felhasznalo = "Anna";
$tarolo = "felhasznalo";
print "${$tarolo}";
már az "Anna" szöveget írja ki, ami a $felhasznalo nevû változó értéke.
A 4.1. példaprogram egy PHP oldalon belül tartalmazza a korábbi programrészleteket
és változóban tárolt karakterláncokat használ a $felhasznalo kezdeti érté-
kének beállítására és elérésére.
4.1. program Dinamikusan beállított és elért változók
1:
2:
3:
4:
5:
6: 7: $tarolo = "felhasznalo";
8: $$tarolo = "Anna";
9: // lehetne egyszerûen csak:
10: // $felhasznalo = "Anna";
11: // vagy
12: // ${"felhasznalo"} = "Anna"
13: // persze ekkor nem kellenek dinamikus változók
14: print "$felhasznalo
";
15: print $$tarolo;
16: print "
";
17: print "${$tarolo}
";
18: print "${'felhasznalo'}
";
19: ?>
20:
21:
Hivatkozások a változókra
A PHP alapértelmezés szerint értékadáskor a változók értékeit használja. Ez azt jelenti,
hogy ha az $egyikValtozo-t hozzárendeljük egy $masikValtozo-hoz,
akkor a $masikValtozo-ba az $egyikValtozo értékének másolata kerül.
Az $egyikValtozo tartalmának késõbbi módosítása nincs semmiféle hatással
a $masikValtozo-ra. A 4.2. példaprogram ezt mutatja be.
4.2. program Változók érték szerinti hozzárendelése

1:
2:
3:
4:
5:
6: 7: $egyikValtozo = 42;
8: $masikValtozo = $egyikValtozo;
9: // $masikValtozo-ba $egyikValtozo tartalmának
másolata kerül
10: $egyikValtozo = 325;
11: print $masikValtozo; // kiírja, hogy 42
12: ?>
13:
14:

Itt a 42 értéket adjuk az $egyikVatozo-nak, majd a $masikValtozo-hoz hozzá-
rendeljük az $egyikValtozo-t. Ekkor a $masikValtozo-ba az $egyikValtozo
értékének másolata kerül. A print utasítás igazolja ezt, mivel a böngészõben
a 42 jelenik meg.
A PHP 4-es kiadásában ezt a viselkedésmódot megváltoztathatjuk. Kikényszeríthetj
ük, hogy a $masikValtozo-ba ne az $egyikValtozo értéke kerüljön, hanem
egy hivatkozás, amely az $egyikValtozo-ra mutat. Ezt illusztrálja a 4.3. példaprogram.
4.3. program Változóra mutató hivatkozás

1:
2:
3:
4:
5:
6: 7: $egyikValtozo = 42;
8: $masikValtozo = &$egyikValtozo;
9: // $masikValtozo-ba $egyikValtozo-ra mutató
hivatkozás kerül
10: $egyikValtozo = 325;
11: print $masikValtozo; // kiírja, hogy 325
12: ?>
13:
14:

A 4.2. példaprogramhoz képest a változás mindössze egy karakter.
Az $egyikValtozo elé tett & jel gondoskodik róla, hogy az érték másolata helyett
a $masikValtozo-ba a változóra mutató hivatkozás kerül. Ezután
a $masikValtozo elérésekor az $egyikValtozo-ra vonatkozó mûveletek eredm
ényét láthatjuk. Más szavakkal: mind az $egyikValtozo,
mind a $masikValtozo ugyanazt a „tárolódobozt” használja, így értékeik
mindig egyenlõk. Mivel ez az eljárás kiküszöböli az egyik változóból a másikba tört
énõ értékmásolás szükségességét, csekély mértékben növelheti a teljesítményt.
Hacsak nem használunk nagyon gyakran értékadásokat, ez a teljesítménybeli nö-
vekedés alig érezhetõ.
40 4. óra
A hivatkozások a PHP 4-es változatában kerültek a nyelvbe.
Adattípusok
A különféle típusú adatok több-kevesebb helyet foglalnak a memóriában, a nyelv
pedig mindegyiket némileg más módon kezeli. Ezért néhány programozási nyelv
megköveteli, hogy a programozó elõre meghatározza a változótípusát. A PHP 4
gyengén típusos, ami azt jelenti, hogy az adattípusokat úgy kezeli, mintha a típus
az adathoz rendelt kiegészítõ információ lenne. A PHP vegyes megközelítést haszn
ál. Egyfelõl ez azt jelenti, hogy a változók rugalmasan használhatók: egyszer
karakterlánc, másszor esetleg szám lehet bennük. Másfelõl, nagyobb méretû programokban
zavar forrása lehet, ha egy adott típusú változót várunk egy változóban,
miközben valami teljesen más van benne.
A 4.1. táblázat a PHP 4-ben elérhetõ hat fontosabb adattípust tartalmazza, rövid le-
írással és példával.
4.1. táblázat Adattípusok
Típus Példa Leírás
Integer 5 Egész szám
Double 3.234 Lebegõpontos szám
String "hello" Karakterek sorozata, karakterlánc
Boolean true Logikai változó. Értéke igaz vagy hamis
(true vagy false) lehet
Object Objektum, lásd a nyolcadik, objektumokkal
foglalkozó órát
Array Tömb, lásd a hetedik, tömbökkel foglalkozó órát
Az adattípusok közül a tömböket és az objektumokat késõbbre hagyjuk.
A változó típusának meghatározására a PHP 4 beépített gettype() függvényét
használhatjuk. Ha a függvényhívás zárójelei közé változót teszünk, a gettype()
egy karakterlánccal tér vissza, amely a változó típusát adja meg. A 4.4. példaprogram
egy változóhoz négy különbözõ típusú értéket rendel, majd meghívja
a gettype() függvényt.
Az alkotóelemek 41
4
A függvényekrõl bõvebben a hatodik órában, a „Függvények”
címû részben tanulunk.
4.4. program Változó típusának vizsgálata

1:
2:
3:
4:
5:
6: 7: $proba = 5;
8: print gettype( $proba ); // integer
9: print "
"; // új sor, hogy ne follyanak össze
a típusnevek
10: $proba = "öt";
11: print gettype( $proba ); // string
12: print "
";
13: $proba = 5.0;
14: print gettype( $proba ); // double
15: print "
";
16: $proba = true;
17: print gettype( $proba ); // boolean
18: print "
";
19: ?>
20:
21:
Az elõbbi program a következõ kimenetet eredményezi:
integer
string
double
boolean
Az integer egész szám, vagyis olyan szám, amelyben nincs tizedesjegy („tizedespont
”).
42 4. óra
Könyvünk ugyan magyar nyelvû, a PHP 4 azonban az angol kifejez
éseket használja. A gettype ezért adja meg az integer, string,
double és boolean szavakat. Ugyanígy az angol írásmód szerint
a szám egészrészét a törtrésztõl nem tizedesvesszõ, hanem tizedespont
választja el. Annak érdekében, hogy ne kövessünk
elgépelési hibákat, a könyv hátralevõ részében a magyarul kicsit
szokatlanul csengõ tizedespont kifejezést használjuk.
A string karakterek sorozata. Ha programunkban karakterláncokkal dolgozunk,
mindig aposztrófok (') vagy macskakörmök (") közé kell azokat tennünk.
A double lebegõpontos szám, vagyis olyan szám, amely tartalmazhat tizedespontot.
A boolean a két logikai érték, a true (igaz) és a false (hamis) egyikét veheti fel.
Típus módosítása a settype() segítségével
A PHP a változó típusának módosítására a settype() függvényt biztosítja.
A settype()-ot úgy kell használnunk, hogy a megváltoztatandó típusú változót,
valamint a változó új típusát a zárójelek közé kell tennünk, vesszõvel elválasztva.
A 4.5. példaprogramban a 3.14-et (lebegõpontos szám, vagyis double) olyan típusokk
á alakítjuk, mely típusokat ebben a fejezetben részletesen tárgyalunk.
4.5. program Változó típusának módosítása a settype() függvény segítségével

1:
2:
3:
4:
5:
6: 7: $ki_tudja_milyen_tipusu = 3.14;
8: print gettype( $ki_tudja_milyen_tipusu ); // double
9: print " - $ki_tudja_milyen_tipusu
"; // 3.14
10: settype( $ki_tudja_milyen_tipusu, "string" );
11: print gettype( $ki_tudja_milyen_tipusu ); // string
12: print " - $ki_tudja_milyen_tipusu
"; // 3.14
13: settype( $ki_tudja_milyen_tipusu, "integer" );
14: print gettype( $ki_tudja_milyen_tipusu ); // integer
15: print " - $ki_tudja_milyen_tipusu
"; // 3
16: settype( $ki_tudja_milyen_tipusu, "double" );
17: print gettype( $ki_tudja_milyen_tipusu ); // double
18: print " - $ki_tudja_milyen_tipusu
"; // 3.0
19: settype( $ki_tudja_milyen_tipusu, "boolean" );
20: print gettype( $ki_tudja_milyen_tipusu ); // boolean
21: print " - $ki_tudja_milyen_tipusu
"; // 1

22: ?>
23:
24:

A típusmódosítás után minden esetben a gettype() függvényt használtuk,
hogy meggyõzõdjünk arról, hogy a típus módosítása sikerült, majd kiírjuk
a $ki_tudja_milyen_tipusu nevû változó értékét a böngészõbe. Amikor
a "3.14" karakterláncot egésszé alakítjuk, a tizedespont utáni információ elvész.
Ezért történhet meg, hogy a $ki_tudja_milyen_tipusu változónak még
akkor is 3 az értéke, amikor újból lebegõpontos számmá alakítjuk.
A végén a $ki_tudja_milyen_tipusu változót logikai típusúvá alakítottuk.
Az ilyen átalakításoknál a 0-tól különbözõ számok értéke – akárcsak a nem nulla
hosszúságú karakterláncoké – mindig true lesz. Amikor a PHP-ben kiírunk egy
logikai változót, akkor ha a változó értéke true, a kimeneten 1-et látunk, míg
a false értékû változók semmilyen kimenetet nem eredményeznek. Így már érthet
õ, hogy az utolsó kiíratás miért eredményezett 1-et.
Típus módosítása típusátalakítással
A változó neve elé zárójelbe írt adattípus segítségével a változó értékének általunk
meghatározott típusúvá alakított másolatát kapjuk. A lényegi különbség
a settype() függvény és a típusátalakítás között, hogy az átalakítás során
az eredeti változó típusa és értéke változatlan marad, míg a settype() alkalmaz
ása során az eredeti változó típusa és értéke az új adattípus értelmezési
tartományához idomul. A 4.6. program ezt hivatott illusztrálni.
4.6. program Változó típusának módosítása
típusátalakítás segítségével

1:
2:
3:
4:
5:
6: 7: $ki_tudja_milyen_tipusu = 3.14;
8: $tarolo = ( double ) $ki_tudja_milyen_tipusu;
9: print gettype( $tarolo ) ; // double
10: print " - $tarolo
"; // 3.14
11: $tarolo = ( string ) $ki_tudja_milyen_tipusu;
12: print gettype( $tarolo ); // string
13: print " - $tarolo
"; // 3.14
14: $tarolo = ( integer ) $ki_tudja_milyen_tipusu;
15: print gettype( $tarolo ); // integer
16: print " - $tarolo
"; // 3
17: $tarolo = ( double ) $ki_tudja_milyen_tipusu;
18: print gettype( $tarolo ); // double
19: print " - $tarolo
"; // 3.14
20: $tarolo = ( boolean ) $ki_tudja_milyen_tipusu;
21: print gettype( $tarolo ); // boolean
22: print " - $tarolo
"; // 1
23: ?>
24:
25:

A $ki_tudja_milyen_tipusu változó típusát a program egyik pontján sem
változtattuk meg, az végig lebegõpontos szám marad. Csupán másolatokat hozunk
létre, amelyek az általunk meghatározott típusúvá alakulnak és az új érték kerül
aztán a $tarolo nevû változóba. Mivel a $ki_tudja_milyen_tipusu másolat
ával dolgozunk, a 4.5. példaprogrammal ellentétben az eredeti változóban
semmilyen információt nem veszítünk el.
Mûveletjelek és kifejezések
Most már képesek vagyunk adatokat helyezni változóinkba, meghatározhatjuk,
sõt meg is változtathatjuk egy változó típusát. Egy programozási nyelv azonban
nem túl hasznos, ha a tárolt adatokkal nem végezhetünk mûveleteket. A mûveletjelek
(operátorok) olyan jelek, amelyek azon mûveleteket jelzik, melyek lehetõvé
teszik, hogy egy vagy több értékbõl egy új értéket hozzunk létre. Az értéket,
amellyel a mûveletet végezzük, operandusnak hívjuk.
Az operátor (mûveletjel) jel vagy jelsorozat, amelyet ha értékek összekapcsol
ására használunk, valamilyen mûveletet végezhetünk, amely
általában új értéket eredményez.
Az operandus egy érték, amelyet a mûveletjellel kapcsolatban használunk.
Egy mûveletjelhez általában két operandus tartozik.
Kapcsoljunk össze két operandust és hozzunk létre egy új értéket:
4 + 5
Itt a 4 és az 5 az operandusok. Az összeadó operátor (+) végez rajtuk mûveletet
és ez szolgáltatja a 9 értéket. A mûveletjelek többsége két operandus között
helyezkedik el, bár az óra késõbbi részében látni fogunk néhány kivételt is.
Az operandusok és mûveletjelek együttesét kifejezésnek hívjuk. Annak ellenére,
hogy még a legelemibb kifejezéseket is mûveletjelek segítségével hozzuk létre,
a kifejezésnek nem kell szükségszerûen operátort tartalmaznia. Valójában a PHP
mindent, ami értéket határoz meg, kifejezésnek tekint. Így az állandók, például
az 543; változók, mint a $felhasznalo és a függvényhívások, például
a gettype() is kifejezések, a 4+5 kifejezés pedig két további kifejezésre (4 és
5) és egy operátorra bontható.
A kifejezés a függvények, értékek és mûveletjelek olyan együttese,
amely értéket határoz meg. Általánosságban azt mondhatjuk, hogy
ha értékként használhatunk valamit, akkor az kifejezés.
Most, hogy az alapelveket tisztáztuk, ideje megismerkednünk a PHP 4 alapvetõ
mûveleteivel.
Hozzárendelés
Már találkoztunk a hozzárendelõ mûveletjellel, valahányszor értéket adtunk változ
óinknak. A hozzárendelõ operátor egyetlen karakterbõl áll, az egyenlõségjelbõl
(=). Jelentése: a mûveletjel jobb oldalán álló kifejezés értékét hozzárendeljük a bal
oldali operandushoz.
$nev = "Kõmûves Kelemen";
A $nev változó ekkor a "Kõmûves Kelemen" szöveget fogja tartalmazni. Érdekes
módon, ez az értékadás maga is egy kifejezés. Elsõ látásra úgy tûnik, hogy a hozzá-
rendelés csak a $nev értékét változtatja meg, de valójában a kifejezés, amely a hozz
árendelõ mûveletjelbõl áll, mindig a jobb oldalon álló kifejezés értékének másolatát
adja vissza. Így a
print ( $nev = "Kõmûves Kelemen" );
utasítás kiírja a böngészõbe, hogy "Kõmûves Kelemen", azon felül, hogy
a "Kõmûves Kelemen" szöveget a $nev változóhoz rendeli.
Aritmetikai mûveletek
Az aritmetikai mûveletek pontosan azt teszik, amit elvárunk tõlük. A 4.2. táblázat
a megfelelõ mûveletjeleket sorolja fel. Az összeadó mûveletjel hozzáadja a jobb
oldali operandust a bal oldalihoz, a kivonó mûveletjel a jobb oldali operandust
kivonja a bal oldaliból, az osztó mûveletjel a bal oldali operandust elosztja a jobb
oldalival, a szorzó mûveletjel pedig összeszorozza a bal és a jobb oldali
operandusokat. A maradékképzõ (modulus) mûveletjel a bal és a jobb operandus
egész osztásának maradékát adja.
4.2. táblázat Aritmetikai mûveletek
Mûveletjel Név Példa Érték
+ Összeadás 10+3 13
- Kivonás 10-3 7
/ Osztás 10/3 3.333333333333
* Szorzás 10*3 30
% Maradék 10%3 1
Összefûzés
Az összefûzés jele a pont (.). Mindkét operandust karakterláncnak tekintve,
a jobb oldali elemet hozzáfûzi a bal oldalihoz. Vagyis a
"Para" . " Zita"
kifejezés értéke:
"Para Zita"
Az elemek típusuktól függetlenül karakterláncként értékelõdnek ki és az eredmény
is mindig karakterlánc lesz.
További hozzárendelõ mûveletek
Annak ellenére, hogy valójában csak egy hozzárendelõ mûvelet van, a PHP 4
számos további mûveletjelet biztosít, amelyek a bal oldali operandust módosítják.
A mûveletek az operandusokat általában nem változtatják meg, ez alól azonban
a hozzárendelés kivétel.
Az összetett hozzárendelõ mûveletjelek egy hagyományos mûveletjelbõl és az azt
követõ egyenlõségjelbõl állnak. Az összetett mûveletjelek megkímélnek minket att
ól, hogy két operátort kelljen használnunk és az elgépelés esélyét is csökkentik. A
$x = 4;
$x += 4; // $x most 8
például egyenértékû a következõvel:
$x = 4;
$x = $x + 4; // $x most 8
Hozzárendelõ mûveletjelet minden aritmetikai és összefûzõ jelhez kapcsolhatunk.
A 4.3. táblázat a leggyakoribb párosításokat tartalmazza.
4.3. táblázat Néhány összetett hozzárendelõ mûveletjel
Mûveletjel Példa Egyenértékû kifejezés
+= $x += 5 $x = $x + 5
-= $x -= 5 $x = $x - 5
*= $x *= 5 $x = $x * 5
/= $x /= 5 $x = $x / 5
%= $x %= 5 $x = $x % 5
.= $x .= "próba" $x = $x . "próba"
A 4.3. táblázat minden példájában a $x változó értéke változik meg, a jobb oldali
operandusnak megfelelõen.
Összehasonlítás
Az összehasonlító mûveletek az operandusokon vizsgálatokat végeznek. Logikai
értékkel térnek vissza, vagyis értékük true lesz, ha a feltételezett viszony fennáll,
és false, ha nem. Ez a típusú kifejezés az olyan vezérlési szerkezetekben hasznos,
mint az if és while utasítások. Ezekkel az ötödik órában találkozunk majd.
Ha meg szeretnénk vizsgálni, hogy az $x-ben tárolt érték kisebb-e 5-nél, a kisebb,
mint jelet használhatjuk:
$x < 5
Ha $x értéke 3, a kifejezés értéke true, ha $x értéke 7, a kifejezés értéke false lesz.
Az összehasonlító mûveletjeleket a 4.4. táblázatban találhatjuk. $x értéke 4.
4.4. táblázat Összehasonlító mûveletek
Mûveletjel Név Igaz, ha Példa Eredmény
== egyenlõ a két érték megegyezik $x == 5 false
!= nem egyenlõ a két érték különbözõ $x != 5 true
=== azonos a két érték és típus $x === 5 false
megegyezik
!== nem azonos a két érték vagy típus $x !== 5 true
különbözõ
> nagyobb, mint a bal oldal nagyobb $x > 4 false
a jobb oldalnál
>= nagyobb, vagy a bal oldal nagyobb $x >= 4 true
egyenlõ a jobb oldalnál,
vagy egyenlõ
< kisebb, mint a bal oldal kisebb $x < 4 false
a jobb oldalnál
<= kisebb, vagy a bal oldal kisebb $x <= 4 true
egyenlõ a jobb oldalnál,
vagy egyenlõ
Ezeket a mûveletjeleket többnyire egészekkel vagy lebegõpontos számokkal haszn
áljuk, bár az egyenlõség karakterláncok esetében is vizsgálható.
Bonyolultabb összehasonlító kifejezések létrehozása
logikai mûveletek segítségével
A logikai mûveletjelek logikai értékeken végeznek mûveleteket. A vagy operátor
például true-val tér vissza, ha bal vagy jobb operandusa true.
true || false
A fenti eredménye true.
Az és operátor csak akkor ad true-t, ha mindkét operandusa true.
true && false
A fenti értéke false. Valószínûtlen azonban, hogy a gyakorlatban logikai álland
ókon akarunk mûveleteket végezni. Sokkal több értelme van, hogy két vagy
több kifejezést vizsgáljunk meg. Például:
( $x > 2 ) && ( $x < 15 )
Az eredmény itt true, ha az $x-ben tárolt érték nagyobb, mint 2, de kisebb,
mint 15. A zárójeleket azért tettük be, hogy a programkód átláthatóbb legyen.
A 4.5. táblázat a logikai mûveleteket sorolja fel.
4.5. táblázat Logikai mûveletek
Mûveletjel Név Igaz, ha Példa Eredmény
|| vagy a bal vagy a jobb true || false true
operandus igaz
or vagy a bal vagy a jobb true or false true
operandus igaz
xor kizáró vagy vagy a bal, vagy a jobb true xor true false
operandus igaz,
de csak az egyikük
&& és a bal és a jobb true && false false
operandus is igaz
and és a bal és a jobb true and false false
operandus is igaz
! tagadás az egyetlen operandus !true false
hamis
Miért kell kétféle vagy és és mûveletjel? A magyarázat a mûveletek kiértékelési
sorrendjében rejlik, amelyrõl a fejezet késõbbi részében tanulunk.
Egész típusú változók értékének növelése
és csökkentése
Amikor PHP-ben programozunk, gyakran kerülünk olyan helyzetbe, hogy egy
egész típusú változó értékét kell eggyel növelnünk vagy csökkentenünk. Ez jellemz
õen abban az esetben fordul elõ, amikor egy ciklusban számolunk valamit.
Már két módját is tanultuk annak, hogyan tehetjük ezt meg. Egyrészt lehetõségünk
van az összeadó mûveletjellel növelni a változó értékét:
$x = $x + 1; // $x értéke eggyel nõ
De használhatunk összetett értékadó-összeadó mûveletjelet is:
$x += 1; // $x értéke eggyel nõ
Az eredmény mindkét esetben $x-be kerül. Mivel az ilyen típusú kifejezések
nagyon gyakoriak, ezért a PHP (a C nyelv mintájára) biztosít egy különleges mûveletet,
amely lehetõséget ad arra, hogy egy egész típusú változóhoz hozzáadjunk
egyet vagy kivonjunk belõle egyet. A megfelelõ mûveletjelek a növelõ, illetve csökkent
õ operátorok. Ezeknek utótagként (poszt-inkrementáló és poszt-dekrementáló)
és elõtagként (pre-inkrementáló és pre-dekrementáló) használt változata is létezik.
Az utótagként használt növelõ mûveletjel a változó neve után írt két pluszjelbõl áll.
$x++; // $x értéke eggyel nõ
Ha hasonló módon két mínuszjelet írunk a változó neve után, a változó értéke
eggyel csökken.
$x-; // $x értéke eggyel csökken
Ha a növelõ vagy csökkentõ mûveletjelet feltételes kifejezésen belül használjuk,
fontos, hogy az operandus értéke csak a feltétel kiértékelése után változik meg:
$x = 3;
$x++ < 4; // igaz
A fenti példában $x értéke 3, amikor a 4-gyel hasonlítjuk össze, így a kifejezés
értéke igaz. Miután az összehasonlítás megtörtént, $x értéke eggyel nõ. Bizonyos
körülmények között arra lehet szükség, hogy a változó értéke a kiértékelés elõtt
csökkenjen vagy nõjön. Erre szolgálnak az elõtagként használt változatok. Önmagukban
ezek a mûveletjelek ugyanúgy viselkednek, mint utótagként alkalmazott
formáik, csak a két plusz- vagy mínuszjelet ekkor a változó neve elé kell írnunk.
++$x; // $x értéke eggyel nõ
-$x; // $x értéke eggyel csökken
Ha ezek a mûveletjelek egy nagyobb kifejezés részei, a változó értékének módosí-
tása a vizsgálat elõtt történik meg.
$x = 3;
++$x < 4; // hamis
Ebben a kódrészletben $x értéke eggyel nõ, mielõtt összehasonlítanánk 4-gyel.
Az összehasonlítás értéke false, mivel a 4 nem kisebb 4-nél.
A mûveletek kiértékelési sorrendje
Az értelmezõ a kifejezéseket általában balról jobbra olvassa. A több mûveletjelet
tartalmazó összetettebb kifejezéseknél már bonyolultabb a helyzet. Elõször vegyünk
egy egyszerû esetet:
4 + 5
Itt minden tiszta és érthetõ, a PHP hozzáadja a 4-et az 5-höz. De mi a helyzet
a következõ esetben?
4 + 5 * 2
Itt már egy problémával találkozunk szembe: a kifejezés azt jelenti, hogy „vedd
a négyet és az ötöt, add össze õket, majd az eredményt szorozd meg kettõvel”,
vagyis 18 az értéke? Esetleg azt, hogy „add hozzá a négyhez az öt és a kettõ
szorzatát”, vagyis az eredmény 14? Ha egyszerûen balról jobbra olvasnánk, akkor
az elsõ változatot kellene elfogadnunk. A PHP-ben azonban minden mûveletjelhez
tartozik egy „elsõbbségi tényezõ” (prioritás). Mivel a szorzás elsõbbséget élvez az
összeadással szemben, így (iskolai tanulmányainkkal összhangban) a második vá-
lasz a helyes megoldás.
Természetesen van rá lehetõség, hogy kikényszerítsük, hogy elõször az összeadás
hajtódjon végre. Erre a zárójelek használata ad lehetõséget:
( 4 + 5 ) * 2
Bármilyen sorrendben értékelõdjenek is ki a mûveletek, ha hosszú kifejezésekkel
dolgozunk vagy nem vagyunk biztosak a dolgunkban, érdemes zárójeleket haszn
álnunk, így érthetõbbé válik a program és megkíméljük magunkat a hibakeresés
fáradalmaitól. A 4.6. táblázatból az ebben az órában tárgyalt mûveletek elsõbbségét
tudhatjuk meg (csökkenõ sorrendben).
4.6. táblázat A mûveletek elsõbbsége csökkenõ sorrendben.
Mûveletjelek
! ++ -- (típusátalakítás)
/ * %
+ - .
< <= => >
== === != !==
&&
||
= += -= /= %= .=
and
xor
or
Mint látjuk, az or késõbb értékelõdik ki, mint a || mûveletjel, az and-del szemben
pedig elsõbbséget élvez a &&, így a kisebb prioritású logikai mûveletjeleket
használva az összetett logikai kifejezések olvasásmódját módosíthatjuk. Ez nem
feltétlenül mindig jó ötlet. Bár a következõ két kifejezés egyenértékû, a második
kifejezés könnyebben olvasható:
$x || $y and $z
( $x || $y ) && $z
Állandók
A változók rugalmas adattárolási lehetõséget nyújtanak számunkra. Megváltoztathatjuk
értéküket, sõt típusukat is, bármely pillanatban. Ha azonban azt szeretnénk,
hogy egy adott név alatt tárolt érték ne változzon a program futása során, létrehozhatunk
állandókat (konstansokat) is. Ezt a PHP beépített define() függvénye
segítségével tehetjük meg. Miután az állandót létrehoztuk, annak értékét nem
szabad (nem tudjuk) megváltoztatni. Az állandó nevét, mint karakterláncot és
az értéket vesszõvel elválasztva a zárójeleken belülre kell írnunk.
define( "ALLANDO_NEVE", 42);
Az állandó értéke természetesen lehet szám, karakterlánc vagy logikai típusú is.
Az a szokás, hogy az állandók neve CSUPA NAGYBETÛBÕL áll. Az állandók neve
nem tartalmaz dollárjelet, így az állandók elérése csupán a név leírásából áll.
A 4.7. példaprogramban láthatunk egy példát állandók elérésére és használatára.
4.7. program Állandó létrehozása

1:
2:
3:
4:
5:
6: 7: define ( "FELHASZNALO", "Virág" );
8: print "Üdvözlöm ".FELHASZNALO;
9: ?>
10:
11:

Figyeljük meg, hogy az állandónak a karakterláncba ágyazásakor összefûzést
kellett használnunk. Ez azért szükséges, mert az értelmezõ nem tudja megkülönb
öztetni a kettõs idézõjelbe írt egyszerû szöveget az állandók nevétõl.
Minden programban használható állandók
A PHP néhány beépített állandót automatikusan biztosít. Ilyen például a __FILE__,
amely az értelmezõ által beolvasott fájl nevét tartalmazza. A __LINE__ az aktuális
sor számát tartalmazza. Ezek az állandók hibaüzeneteink kiírásánál hasznosak. Az éppen
használt PHP változatszámát többek között a PHP_VERSION állandóból tudhatjuk
meg. Ez akkor lehet elõnyös, ha egy program csak a PHP egy adott változatával
futtatható.

Összefoglalás
Ebben az órában végigvettük a PHP nyelv néhány alapvetõ tulajdonságát. Tanultunk
a változókról és arról, hogyan rendelhetünk hozzájuk értéket. Hallottunk
a dinamikus, vagyis „változó” változókról. Megtanultuk azt is, hogyan kell a változ
ó értékének másolata helyett a változókra hivatkozni. Új mûveletjeleket ismert
ünk meg és megtanultuk, hogyan kell azokat összetettebb kifejezésekké összegy
úrni. Végül megtanultuk, hogyan kell állandókat létrehozni és használni.

Kérdések és válaszok
Mikor kell tudnunk egy változó típusát?
Elõfordul, hogy a változó típusa behatárolja, milyen mûveleteket végezhetünk vele.
Például mielõtt egy matematikai kifejezésben használunk egy változót, megnézhetj
ük, hogy egyáltalán egész vagy lebegõpontos számot tartalmaz-e. Az ehhez hasonl
ó kérdésekkel kicsit késõbb, a tizenhatodik fejezetben foglalkozunk.
Muszáj követnünk a változók nevére vonatkozó szokásokat?
A cél mindig az, hogy a program egyszerûen olvasható és érthetõ legyen. Az olyan
változónevek, mint az $abc12345 nem mondanak semmit a változó programbeli
szerepérõl és elgépelni is könnyû azokat. Ezért érdemes rövid és jellemzõ neveket
választanunk.
Az $f név, bár rövid, bizonyára nem árul el semmit a változó szerepérõl.
Ezt most talán nehéz elhinni, de amikor egy hónap elteltével próbáljuk meg folytatni
a program írását, majd megtapasztaljuk. A $fajlnev már sokkal jobb választás.
Meg kell tanulnunk a mûveletjelek kiértékelési sorrendjét?
Nincs semmi akadálya, hogy megtanuljuk, de tartogassuk energiánkat fontosabb
dolgokra. Használjunk zárójeleket a kifejezésekben, így programunk jobban olvashat
ó lesz és nem kell törõdnünk a kiértékelési sorrenddel.

Mûhely
A mûhelyben kvízkérdések találhatók, melyek segítenek megszilárdítani az órában
szerzett tudást. A válaszokat az A függelékben helyeztük el.
Kvíz
1. Az alábbiak közül melyek NEM lehetnek változónevek?
$egy_felhasznalo_altal_elkuldott_ertek
$44444444444xyz
$xyz44444444444
$______________szamlalo______________
$az elso
$fajl-nev
2. Hogyan használhatjuk fel az alábbi változót dinamikus változó létrehozására?
A változónak adjuk a 4 értéket! Hogyan érhetjük el az új változót?
$en_valtozom = "dinamikus";
3. Milyen kimenetet eredményez az alábbi programsor?
print gettype("4");
4. Mit ír ki az alábbi néhány sor?
$proba_valtozo = 5.4566;
settype ( $proba_valtozo, "integer");
print $proba_valtozo;
5. Az alábbi sorok melyike nem tartalmaz kifejezést?
4;
gettype(44);
5/12;
6. Az elõzõ kérdésben szereplõ sorok melyikében van mûveletjel?
7. Az alábbi kifejezés milyen értéket ad vissza?
5 < 2
Milyen típusú a kérdéses érték?

Feladatok
1. Készítsünk programot, amely legalább öt különbözõ változót tartalmaz.
Adjunk nekik különbözõ típusú értékeket, majd használjuk a gettype()
függvényt a változók típusainak meghatározására.
2. Rendeljünk értéket két változóhoz. Használjuk az összehasonlító mûveleteket
annak eldöntésére, hogy az elsõ változó értéke
• azonos-e a második változó értékével
• kisebb-e a második változó értékénél
• nagyobb-e a második változó értékénél
• kisebb-e a második változó értékénél vagy egyenlõ-e azzal
Írassuk ki az összehasonlítások eredményét a böngészõbe!
Változtassuk meg a változók értékét és futtassuk le újból a programot!