A PHP programozási nyelv

Típusok, típuskonstrukciók

1. Típusszerkezet

Bár minden változónak van típusa, a nyelv csak gyengén típusos. A lehetséges típusok:

Skalárok:

Összetett típusok:

Speciális típusok:

2. Elemi Típusok

2.1. Boolean típus

A logikai típusra konvertálás más típusokról hasonlóképp működik, mint Perlben. A logikai változók értéke true és false lehet, ezek megadásánál nem kell figyelnünk a kis- és nagybetűkre. Ez általában a többi beépített konstansra is igaz, pl. NULL. A boolean típusra konvertálásnál következők adnak false értéket:

A PHP-ben a 4-es változat előtt nem létezett a boolean típus. A régebbi változatokban is használhattuk a true értéket, de azt az értelmező egyszerűen integer típusú 1-re fordította. Az integer és float mérete gépfüggő, általában az int 32, a float pedig 64 bites. Az ezen túlcsorduló egészek automatikusan float-ra konvertálódnak.

2.2. String típus

PHP-ban kétféle lehetőségünk van sztringek megadására. Ha a szövegben változókat szeretnénk kiértékelni, akkor idézőjelek között adjuk meg a sztringet. A nyelv felismeri a változóneveket, lévén, hogy a speciális '$' karakterrel kezdődnek, és a szövegben behelyettesíti a változók neveit az aktuális értékükkel.

echo "There have been $count presidents of the US";

Ez tulajdonképpen megfelel egy konkatenálásnak is, amit a PHP automatikusan elvégez. Az előző példa egyenértékű ezzel:

echo "There have been " . $count . " presidents of the US";

Amennyiben a szöveget változatlan formában szeretnénk értékül adni, akkor használhatunk aposztrófokat idézőjelek helyett. Ekkor a közrefogott változók nem értékelődnek ki, egyszerű szövegként jelennek meg.

$info = 'Preface variables with a $ like this: $variable';

Szükség lehet a szöveg escape-elésére. A sztring tartalmazhat olyan karaktereket, amelyeknek speciális jelentésük van, így azok tévesen kerülnek lefordításra. Ilyen speciális szimbólumok pl.: $, ", ', \. A következő példa nem fog helyesen működni, mert a második aposztróf azt fogja jelenteni a fordítónak, hogy vége a sztringnek, így a szöveg további része hibaként jelenik meg.

$text = 'My sister's car is a Ford'; // Erroneous syntax

Ennek kiküszöbölésére egy backslash (\) karaktert teszünk a speciális karakterek elé, hogy a fordító ne vegye figyelembe azokat.

$text = 'My sister\'s car is a Ford';

Ugyanezt a módszert alkalmazhatjuk egyéb speciális karakterek beszúrásakor, mint pl.: \t, \n, \r. Ezek a whitespace karakterek csak idézőjelek között működnek, aposztrófok között nem.

A sztringekre semmilyen korlátozás nincs, ugyanúgy működnek az interpolációt és speciális karaktereket is beleértve, mint Perlben. Egyetlen fontos újítás, hogy itt a sztringet tekinthetjük byte-ok tömbjének is, ennek megfelelően hivatkozhatunk megfelelő indexekkel a betűkre. Így a sztring első betűje: $first = $str[0];. A sztring hosszát itt nem speciális változóként, hanem függvényhívással kaphatjuk meg: $last = $str[strlen($str)-1];.

Egy sztringet kezelhetünk úgy, mint egy tömböt, vagyis ha valamelyik karakterére szeretnénk hivatkozni, azt tömbökkel megtehetjük. Például:

String s = "szia"; s[1] = z;

A PHP fontosabb beépített függvényei sztringek kezelésére:

3. Típuskonstrukciók, Összetett típusok

3.1. Tömb

A PHP tömb a Perl-beli megfelelőjéhez hasonlóan működik, ám akadnak komolyabb különbségek.
A PHP szintakszisa tömb deklarálására:

$tomb = array("hello","world");

Míg a Perlben két külön típus volt a tömb és a hasítótábla, a PHP nyelvben teljesen ugyanaz a két fogalom, ugyanis az index tetszőleges nem negatív egész szám, vagy szöveg is lehet, ráadásul ez akár egy tömbön belül is tetszőlegesen változhat. Ha nem adjuk meg előre a tömb indexeit, akkor 0-tól induló egész sorozat rendelődik hozzá. Az array nyelvi konstruktorral hozhatóak létre, vagy egyenként megadva az értékeit. Mérete tetszőlegesen változhat. Ha elhagyjuk az értékadásnál a tömbindexet, akkor automatikusan a tömb végére kerül az elem.

$tomb = array("nulla", 42 => "negyvenketto", "egy", "ketto"); $tomb[] = "harom"; // ugyanaz, mint a $tomb[3] = "harom";

Bár szintaxisuk kicsit más, a Perlben megszokott függvények itt is rendelkezésre állnak, tudjuk a tömböt sorként, halmazként, veremként, stb kezelni. Írhatunk számokat is a szögletes zárójelbe, de ez nem tanácsos. Nézzük a következő programrészletet:

$felhasznalok[0] = "Berci"; $felhasznalok[200] = "Mariska";

A tömbnek így mindössze két eleme van, de az utolsó elem indexe 200. A PHP-ben további lehetőség, hogy a tömb elemei nem csak skalárok lehetnek, hanem bármi (tömbök, objektumok, stb). Így könnyen készíthetünk különböző adatszerkezeteket (fa, gráf, miegyéb).

Tömböket kétféleképpen lehet létrehozni. Egyik a list(), másik az array() parancs.
A tömbök rugalmassága miatt nem mindig egyszerű feladat kideríteni, hány elem van a tömbben. A PHP a count() függvényt biztosítja erre a feladatra. A count() a tömbben levő elemek számával tér vissza. Az alábbi programrészben egy számokkal indexelt tömböt hozunk létre, majd a count() függvényt használjuk a tömb utolsó elemének elérésére.

$felhasznalok = array ("Berci", "Marci", "Ödön", "Télapó"); $felhasznalok[count($felhasznalok)-1];

De vannak esetek amikor a count() fv. nem célravezető:

$tomb = array("Ecc, pecc"); // Egyelemű tömb! $tomb[2] = "kimehetsz"; print "Az utolsó elem: " . $tomb[count($tomb)-1];

A fenti kódot futtatva azt tapasztaljuk, hogy az "Az utolsó elem: " szöveg után semmi nem íródik ki. Ez azért van, mert a tömbnek nincs 1 indexű eleme. Az első elem a 0 indexen található, a második a 2 indexen, mivel az értékadáskor az indexet közvetlenül határoztuk meg.
A tömbök indexelése alapértelmezés szerint nullától indul, de ezt meg lehet változtatni. Ha azonban világos és következetes programokat szeretnénk írni, ne éljünk ezzel a lehetőséggel.
Példa tömb bejárására:

$felhasznalok = array ("Berci", "Marci", "Ödön"); $felhasznalok[10] = "Télapó"; foreach($felhasznalok as $szemely) { print"$szemely<br>"; }

Lehetőség van a tömbelemek változtatására a bejárás során, ehhez azonban referencia szerint kell elérni a tömbelemeket, amit a '&' operátor használatával érhetük el.

foreach ($szamok as &$szam) { $szam *= 10; } unset($szam);

Vigyázat! A referencia szerint átadott értékváltozóra a bejárás után mindig hívjuk meg az unset függvényt! A változó hatásköre nem csak a ciklusra vonatkozik, ezért ha az unset hívást elmulasztjuk, a változó továbbra is él és továbbra is a tömb utolsó elemére mutat. Például egy újabb, érték szerinti hivatkozást használó foreach ciklus nehezen felderíthető hibát okozhat.

Tömb bejárását kézileg is végezhetjük a beépített pointerek manipulálásával (ezek a reset, end, key, current, next). A következő példában azonban elakad a bejárás, amennyiben valamelyik elem pontosan FALSE értékű!

for (reset($array); current($array) !== false; next($array)) { echo current($array); }

3.2. Asszociatív tömb

Alapértelmezetten a tömb 0-tól indexelődik, azonban mi tetszőleges egész számokkal és sztringekkel indexelhetjük a tömbünket. Példa:

$asszoc["kerek"] = "alma"; $asszoc["kortealaku"] = "korte"; $asszoc["kopasz"] = "barack";

Másképpen:

$asszoc = array( "kerek" => "alma", "kortealaku" => "korte", "kopasz" => "barack", );

Mivel csak egészek és sztringek szerepelhetnek indexként, a további értékek a következőképpen konvertálódnak:

Az elemek a bekerülés sorrendjében szerepelnek a tömbben. Figyeljünk oda arra, hogy a nyelv nem figyelmeztet arra, ha egy tömb megadásakor egy elemmel felülírunk egy másikat. Például a következő tömb csak a 0 indexű "masodik" elemet fogja tartalmazni:

$tomb = array( "elso", 0 => "masodik" );

A PHP-ben fontos az asszociatív tömbök használata, ismerete, mivel az adatbázis rendszerek általában asszociatív tömbben adják vissza a lekérdezések eredményeit. (pl. mysql_fetch_array() függvény olyan asszociatív tömböt ír, amelyben a mezők nevei a kulcsok.)

Bonyolultabb programok esetében gyakran előfordul, hogy kíváncsiak vagyunk egy tömb vagy valamilyen más összetett változó tartalmára. Ilyenkor általában nem kell saját tömblistázó kódot használnunk, hiszen a PHP biztosítja számunkra a print_r() függvényt, amely a paramétereként megadott változó tartalmát írja ki.
Fontos, hogy a PHP csak azokat a tömbelemeket menti el, amelyeket létrehoztunk, ezért már most mutatunk egy példát a tömb bejárására:

while (list($kulcs, $ertek) = each($asszoc)) { print("kulcs: " .$kulcs . ", érték: " .$ertek); }

Példa asszociatív tömb bejárására:

foreach ( $karakter as $kulcs => $ertek ) { print "$kulcs = $ertek"; }

Ahol csak mód van rá, ne használjunk tömbindexeket. A tömböket sokszor csak egyszerű listaként használjuk, ahol nem számít az, hogy egy adott elemnek mi az indexe. A PHP a tömbök elérésére a tömbindexek használatánál hatékonyabb és áttekinthetőbb függvényeket biztosít, programunk ezáltal rugalmasabb, könnyebben módosítható és jól olvasható lesz.

3.3. Többdimenziós tömb

Mátrixokat is hozhatunk létre tömbök tömbje módszerrel, például többdimenziós indexelés $a[ ][ ] formában. A többdimenziós tömbök érdekessége, hogy minden implementáció egyedi, vagyis kétdimenziós tömbnek lehet az első dimenziója numerikusan indexelt, a második pedig asszociatív.

$m[0][0]="Zero"; $countries[Idaho][0]="Ada";

Más példa többdimenziós tömb felépítésére:

$karakterek = array ( array ( "nev" => "János", "tevekenyseg" => "szuperhős", "eletkor" => 30, "kulonleges kepesseg" => "röntgenszem" ), array ( "nev" => "Szilvia", "tevekenyseg" => "szuperhős", "eletkor" => 24, "kulonleges kepesseg" => "nagyon erős" ), array ( "nev" => "Mari", "tevekenyseg" => "főgonosz", "eletkor" => 63, "kulonleges kepesseg" => "nanotechnológia" ) );

Példa többdimenziós tömb bejárására:

foreach ( $karakterek as $karakter ) { foreach ( $karakter as $kulcs => $ertek ) { print "$kulcs: $ertek"; } }

3.4. Műveletek tömbökkel

A PHP rengeteg függvénnyel segíti a tömbök feldolgozását is. A Perlben jártas olvasó bizonyára ismerősnek fogja találni ezen függvények nagy részét.

4. Speciális típusok

4.1. Erőforrás típus

Az erőforrás a PHP-ban egy új fogalom: referencia valamilyen külső erőforrásra, mint például fájl, adatbázis kapcsolat, hálózati kapcsolat, stb. Ezek különlegessége, hogy nem kell fáradoznunk a felszabadításukkal, mivel a Java szemétgyűjtő mechanizmusához hasonló beépített rendszer ezt elvégzi helyettünk. Ennek következtében nem fordulhat elő, hogy írás után elveszik valamilyen kiírt adat, mert nem ürítettük ki a fájl-buffereket és zártuk le a fájlt.

4.2. Null típus

A NULL egy külön típus, mely azt jelzi, hogy egy változó nem vett fel értéket, így egy változó értékét törölhetjük a $var = Null; utasítással. Egy változó NULL-nak tekinthető, ha a NULL értéket rendeltük hozzá, ha még nem rendeltünk hozzá értéket, ha az unset() függvény törölte a változót. Az előbbi három esetet az isset() függvény vizsgálja, az is_null() függvénnyel pedig biztosan létező változókról tudjuk eldönteni, hogy NULL értéket rendeltünk-e hozzájuk.

5. Típuskonverziók

Mivel a PHP-ben gyengén típusosak, a változók típusa a program folyamán változhat, a Perlhez hasonlóan a változó típusát itt is a környezet határozza meg.

$var = 2020; // most int $var = "Hello"; // most string

A szükséges típuskonverzió lehet automatikus:

$szam = "15"; if ($szam > 12) print "Ez több mint egy tucat!";

Lehetőségünk van explicit konverzióra is, ezek egyik módja az ún. cast-olás, ez a C-s szintaktikát követi: $x = (új típus) $y;.

$szam = "15"; if ( (integer)$szam > 12) print "Ez több mint egy tucat!";

Használhatjuk a settype($var,"új típus); függvényt is:

$szam = "15"; $szam2 = settype( $szam, "integer" ); if ($szam2 > 12) print "Ez több mint egy tucat";

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. Az automatikus típuskonverzióra adható néhány érdekes példa is: '+' operátor esetén, ha az egyik operandus float, az eredmény is az lesz. Különben ha valamelyik integer, akkor az eredmény integer lesz.

$foo = "0"; // $foo egy sztring (ASCII 48) $foo += 2; // $foo most egész (2) $foo = $foo + 1.3; // $foo most lebegőpontos (3.3) $foo = 5 + "10 Kis Pingvin"; // $foo egész (15)

Ha valamilyen skalárt tömbbé akarunk konvertálni, létrejön egy tömb, aminek első eleme a skalár. A tömb konverziója egyes esetekben nincs pontosan definiálva, mivel a nyelv definíciójából adódóan a következő probléma eldönthetetlen:

$var = 1; $var[1] = "f"; // ez még helyes, a $var=array(1,"f"); megfelelője $var = "0"; $var[0] = "f"; // a sztringet indexeljük, vagy tömböt hozunk létre?

Ha egy skalárt objektumra konvertálunk, akkor létrejön egy objektum, melynek van egy scalar mezője:

$obj = (object) "Hello"; echo $obj→scalar; // kiirja, hogy "Hello"

A típusok közti konverzió meglepő eredményeket adhat, ha a konverzió egyébként sem magától értetődő. Pl. egy tömb vagy egy objektum sztringre konvertálása "Array" illetve "Object" sztringet ad eredményül. Hasonlóan zűrös esetekben inkább nézzünk meg egy nyelvi referenciát.
Sztringet egyszerűen numerikus kifejezéssé konvertálhatunk a következő szabályok alapján:

Egy numerikus adat érvényes, ha egy vagy több számjegy, opcionális tizedespont egy opcionális hatványkifejezésből áll.
A változók típusát lekérdezhetjük a gettype() függvénnyel:

$ valt=15; print gettype($valt); // integer $valt2 = 3.14 print gettype($valt); // double, stb...

Gyakran csak arra van szükségünk, hogy tudjuk, az adott változó egy adott típus-e vagy sem. Ilyenkor jönnek jól az alábbi, logikai értéket visszaadó függvények:

6. Változók, konstansok

A PHP-ben a változók:

A változókat nem kell deklarálnunk, mivel a használat helyén keletkeznek, ebből kifolyólag célszerű egy kezdő értékadással bevezetni használatukat. Megjegyezzük, hogy a következőkben ismertetendő modulok nem tekinthetők külön blokknak, azaz a modulban deklarált változó a megfelelő include() vagy require() vagy require_once() hívás után látható marad. Minden változó nevét a '$' jellel kell kezdeni. Az értékadás és paraméterátadás alapesetben érték szerint történik. Lehetőség van referencia szerinti átadásra is, ám a Perl-lel ellentétben nincsenek névtelen változókra mutató referenciák.

$x = $y; // érték szerinti átadás
$x = &$y; // referencia szerinti

Ha 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 vagy const kulcsszó 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.
A konstansok nevének nem kell '$'-al kezdődniük, nem érvényesek rájuk a változókra vonatkozó láthatósági korlátozások, valamint csak skaláris értéket tartalmazhatnak. Például:

PHP 5.3-ig a const kulcsszó nem volt használható a globális hatókörben, pusztán egy osztály adattagjának definíciójakor. Ezt arra használtuk, hogy valamilyen konstans beállítást eszközöljünk az osztályra nézve, vagy valamilyen enum jellegű struktúrát szeretnénk létrehozni, melyet a PHP nem támogat jelenleg. PHP 5.3-tól a const kulcsszó használható globális névtérben is.
A define kulcsszó ugyenezen okból kifolyólag használható, de pusztán globális hatókörben.

A PHP 5.6-tól const definíciójakor használható skalár-kifejezés, mely numerikus és string literálokat, vagy konstansokat tartalmazhat.

define("PI", 3.14159265358979); const ONE = 1; const TWO = ONE * 2; class C { const THREE = TWO + 1; const ONE_THIRD = ONE / self::THREE; const SENTENCE = 'The value of THREE is '.self::THREE; public function f($a = ONE + self::THREE) { return $a; } } echo (new C)->f()."\n"; echo C::SENTENCE;
4 The value of THREE is 3

Az a szokás, hogy az állandók neve CSUPA NAGYBETŰBŐL áll. Az összes előre definiált változó (és más hasznos információ) kilistázható a phpinfo() függvénnyel.
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ó.
Különbség az érték és a referencia szerinti átadásnál, hogy amíg az érték szerinti átadásnál bármilyen módosítás nem befolyásolja a másik változót, a referencia szerinti átadásnál igen. Tehát ha $x=&$y és megváltoztatom x értékét ezzel y értékét is megváltoztatom, hiszen x y-ra hivatkozik!

6.1. Előre definiált változók

A felhasználható előre definiált változók listája függ a szkript környezetétől (pl. webszerveren fut-e a PHP vagy esetleg különálló programként), a PHP verziószámától és a webszerver típusától. Automatikusan rendelkezésre állnak minden hatáskörben (azaz: szuperglobálisak). Egyidőben létezhet a szuperglobális és a HTTP_*_VARS tömb, de ezek nem azonosak, tehát az egyiknek a módosítása nem változtatja meg a másikat is. A phpinfo() függvény segítségével listázhatjuk ki ezeket.

A fontosabb előre definiált változók:

Változó Definició
$GLOBALS A globális változók nevei
$_COOKIE HTTP sütikből (cookies) származó változók
$_GET HTTP GET kérés által létrehozott változók
$_POST HTTP POST kérés által létrehozott változók
$_SERVER Változók, amelyeket a web-szerver állított be
$_FILES HTTP post fájlfeltöltés által létrejövő változók
$_ENV A környezetből származó változók
$_REQUEST HTTP GET, POST és COOKIE bemenetekből származó változók
$_SESSION A szkript munkamenetéhez rendelt változók


Apache környezet változóinak egy része:
Változó Definició
HTTP_HOST A host tartalma: böngésző által küldött fejléc
HTTP_USER_AGENT A user agent tartalma: böngésző által küldött fejléc, ami az aktuális lapot lekérő böngészőre utal
REMOTE_ADDR Az aktuális lapot néző felhasználó IP címe
SERVER_PROTOCOL A használt protokoll neve és verziószáma
GATEWAY_INTERFACE CGI specifikáció száma, amelyet a szerver használ


A többi beépített függvény már a Perl vagy akár a C++-ból ismert aritmetikai operátor, a bitenkénti operátorok, az összehasonlító operátorok (extra: === azonos, == egyenlő), az inkrementáló/dekrementáló operátorok, a logikai operátorok és a hozzárendelő operátorok (+=, %=, stb.)

6.2. Hatáskör

A Perllel ellentétben itt a változók nem láthatóak teljes élettartamukban, csak a saját blokkjukban. A függvényben használt változók az adott függvényre nézve helyiek maradnak. Más szavakkal: a változó a függvényen kívülről vagy más függvényekből nem lesz elérhető. Nagyobb projektek esetén ez megóvhat minket attól, hogy véletlenül két függvény felülírja azonos nevű változóik tartalmát.

$a = 1; // globális hatáskör function Test () { echo $a; // rossz: üres kimenet, mert $a lokális, így definiálatlan }

A függvényen kívül meghatározott változó nem érhető el automatikusan a függvényen belülről. A külső blokkban látható változókat behozhatjuk blokkunkba a global kulcsszóval:

$a = 1; // globális hatáskör function Test () { global $a; echo $a; // kimenet: "1" }

Vagy elérhetjük őket a $GLOBALS tömbön keresztül:

$a = 1; // globális hatáskör function Test () { echo $GLOBALS["a"]; // kimenet "1" }

A függvénynek átadott paraméter általában valamilyen érték másolata, a paraméter megváltoztatásának a függvény vége után semmilyen hatása nincs. Ha azonban egy globális változó értékét változtatjuk meg egy függvényen belül, akkor az eredeti változót változtattuk meg és nem egy másolatot. Ezért a global kulcsszót lehetőleg minél kevesebbszer használjuk.

Függvényhez statikus változót a static kulcsszóval deklarálhatunk, ld. később. A nevek interpolálása a Perlhez hasonlóan működik.

$a = "hello"; $$a = "world"; // ugyanaz, mint $hello = "world"; echo "$a $$a"; // ugyanaz, mint echo "$a $hello";

A PHP támogatja a statikus változók alkalmazását függvényekben, annak érdekében, hogy a függvényekben a lokális változók ne veszítsék el értéküket a hívások között.

6.3. Konstansok

Az állandó a PHP-ben egy előre meghatározott érték azonosítója. A változókkal ellentétben értéke a definiálása után nem változtatható meg - kivéve két speciális esetet: a __FILE__ és a __LINE__ állandót.
Az állandók nevei is kis/nagybetű érzékenyek, bár nem előírás, de a programozói gyakorlat szerint csupa nagybetűvel írjuk őket.
Az állandók nevei az angol abc betűit, valamit az ASCII kódtábla 127-255 elemeit tartalmazhatják (pl. aláhúzás jelet igen, de kötőjelet nem), mindig betűvel, vagy aláhúzás jellel kell kezdődniük.
Fontosabb különbségek a változókhoz képest:

Állandót a PHP define() beépített függvényével lehet meghatározni. Mint már tudjuk, értéke ezután nem változik.
A defined() függvénnyel tudjuk lekérdezni, hogy egy karaktersor már definiált állandónak felel-e meg. A definiált állandók listáját a get_defined_constants() függvénnyel kapjuk meg.

<?php define("_ALLANDOM", "Én egy állandó vagyok"); // állandó meghatározása print (_ALLANDOM); // kiírja, hogy: Én egy állandó vagyok print (_VALAMI); // még nem definiált állandó, kiírja a _VALAMI szöveget és hibát jelez ?>

A PHP-ben számos előre definiált állandó áll a programozó rendelkezésére. Néhány további fontosabb előre definiált állandó:

Különleges, úgynevezett MÁGIKUS állandók a __FILE__ és a __LINE__ állandók, melyek értéke - a főszabálytól eltérően futásidőben változik. A __FILE__ az éppen feldolgozás alatt álló scriptfájl nevét tartalmazza, a __LINE__ pedig az aktuális sornak a számát.
Egyéb mágikus állandók:



7. Kifejezések, operátorok

Kétféle függvény létezik: a nyelvbe beépített függvény és az általunk létrehozott függvény. A PHP-ben rengeteg beépített függvény van:

print ("Hello Web!");

A print abból a szempontból nem jellegzetes függvény, hogy paramétereit nem kell zárójelbe tenni. A print("Hello Web!"); és print "Hello Web!"; egyaránt helyes megoldások. Ez egy különleges függvény. Szinte az összes többi függvénynél kötelező a zárójel; akár kell paramétert átadnunk, akár nem. Mivel a PHP-ben nincsenek típusok, logikusnak tűnik, hogy a függvények visszatérési típusát sem kell előre meghatározni.

A visszatérési értéket egyszerűen a return utasítással határozzuk meg. A return befejezi a függvény futtatását és az utána írt kifejezést küldi vissza a hívónak.

return 0.1; // valós számot ad vissza
return "valami"; //sztringet ad vissza
return; //visszatérési érték nélkül tér vissza

Példa beépített abs függvényre:

$szam = -321; $ujszam = abs( $szam ); print $ujszam; // kiírja, hogy "321"

Ebben a példában a $szam nevű változóhoz a -321-es értéket rendeltük, majd átadtuk az abs() függvénynek, amely elvégzi a szükséges számításokat és visszaadja az eredményt. Ezt az új értéket rendeljük az $ujszam nevű változóhoz és kiírjuk az eredményt. A feladatot megoldhattuk volna segédváltozók segítsége nélkül is, az abs() függvényt adva közvetlenül a print() paramétereként:

print( abs( -321 ) );


Az operátorok terén a Perlhez viszonyítva különbségként talán csak annyit kell megemlíteni, hogy néhány operátor megjelent, illetve kimaradt PHP-ben.
Példák új operátorokra:

Példa a hibakezelő operátorra:

$file = @file ('nem_letezo_allomany') or die ("Nem lehet megnyitni, a hiba: '$php_errormsg'");

PHP-ben nincs:

<=> előjeles összehasonlítás
eq, le, gt, cmp, stb sztringoperátorok
-e, -r, stb fájloperátorok
qq, q, m, s, qw, stb sztring és tömbdefiniáló operátorok
.., ... "intervallum" és ciklusoperátorok


7.1. Összehasonlító operátorok

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.

Műveleti jel 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 megegyezik $x === 5 false
!== nem azonos a két érték vagy típus különböző $x !== 5 true
> nagyobb, mint a bal oldal nagyobb a jobb oldalnál $x > 4 false
>= nagyobb vagy egyenlő a bal oldal nagyobb a jobb oldalnál vagy egyenlő vele $x >= 4 true
< kisebb, mint a bal oldal kisebb a jobb oldalnál $x < 4 false
<= kisebb vagy egyenlő a bal oldal kisebb a jobb oldalnál vagy egyenlő vele $x <= 4 true

7.2. Aritmetikai operátorok

+ összeadás
- kivonás
* szorzás
/ osztás
% maradékos osztás

A fenti operátorok mindegyike lebegőpontos számot ad eredményül, ha az input lebegőpontos, valamint az egészeket is lebegőpontossá konvertálják, ha az eredmény nem egész. A műveleteket az operációs rendszer végzi (a szerver operációs rendszere), ezért azok pontossága a hardware-től és attól függ, hogy az operációs rendszer hogyan kezeli a hardware eredményeit.

7.3. Sztringoperátorok

A konkatenáció 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" lesz.

Az elemek típusuktól függetlenül karakterláncként értékelődnek ki és az eredmény is mindig karakterlánc lesz.

. konkatenáció
.= végéhez csatolás

7.4. További hozzárendelő műveletek

Annak ellenére, hogy valójában csak egy hozzárendelő művelet van, a PHP 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.

$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.

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 példákban a $x változó értéke változik meg, a jobb oldali operandusnak megfelelően.

7.5. Dokumentumbejegyzés

Ha hosszú szöveget szeretnénk változóba írni, a dokumentumbejegyzés rá a legjobb megoldás. Operátor a <<< szimbólum. Használatakor meg kell adnunk a beolvasandó szöveg határait, ezt a példában a sokszo-val tesszük meg. A sokszo; -nak új sorban kell kezdődnie. A szövegben bármilyen karakter állhat, kivéve a '$'-t, amit természetesen a '\' jellel kiemelve szúrhatunk be. (\$ megengedett és $-t fog kiírni.)

Példa:
$hosszuszoveg = <<< sokszo

7.6. Növelő, csökkentő operátorok

++ növelő operátor
-- csökkentő operátor

Természetesen nem mindegy, hogy a változó előtt vagy után használjuk az operátort:

$a = 3; print ($a++);

Ez a kód 3-at ír ki a képernyőre, aztán a $a változó értéke nő 4-re.

$a = 3; print (++$a);

Ez a kód már 4-et fog kiírni, mivel a növelést a kiíratás előtt végeztük el.

7.7. Hibaellenőrző operátor

A '@' operátor használatával letilthatjuk a hibák kiírását. Főleg akkor használjuk, ha gyorsan kell kódot írnunk, amely nem mentes az olyan hibáktól, amelyek nem végzetesek, tehát maga a program "jól" működik, de nem volt időnk minden hibaüzenetet kivenni. Ha egy függvénynek, ami elé beírtuk a '@' operátort, nincsen egyedi hibajelentési mechanizmusa, a $php_errormsg -ben lehet megtalálni a hibát.

7.8. Bináris operátorok

& ÉS, azaz AND
| VAGY, azaz OR
^ kizáró vagy, azaz XOR
~ NO
<< balra tolás
>> jobbra tolás

7.9. Logikai műveletek

Műveleti jel Név Igaz, ha Példa Eredmény
|| vagy a bal vagy a jobb operandus igaz true || false true
or vagy a bal vagy a jobb operandus igaz true or false true
xor kizáró vagy vagy a bal, vagy a jobb operandus igaz, de csak az egyikük true xor true false
&& és a bal és a jobb operandus is igaz true && false false
and és a bal és a jobb operandus is igaz true and false false
! tagadás az egyetlen operandus hamis !true false

Miért kell kétféle vagy és és műveletjel? A magyarázat a műveletek kiértékelési sorrendjében rejlik, amelyet a fejezet későbbi részében láthatunk.

7.10. Végrehajtás-operátor

A vissza-aposztróf ' ` ' operátor használatával ugyanazt érjük el, mintha a system() függvényt használnánk: mindent, amit a két ' ` ' jel közé írunk, az operációs rendszernek küldi el a php végrehajtásra. Amit az operációs rendszer válaszát stringként kapjuk vissza.
Példa:

$dirlista = `ls`;

Vigyázzunk, nehogy beleessünk abba a hibába, hogy például egy form mezőjén keresztül várunk egy inputot, amit végrehajtatunk, mivel így a felhasználó azt csinál a szerverünkkel, amit csak akar.

7.11. Műveleti sorrend (precedencia)

Az operátorok precedenciája fentről lefelé csökkenő sorrendben (az egy sorban levőknek ugyanannyi):

New [ ! ~ ++ -- (int) (double) (string) (array) (object) @ * / % + - . << >> < <= > >= == != === !== & ^ | && || ?: = += -= *= /= .= %= &= |= ^= ~= <<= >>= Print 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