A logikai operátorok segítségével ÉS (AND), VAGY (OR), KIZÁRÓLAGOS VAGY (XOR) és TAGADÁS (NOT) műveleteket végezhetünk el. A visszatérő érték igaz (true) vagy hamis (false) lehet:

$a and $b

AND műveletet végez, az értéke IGAZ, ha az $a és a $b értéke külön-külön igaz.

$a or $b

OR műveletet véget, az értéke IGAZ, ha vagy az $a, vagy a $b értéke igaz (beleértve azt az esetet, amikor mindkettő igaz).

$a xor $b

XOR műveletet végez, az értéke IGAZ, ha vagy az $a, vagy a $b értéke igaz, viszont mindkettő nem lehet igaz.

!$a

NOT műveletet végez, az értéke IGAZ, ha az $a értéke nem IGAZ.

$a && $b

AND műveletet végez, az értéke IGAZ, ha az $a és a $b értéke külön-külön igaz.

$a || $b

OR műveletet véget, az értéke IGAZ, ha vagy az $a, vagy a $b értéke igaz (beleértve azt az esetet, amikor mindkettő igaz).

Miért van kétféle AND és OR operátorunk?

A műveletek sorrendje szerint a kétféle logikai operátor viselkedése eltér egymástól. A || operátor műveleti sorrendje magasabb, mint az or operátoré - ugyanez a helyzet a && és az and operátor esetében is.

Figyeljünk oda a logikai operátorok használata esetén a következő esetekre:

$a = false || true;  úgy viselkedik, mintha ezt írtuk volna: $a = (false || true); - először a zárójelben levő rész értékelődik ki, majd a visszatérő értéket veszi fel az $a változó.

$b = false or true; esetében viszont a sorrend: ($b = false) or true; - vagyis a $b változóhoz hozzárendelődik a false érték, utána pedig következik a kiértékelés:

$a = true and false;     // $a === true
$c = (true and false);   // $b === false
$c = true && false;      // $c === false

Figyelem!
Tartsuk szem előtt azt a tényt is, hogy a logikai kiértékelések minden esetben logikai értékkel térnek vissza, vagyis más nyelvektől eltérően nem használható alapértékek beállításához:

------------------------------ 

<?php

$gyumolcs = $valasztott_gyumolcs || 'alma';
echo $gyumolcs; // Kiírja: 1, habár azt vártuk volna, hogy 'alma' lesz a kiírt szöveg

?>

------------------------------ 

--------------------------------------------

Feladatok

1. Vegyünk fel két változót, és vizsgáljuk meg az ÉS műveletes kiértékelésüket mindkét operátor típussal!

2. Vegyünk fel három változót, és vizsgáljuk meg együttesen VAGY művelettel őket!

3. Egy változó tagadott értékét kizárólagos vagy művelettel vessük össze egy másik változó értékével!

Programozás közben szinte elkerülhetetlen az a forgatókönyv, amikor egy szám típusú változó értékét növelnünk vagy csökkentenünk kell. A növelést "++", a csökkentést pedig "--" operátorokkal érhetjük el. Ilyenkor a változó értéke eggyel növekszik vagy csökken. 

Attól függően, hogy az operátort a változó elé vagy mögé írjuk, két különböző viselkedést tapasztalhatunk: az elé írt operátorral (++$szam) előzetes értéknövelés történik (a $szam értéke eggyel növekszik, majd visszatér a $szam új értékével), a mögé írttal pedig ($szam++) először visszatér az értékkel, majd utána növeli:

-----------------------

<?php
$szam_a = 1;
$szam_b = 2;

echo ' $szam_a: ';
echo $szam_a++; // Kiírja: 1 (mivel az értéknövelés csak a kiírás után történik)
echo ' $szam_b: ';
echo ++$szam_b; // Kiírja: 3 (itt az értéknövelés már a kiírás előtt megtörtént)

?>

-----------------------

Érdekesség

Mi történik, ha egy stringet növelünk? Hasonlóan a Perl nyelvhez, a PHP is az a-z, A-Z és 0-9 tartományokat támogatja, valamint csak a növelés operátor működik. Ha az "a" értékű változót növeljük, az eredmény "b" lesz (mindig a soron következő karakter), ha eléri a lista végét (pl. "z"), akkor eggyel arrébb csúsztatja, és kezdi elölről: "z" után "aa" jön, "aa" után "ab", stb.

-----------------------

<?php
$szoveg = 'a';

echo ' $szoveg: ';
echo ++$szoveg; // Kiírja: b (mivel az értéknövelés megtörtént)
?>

-----------------------

Figyeljük meg az alábbi példát! Habár azt várnánk, hogy a fenti módszerrel a '01' értékű változó növelt értéke '02' lesz, ez nem így van: a PHP automatikusan számként fogja értelmezni, és '2' lesz az eredmény. Ezt ellenőrizhetjük a var_dump segítségével:

-----------------------

<?php
$szoveg = '01';
echo var_dump($szoveg); // vizsgálat: itt még string!
echo ' $szoveg: ';
echo ++$szoveg; // Kiírja: 2 (habár azt várnánk el, hogy '02' legyen az eredmény!)
echo ' ';
echo var_dump($szoveg); // újbóli vizsgálat: itt már integer!
?>

-----------------------

A fenti eset miatt nagyon óvatosan bánjunk az értéknövelt stringekkel, mert elképzelhető, hogy meglepetést okozhat az eredmény. Ez is egy jó példa a gyenge típusosság (amikor egy változó típust válthat művelet közben) csapdájára.

Figyelem!

Habár a $szam += 1 forma azonos hatást produkál a ++$szam formával, a mérések alapján az első gyorsabb. Továbbá a ++$szam gyorsabb és kevesebb memóriát foglal, mint a $szam++. Ha tehetjük, és a programunk logikája megengedi, használjuk az első alakot!

Mi történik, ha a változót nem hoztuk létre, és úgy növeljük? Habár azt várnánk, hogy legalább egy figyelmeztetést kapunk majd, ez nem történik meg, hanem 0 értékkel létrejön a változó, majd megtörténik az értékváltoztatás.

-----------------------

<?php
echo ++$valtozo; // Kiírja: 1 (hibajelzés nélkül létrejön a változó 0 értékkel, majd növeli eggyel)
?>

-----------------------

Láthatjuk, hogy az egyszerűnek tűnő operátor mennyire változatosan tud viselkedni. A váratlan eredmények elkerülése érdekében gondoljuk át jól, hogy mit is akarunk elérni az alkalmazásukkal!

----------------------------------------------

Feladatok

1. Hozzunk létre két változót, az egyik értékét növeljük eggyel, majd az értéknövelt változóból vonjuk le a második változó értékét!

2. Egy string típusú változót növeljünk, majd írjuk ki az eredményt! 

3. Vizsgáljuk meg egy változó előzetes és utólagos értéknövelését, valamint értékcsökkentését!

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: 

1. Ha egyenlőek, az érték: 0  ( Pl.: 1 <=> 1)
2. Ha az első kisebb, mint a második, az érték: -1 ( Pl.:  1 <=> 2)
3. 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!

Hozzárendelő operátorok

Ahhoz, hogy a változók értékeket kapjanak, valamilyen módon hozzá kell rendelni azt. Az alapértelmezett hozzárendelő operátor az "=" jel, ezt használjuk a legtöbbször. Az előző leckék példáiban ezt számtalanszor láthattuk: $valtozo = 'érték'; formában.

Tömbök esetében egy kulcshoz az "=>" jellel rendelünk hozzá értéket, így:

$tomb = array('kulcs' => 'kulcs értéke', 'kulcs2' => 'második kulcs értéke');

Ez alól kivétel az az eset, amikor a tömb elemét $tomb['kulcs'] formában hivatkozzuk, ilyenkor az érték hozzárendelése az "=" jellel történik:

$tomb['kulcs1'] = 'érték';

Megjegyzés
A számozott tömbök esetében automatikus kulcsérték növelést (auto-increment) érünk el, amennyiben a szögletes zárójeleket üresen hagyjuk. Ebben az esetben a tömb soron következő számú kulccsal növekedik.

Példa:

---------------------------

<?php
$tomb = array(); // üres tömb létrehozása
$tomb[] = 'első érték'; // első érték hozzárendelése a 0-ás kulccsal azonosított elemhez
$tomb[] = 'második érték'; // második érték hozzárendelése az 1-es kulcssal azonosított elemhez
print_r($tomb);

/* Mivel echo-t tömb esetében nem használhatunk, print_r-t használunk, hogy lássuk a tömb elemeit.
Kiírja: Array ( [0] => első érték [1] => második érték )
*/
?>

---------------------------

Számok esetén használt hozzárendelő operátorok

Egy változó értékének növeléséhez a "+=" operátort, míg a csökkentéséhez a "-=" operátort használhatjuk. Továbbá működnek a szorzás ("*="), osztás ("/=") és maradékos osztás ("%=") operátorok is:

---------------------------

<?php
$szam = 1;
$szam += 2; // a $szam változó értékének növelése 2-vel
echo $szam; // Kiírja: 3

echo "\n"; // Új sor karakter. Figyeljük meg a kettős idézőjelet!

$szam -= 1; // a $szam csökkentése 1-gyel
echo $szam; // Kiírja: 2

echo "\n";

$szam *= 20; // a $szam szorzása 20-szal
echo $szam; // Kiírja: 40

echo "\n";

$szam /= 2; // a $szam osztása 2-vel
echo $szam; // Kiírja: 20

echo "\n";

$szam %= 3; // a $szam maradékos osztása 3-mal 
echo $szam; // Kiírja:  2

echo "\n";
?>

---------------------------

Megjegyzés
Figyeljük meg a fenti példában a sortörést, amelyet a "\n" hoz létre. Böngészőben azonban ez szóköznek fog látszani, mivel a böngésző html kódot vár a formázáshoz. A fenti példa szöveges terminálon futtatva szemlélteti a sortörést, böngészőből az oldal forrását nézve láthatjuk a sortörések helyét.

Szövegek esetén használt hozzárendelő operátor

Ha szöveges változó tartalmát akarjuk kibővíteni, akkor a rendelkezésünkre áll az összefűzés. String típusú tartalmakat a "." karakterrel tudjuk összefűzni:

$szoveg = 'első rész ' . ' második rész';

Amennyiben további résszel bővítenénk, akkor így tehetjük meg:

---------------------------

<?php
$szoveg = 'első rész ';
$szoveg .= 'második rész'; // hozzáadjuk a kibővítést
echo $szoveg; // Kiírja: első rész második rész
?>

---------------------------

TIPP
Habár a fenti példában a $szoveg .= 'második rész'; egyenértékű a $szoveg = $szoveg . 'második rész'; formával, tanácsos az elsőt használni, mivel a memóriafoglalások miatt gyorsabb. Ez főleg olyankor látványos, ha nagyon sok ilyen műveletet kell elvégezni, hatalmas mennyiségű adattal.

Hivatkozási operátor

Előfordulhat olyan eset, amikor úgy hozunk létre egy új változót, hogy egy másik, már létező változó tartalmára akarunk hivatkozni, annak másolása nélkül. Ezt a "&" operátorral tehetjük meg: 

--------------------------

<?php
$elso_valtozo = 'eredeti változó';
$masodik_valtozo = &$elso_valtozo;
echo $masodik_valtozo; // Kiírja: eredeti változó
?>

--------------------------

-----------------------------------------------------------------------------------------------------

Feladatok

1. Határozzunk meg egy pozitív egész számot, adjunk hozzá 10-et, a kapott eredményből vonjunk le 3-at, majd az így kapott értéket szorozzuk meg 30-cal, utána pedig osszuk el 4-gyel, a kapott  eredményt pedig írjuk ki!

2. Szövegösszefűzéssel írjuk le a nevünket!

3. Vegyünk fel két szöveges változót, amelybe két tetszőleges szöveget írjunk,  hivatkozási operátorral hozzunk létre egy harmadikat, amely az elsőre mutat, majd fűzzük össze a harmadikat a másodikkal, és írjuk ki!

Mivel minden alkalmazás valamilyen műveleti céllal jött létre, a nyelv tanulása szempontjából nagyon fontos megérteni és helyesen használni a különböző műveleteket. Az egyik legfontosabb műveleti csoport az aritmetikai. Ezek segítségével végzünk számításokat. Feltételezem, hogy mindenki tisztában van a műveletek sorrendjével, ezeket nem tárgyaljuk külön. A php nyelv operátoroknak nevezett jeleket használ a műveletek elvégzésére. Lássuk őket sorban:

Aritmetikai műveletek operátorai

Az aritmetikai műveletek operátorai a matematika órákról ismert módon történő számokkal való műveleteket teszik lehetővé:

1. Tagadás (negáció)

Egy $szam változó tagadása: -$szam

Példa:

------------------------------

<?php
$szam = 1;
echo -$szam; // Kiírja: -1
?>

------------------------------

Megjegyzés
A php nem jelez hibát, ha szöveges változót negálunk, ebben az esetben az eredmény: 0.

2. Összeadás

Két számértékű változó összeadását a "+" operátorral végezzük el: $elso_szam + $masodik_szam

Példa:

-----------------------------

<?php
$elso_szam = 1;
$masodik_szam = 2;
echo $elso_szam + $masodik_szam; // Kiírja: 3
?>

-----------------------------

3. Kivonás

Két számértékű változó kivonását a "+" operátorral végezzük el: $elso_szam + $masodik_szam

Példa:

-----------------------------

<?php
$elso_szam = 10;
$masodik_szam = 2;
echo $elso_szam - $masodik_szam; // Kiírja: 8
?>

-----------------------------

4. Szorzás

Két számértékű változó szorzását a "*" operátorral végezzük el: $elso_szam * $masodik_szam

Példa:

-----------------------------

<?php
$elso_szam = 10;
$masodik_szam = 2;
echo $elso_szam * $masodik_szam; // Kiírja: 20
?>

-----------------------------

5. Osztás

Két számértékű változó osztását a "/" operátorral végezzük el: $elso_szam / $masodik_szam

Példa:

-----------------------------

<?php
$elso_szam = 10;
$masodik_szam = 2;
echo $elso_szam / $masodik_szam; // Kiírja: 5
?>

-----------------------------

Megjegyzés
Figyeljünk oda, a 0-val való osztás nem értelmezett, és végzetes hibát fog eredményezni!

6. Osztási maradék (modulus)

Két szám osztási maradékát a "%" operátorral kapjuk meg: $elso_szam % $masodik_szam. A gyakorlati haszna a prímszámkereséstől a páros-páratlan szám vizsgálaton át sokrétű lehet. Ezt az operátort azért vezették be, mivel a fentebb említett alapműveletekkel csak kiegészítő függvényeken keresztül tudnánk vizsgálni. 

Példa:

-----------------------------

<?php
$elso_szam = 10;
$masodik_szam = 4;
echo $elso_szam % $masodik_szam; // Kiírja: 2
?>

-----------------------------

A fenti példa kis magyarázatra szorul, az egyértelműsítés miatt: 10-ben a 4 megvan 2-szer, mert 2 * 4 = 8, 10-ből kivonjuk a kapott 8-at, így marad 2. Másik példával: 10-ben a 3 megvan 3-szor, mert 3 * 3 = 9, 10-ből kivonjuk a kapott 9-et, a maradék pedig 1. Amennyiben a maradék 0, az első szám osztható a másodikkal maradék nélkül.

 7. Hatványozás (5.6-os verzióban vezették be)

 A hatványozást "**" operátorral végezhetjük el, azonban óvatosan használjuk, mivel a régebbi verziók végzetes hibával leállnak! Csak akkor használjuk, ha biztosak vagyunk a php verziójában. Egyéb esetben ezt függvénnyel tudjuk megoldani, amiről később ejtünk szót.

Példa:

-----------------------------

<?php
$elso_szam = 10;
$masodik_szam = 4;
echo $elso_szam ** $masodik_szam; // Kiírja: 10000
?>

-----------------------------

Megjegyzés
Figyeljünk oda, a más nyelvekből ismert "^" operátor a php-ban NEM HATVÁNYOZÁST jelent!

----------------------------------------------------------------------------------------

Feladatok

1. Misi 8 éves, a húga, Blanka pedig 2 évvel fiatalabb. Írjunk egy alkalmazást, amely kiszámolja Blanka életkorát!

2. Egy zsemle 10 forintba kerül. Hány forintba kerül 12 zsemle?

3. Egy alma ára duplája egy retek árának. Ha 10 retek 100 forintba kerül, mennyi az ára 3 almának? Az alkalmazást írjuk meg minél kevesebb lépésben!

a) A php fájlok szerkezete

A php fájlok szöveges állományok, amelyeket a php nyelv értelmezője futtat. Létrehozhatjuk bármilyen egyszerű szövegszerkesztővel, a fájl kiterjesztése konvenciók szerint ".php", azonban valójában ez nem megkötés. Az értelmező a nyitó és záró tag-ek közötti részt tekinti php kódnak, az ezen kívül eső rész egyszerű szövegként kerül kiírásra. A nyelv alapértelmezett nyitó és záró tag-jei a "<?php" és a "?>", valamint a rövidített "<?" és "?>" - ahol ez engedélyezve van. A megjegyzéseket "//" jellel kezdjük soronként, valamint "/*" és "*/" jelek közé tehetjük, ha több soros a megjegyzés. A különböző utasításokat pontosvesszővel (;) zárjuk.

A php fájlokban a nyelv saját függvényeit és osztályait valamint saját magunk által létrehozottakat használhatunk, valamint lehetőségünk van ezeket teljesen mellőzni is, ha a feladat megengedi.

Példa:

-------------------
<?php
/* Ez a program kiírja
a klasszikus "Hello World!"
szöveget. */
echo "Hello World!"; // Ez egy egy soros megjegyzés
?>
-------------------

Megfigyelhetjük a nyitó (<?php) és záró (?>) tageket, közöttük a "hasznos" résszel.

Tanács:

Ajánlatos a fájlban kerülni a többszörös tag nyitás-zárást, mivel ilyenkor az értelmezőt gátoljuk a futásban, emellett nehezebben olvasható a kód, amit írunk.

Rossz példa:
------------------
<html>
<head>
<title>Rossz példa</title>
</head>
<body>
<div>
<?php
echo "Én egy példa mondat vagyok.";
?>
</div>
<div>
<?php
echo "Én egy másik mondat vagyok!";
?>
</div>
</body>
</html>
------------------

Javított változat:

------------------
<?php
echo '<html>
<head>
<title>Jó példa</title>
</head>
<body>
<div>
Én egy példa mondat vagyok.
</div>
<div>
Én egy másik mondat vagyok!
</div>
</body>
</html>';
?>
------------------

b) Változók

A fenti példákból hiányzik valami: az a tulajdonság, amely megkülönbözteti egy statikus szöveges állománytól - semmi nem változik a futtatás során. Ahhoz, hogy igazán hasznos php alkalmazást írjunk, sehogy nem kerülhetjük el a változókat. A változók olyan speciális, adattartalommal bíró logikai egységek, amelyeket tetszés - és a logika korlátai - szerint felhasználhatunk. A változó ismérve a php nyelvben az, hogy "$" jellel kezdődik, amelyet betűkből, számokból, és bizonyos írásjelekből álló rész követ. A pontos tartományt a hivatalos kézikönyv tartalmazza, ajánlatos azonban betartani pár alapvető szabályt:

1. A $ jel után NEM ÁLLHAT szám. Pl. "$1alma"
2. Nem használhatunk szóköz karaktert. Pl. "$alma korte"
3. Habár a nyelv lehetővé teszi a kiterjesztett kódlapok használatát, nem ajánlott. Pl."$körte" helyett inkább "$korte" formában adjuk meg a változó nevét.
4. Használjunk beszédes változókat! Sokkal könnyebb lesz utólag a kódot értelmezni, ha a változó nevéből következtethetünk a tartalomra. Pl. "$var1" helyett "$szamlalo_ertek"
5. Habár a nyelv nem kéri, próbáljunk törekedni a változó típusossá tételére, esetleg az ellenőrzésére.

FIGYELEM!
Nem minden szintaktikailag helyes változót használhatjuk, mivel a php néhányat előre lefoglalt, ezek listáját a dokumentációban találjuk.

c) Változók típusai

A változók felvehetnek számértéket, szöveget, tömböt, logikai értéket, objektumot, valamint két speciális típust: a NULL-t és az erőforrást (resource).

Példák:

Számértékek (int, float):
$szam_ertek_1 = 1; // Egész szám
$szam_ertek_2 = 1.1; // Tizedes szám

Szöveges értékek (string):
$szoveg_ertek = "Ez egy szöveg."; // Dupla idézőjeles kiírás!*

Logikai értékek (boolean):
$logikai_ertek_1 = true; // Igaz érték
$logikai_ertek_2 = false; // Hamis érték

Tömbök (array):
$tomb_ertek_1 = array("első elem", "második elem"); // számozott tömb
$tomb_ertek_2 = array("elem1"=> "első elem", "elem2"=>"második elem"); // asszociatív tömb

A tömb elemeire a kulcsokon kereszül tudunk hivatkozni szögletes zárójelek közé írt kulccsal. A számozott tömbök kulcsai 0-val kezdődnek. A fenti példából kiindulva:
-----------------------
<?php
$tomb_ertek_1 = array("első elem", "második elem");
$tomb_ertek_2 = array("elem1"=> "első asszociatív elem", "elem2"=>"második asszociatív elem");

echo $tomb_ertek_1[0]; // Kiírja: első elem
echo $tomb_ertek_2["elem1"]; // kiírja: első asszociatív elem

?>
----------------------
Objektumok (object):
$objektum = New Objektum; // A hivatkozott objektumnak léteznie kell

Erőforrás (resource):
$my_resource = mysqli_connect("localhost","myuser","mypassw","mydatabase"); // Adatbázis kapcsolat erőforrása

NULL:
$null_variable = NULL; // Egy változó akkor NULL, ha a NULL konstanst rendeltük hozzá, vagy ha nem volt semmilyen érték hozzárendelve, esetleg, ha az unset() függvénnyel eldobtuk.

--------
*) A változók szöveges értékeit idézőjelek közé tesszük, amelyek lehetnek egyszerű idézőjelek : 'valami', valamint kettős idézőjelek "valami". A kettő közötti különbség az, hogy az egyszerű idézőjelek közötti szöveg értelmezés nélkül létezik, míg a kettős idézőjeles változatban az értelmező további változókat keres benne, amelyeket próbál feltölteni az adott értékkel.

Példák:
---------------------
<?php
$nem_ertelmezett_szoveg = 'Én egy szöveg vagyok, amelyben szerepel a $szoveges_valtozo nevű változó.';
echo $nem_ertelmezett_szoveg;
?>
---------------------

Figyeljük meg a különbséget:
---------------------
<?php
$tipus_neve = 'szöveg';
$ertelmezett_szoveg = "Én egy $tipus_neve vagyok.";
echo $ertelmezett_szoveg;
?>
---------------------

TIPP
Ahol a szöveg nem tartalmaz változót, használjuk egyszerű idézőjelet: így a php értelmező nem dolgozik feleslegesen azon, hogy változókat keressen (gyorsabb futás), valamint hosszú szövegek esetén olvasás közben látjuk, hogy milyen jellegű a tartalom.
-------

A változók hatásköre

A változókat a létrehozásuk után használhatjuk bárhol a kódban, hatáskörük globális, kivéve a függvények belsejét. A függvényben létrehozott változó helyi hatáskörrel bír, a függvényen kívül létező azonos nevű változót nem érinti. Globális változót behozhatunk a függvénybe a "global" kulcsszóval.

Példák:
--------------------
<?php
$szam_ertek = 1;
echo $szam_ertek; // Kiírja: 1

semmit_nem_ir_ki();
globalis_erteket_ir_ki();
lokalis_erteket_ir_ki();

/* Függvények */

function semmit_nem_ir_ki() {
echo $szam_ertek; // Nem ír ki semmit
}

function globalis_erteket_ir_ki() {
global $szam_ertek;
echo $szam_ertek; // Kiírja: 1
}

function lokalis_erteket_ir_ki() {
$szam_ertek = 2;
echo $szam_ertek; // Kiírja: 2
}

?>
--------------------

d) Konstansok

A konstansok olyan azonosítók, amelyek egyszerű értékek tárolására alkalmasak. Hagyományosan NAGYBETŰVEL jelöljük, a "$" jelet leszámítva a felépítésük azonos a változókkal. Némely konstanst a php alapértelmezetten szállít, ezek listája megtalálható a dokumentációban. Olyan helyeken használjuk, ahol a kód olvashatósága az elsődleges cél.

Példák:
define('PI_ERTEK', 3.14159265358979323846); // Csak osztályon kívüli létrehozás szintaxisa
const PI_ERTEK = 3.14159265358979323846; // Csak osztályon belüli létrehozás szintaxisa

Megjegyzések
A fenti példákban szereplő PI_ERTEK konstans valójában fölösleges, mivel az alapértelmezettek között szerepel az M_PI nevű konstans, amely tartalma megegyezik a fenti példáéval.
A konstansokat nem használhatjuk szövegen belül úgy, mint a változókat.

Példa:
--------------------------
<?php
define('KONSTANS','konstans érték');
$valtozo = 'változó érték';

echo "Ez egy konstans értéke: KONSTANS"; // Kiírja: Ez egy konstans értéke: KONSTANS
echo "Ez egy változó értéke: $valtozo"; // Kiírja: Ez egy változó értéke: változó érték

?>
--------------------------

Futás közbeni módosítások

A változókat futás közben új tartalommal tölthetjük fel, valamint előzetes lefoglalás nélkül használhatjuk bárhol az alkalmazásban.

Példa:
-----------------------------
<?php
$valtozo = 'Most szöveg vagyok!';
echo $valtozo; // Kiírja: Most szöveg vagyok!
$valtozo = 1;
echo $valtozo; // Kiírja: 1
$valtozo = NULL;
echo $valtozo; // Nem ír ki semmit.
?>
-----------------------------

Ezzel szemben a konstansokat csak egy speciális függvényen keresztül tudjuk változtatni; azt ajánlom, hogy abban az esetben, ha egy konstanst utólag változatni kell, akkor inkább használjunk helyette változót.

-------------------------------------------------------------------------------------------------

Feladatok

1.  Írjunk egy php példaprogramot, amely előre megadott változókból feltölti a következő szöveget: "Az én nevem ....., és ..... éves vagyok."
   Használjunk beszédes változóneveket!
2. Írjuk ki egyetlen változó újrafelhasználásával a következő szövegeket: "Az én nevem .....", majd utána: ".... éves vagyok."
3. Hozzunk létre egy 10 elemből álló tömböt, majd irassuk ki a 3. elemet!