Adattípusok PHP-ben


A php-vel való ismerkedés során rengetegen elkövetik azt a hibát, hogy nem olvassák át a PHP-ben található adattípusok jellemzését, holott ezzel később rengeteg problémától megkímélnék magukat. Úgyhogy álljon itt egy elemzés ezekről a típusokról.

Mielőtt belemennénk részletesen a típusok taglalásába egy dolgot azonnal tisztázzunk: gyakran hivatkoznak ezekre mint “változó-típusokra”, azonban ez a megfogalmazás pontatlan, helytelen. Egy változó ugyanis olyan nyelvi elem, amelynek van neve (pl.: $theAnswerToLifeTheUniverseAndEverything), típusa (pl.: egész szám) és értéke (pl.: 42).
Azonban típusa minden adatnak van, ez a leírás például karakterlánc típusú. A függvények visszatérési értékeinek is van típusa, ahogy azok paramétereinek, a konstans értékékeknek, mindennek. A helyes megnevezés tehát adattípus, Mivel az adatok típusát adják meg.

A PHP-ban a következő típusokat különböztetjük meg: null, boolean, integer, float, string, array, object valamint resource. A PHP kézikönyben azonban láthatunk egyéb típusokat: mixed, number, callback és scalar. Ezekről a pszeudó, vagyis ál-típusokról majd később.

Null

Kezdjük is a legegyszerűbb adattípussal, a Null-al. A null típussal akkor találkozhatunk, ha egy kifejezés nem tartalmaz értéket. Ez lehet inicializálatlan változó (ezek használatáért E_NOTICE szintű hibaüzeneteket kapunk), visszatérési értéket nem adó függvény, stb. Egyetlen lehetséges értéke az ún. NULL érték.

Az adat ezen típusba sorolásának ellenőrzésére az is_null függvényt használhatjuk. Például:

1
2
3
4
5
6
<?php
function ize() { } /* ize()-nek nincs visszatérési értéke [az ilyen függvényeket a PHP függvény-referencia void-ként jelöli */
var_dump(is_null(ize()));
var_dump(is_null($var));
$var = "";
var_dump(is_null($var));

Ennek a kódnak a kimenete a következő lesz:

1
2
3
bool(true)
bool(true)
bool(false)

Mint azt korábban írtam a visszatérési érték nélküli függvényünk (ize), és az inicializálatlan változónk (első $var) null típusú (és NULL értékű) kifejezésként értékelődik ki, míg az üres karakterlánc (második $var) már nem.

Boolean (Bool)

A következő változótípusunk szintén nem bonyolult, csak kétféle értéket vehet fel: igaz vagy hamis. Elég gyakran fogjuk ezt használni, rengeteg függvény tér vissza ilyen értékkel.

Az adat ezen típusba sorolásának ellenőrzésére az is_bool függvényt használhatjuk. Például:

1
2
var_dump(is_bool(true));
var_dump(is_bool("http://www.tutorial.hu/forum"));

A kimenet – mint ahogy azt elvárjuk – a következő lesz:

1
2
bool(true)
bool(false)

Természetesen ez így túl szép ahhoz, hogy igaz legyen, a PHP automatikus típus-konverziója miatt néha fontos figyelnünk a Boolean típusra is. Vannak bizonyos függvények, amelyek numerikus (szám) értékkel térnek vissza, ezek között is van olyan, amelynél elképzelhető mind a 0 érték, mind a boolean típusú false érték. A kettő között hatalmas különbség van, ám a PHP típus-konverzió miatt a kettő egyenlőként értékelődik ki. (A boolean false integer típusú értéke 0, a true-é 1)
Például:

1
2
3
4
5
$string = "Ez egy leírás az adat-típusokról!";
if(strpos($string, 'E') == false)
   {
   print 'Nincs benne E';
   }

Ennél a kódnál tévesen fog kiértékelődni a feltétel, ugyanis az strpos a karakterek számozását 0-tól kezdi. Így az E betű a nulladik karakter. A false értéket a PHP szintén 0-ra alakítja és mivel 0 = 0 a feltétel igazként fog kiértékelődni.

Éppen ezért ilyen esetekben az ún. “Azonos” (===) – vagy ellentéte, a “Nem azonos” (!==) – összehasonlító operátorokat kell használni, amelyek a kifejezések tartalmának egyezésén kívül azok típusának egyezését is figyelik. Így az (int)0 = (bool)0 – immár helyesen – hamisként kerül kiértékelésre:

1
2
3
4
5
$string = "Ez egy leírás az adat-típusokról!";
if(strpos($string, 'E') === false)
   {
   print 'Nincs benne E';
   }

A PHP kézikönyben a néhány függvénynél, amelynél – hasonlóan az strpos-hoz – figyelni kell a visszatérési érték típusát is, erre külön felhívják a figyelmünket. Sajnos azonban jónéhány esetben nem, úgyhogy érdemes figyelnünk a lehetséges értékek et.

Integer

Az integer, vagyis egész szám típusú adatok – értelemszerűen – pozitív és negatív egész számokat tárolnak. A tárolható szám két határértéke rendszer-függő, a kézikönyv alapján általában +/-2.147.483.647. A határétéken kívül eső számok automatikusan lebegőpontos számmá alakulnak, bár elég valószínűtleg, hogy ilyen nagy számokkal kelljen dolgoznunk.

Az adott kifejezés integer típusba tartozásáról az is_int függvénnyel tudunk megbizonyosodni.
Például:

1
2
3
4
5
6
var_dump(is_int(strpos('Szia', 'e')));
var_dump(is_int(strpos('Szia', 'a')));
var_dump(is_int(6));
var_dump(is_int(6.5));
$var = 6.5 * 2;
var_dump(is_int($var));

Az első 3 egyértelmű a korábban leírtak ismeretében. Az első hamis, a második kettő igaz értékkel tér vissza. A 6.5 (a pont a tizedesvessző szerepét tölti be) már nem egész szám, így természetesen hamis-ként lesz kiértékelve. Még ez is elfogadható.
A következő, a 6.5 * 2 már érdekesebb. A kifejezés értéke ugyebár 13, ami ismereteink szerint egész szám, PHP szerint mégsem az. Ennek oka az, hogy egy float típusú érték és egy egész szám – végiggondolva teljesen logikusan – továbbra is float típusú lesz. (Akik a példa alapján megkérdőjelezik a logikusságát: például 0.1 * 2 nem lesz egész szám, pont úgy, mint az ilyen szorzatok jelentősebb része.)
(Természetesen van mód az egész szám típusra alakításra, de ezt majd egy másik cikkben.)

Float

A floating point típusba a valós számok tartoznak. Néhányszor találkozhatunk még a double (double precision) típussal is, PHP alatt a kettő ugyanazt jelenti (A lebegőpontos számábrázolás egyszeres és kétszeres pontosságú értékeket külön veszi, a belső ábrázolástól függően. Részletek a lentebb linkelt oldalon).

Legfontosabb jellemzője, hogy terjedelme jóval meghaladja az integer típusét (itt is platform-függő, az IEEE 754-es, szabvány szerint 64 bites float esetében kb. ±(21024 − 2971) – forrás: Wikipedia – Floating-point standard)

A típusba tartozást az is_float függvénnyel ellenőrizhetjük.

A float típusú elemek – belső ábrázolásuk miatt – néhány esetben érdekes formátumokat vehetnek fel. Például: 7E-1. Ez a 7*10-1 értéket jelenti (0,7).

Szintén a fenti okból kifolyólag néhány esetben tévesen kerülnek kerekítésre, ha float típussal dolgozunk érdemes erre figyelni

Előfordulhatnak olyan esetek, amikor nem számítható ki a pontos érték. Ilyenkor a szabvány szerint az INF (végtelen) és NaN (nem szám) értéket veszik fel (pl.: INF: 2e308 NaN: acos(1.01)).

Ezen speciális értékek vizsgálatára az is_nan() és is_infinite() függvények használhatóak. Mivel ritkán – valószínűleg soha – nem fogunk ilyenekbe belefutni (hacsak külön nem vizsgálni akarjuk ezek működését) nem is érdemel több szót a téma.

Most, hogy a számokat jelölő két típust megnéztük még egy fontos dolog van hátra: hogyan ellenőrizzük, hogy adott adat szám-e? Jogos lehetne a válasz, hogy megnézzük integer vagy float típusba tartozik-e, ám ez téves eredményeket adna:

1
2
3
4
5
<?php
$ize = (string)4;
var_dump(is_int($ize));
var_dump(is_float($ize));
var_dump(is_numeric($ize));

Ha megnézzük az $ize valóban egy szám, ám karakterlánc típusúvá alakítottuk (az átalakításokról egy későbbi leírásban még szó lesz). Éppen ezért mind az is_int mind az is_float false-t fog visszaadni, az is_numeric azonban nem, mivel az nem a kifejezés típusát, hanem tartalmát vizsgálja.

Mivel az összes felhasználótól érkező adat (GET, POST, COOKIE) string típusúként jelölt a PHP-ben fontos ezt a függvényt fejbentartani.

String

A sztring-ek, azaz karakterláncok a nevükhöz hűen karaktereket, vagy azok láncát tárolják – betűk, szavak, mondatok…

Karakterláncot három módon hozhatunk létre: aposztróffal, idézőjellel és az ún. heredoc szintaxissal.

1
2
3
4
5
$var = '<a href="#">Tutorial.hu</a>';
$var = "<a href=\"#\">Tutorial.hu</a>";
$var = <<<TEXT
<a href="#">Tutorial.hu
TEXT;

Az első kettő egyértelmű, a harmadik érdekesebb. A heredoc szintaxis felépítése a következő:

1
2
3
<<<AZONOSÍTÓ
Bármilyen karakterlánc, ahol nincs szükség escape-lésre
AZONOSÍTÓ;

A heredoc szintaxis alapjairól ennyit, a téma részletesen ki van fejtve a PHP.net string oldalán.

Gyakran fogunk karakterláncokkal dolgozni, így a két string-kezelő operátort érdemes megjegyeznünk. Az első az ún. összefűző operátor, amely a két oldalán található adatot fűzi össze.

1
2
3
4
5
$var1 = 42;
$var = "The answer to life, the universe and everything is " . $var1;
/* $var értéke
The answer to life, the universe and everything is 42
lesz */

A fentivel azonos működésű, ám az összefűző-hozzárendelő operátort használó példa:

1
2
$var = "The answer to life, the universe and everything is ";
$var .= 42;

Az összefűző-hozzárendelő operátor a bal oldalon található sztring végére fűzi a jobb oldalon található adatot, amennyiben a bal oldalon található adat írható.

A string típusba tartozást a is_string függvénnyel ellenőrizhetjük. Azonban az üres karakterlánc is string, így az is_empty – ürességet vizsgáló – függvényt is érdemes megjegyeznünk.

Itt is kiemelném, hogy minden, a PHP-n kívülről érkező adat tartalmától függetlenül string típusú lesz.

Array

Ezzel el is jutottunk a tömbökig. Szintén igen gyakran használt típus. A tömbök kulcs => érték párosokból épülnek fel, ahol – természetesen – mind a kulcsnak, mind az értéknek van típusa, és értéke. Néhány nyelv megkülönböztet ún. indexelt (számozott) és asszociatív (hozzárendelő) tömböket. A PHP-ban egy tömbben mindkét típus lehet, akár vegyesen is. Például:

1
2
3
4
5
$var = array(0, 1, 'google');
$var1 = array('hu' => 'google', 'com' => 'altavista');
$var2 = array(0,
 5 => 1,
 'hu' => 'google');

Mint látható tömböket az array nyelvi elemmel lehet létrehozni. Tudni kell azonban, hogy ez nem függvény, így callback-ként (lásd: később) nem használható.

A fenti példában látszanak a tömbök létrehozásának lehetséges módszerei. Az első tömb ($var) esetében az elemek a következők lesznek (kulcs => érték)

1
2
3
0 => 0
1 => 1
2 => 'google'

Megfigyelhető a nullától kezdődő, és folyamatosan számozás.

A második példában már így alakulnak az elemek:

1
2
'hu' => 'google',
'com' => 'altavista'

Míg a harmadik esetében:

1
2
3
0 => 0,
5 => 1,
'hu' => 'google'

Az így létrehozott tömbökbe bármikor vihetünk fel új elemeket:

1
2
$var2[] = 3;
$var2['ize'] = 15;

Ekkor a $var2 tömbünk más így fog kinézni:

1
2
3
4
5
0 => 0,
5 => 1,
'hu' => 'google',
6 => 3
'ize' => 15

A sorrendet figyeljük meg, és azt, hogy amennyiben nem adunk meg kulcsot a legmagasabb indexnél egyel nagyobb indexet fogja kapni az elem (példánkban a 6-ost).

Ez így még nem jelent túl sokat, pusztán annyit, hogy tömbökben több adatot tárolhatunk. Azonban a tömbelemek (példánkban: 0, 1, ‘google’, 3, 15) lehetnek tömbök is, így több-dimenziós tömböket hozhatunk létre.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$members = array(
	'Harder' => array(
		'posts' => 7725,
		'regdate' => '2003. Március 16'),
	'LeGaS' => array(
		'hozzászóláok' => 5164,
		'regdate' => '2004. August 2.'),
	'BlackY' => array(
		'posts' => 4006,
		'regdate' => '2003. Május 25.'),
	'Zsola2' => array(
		'posts' => 3642,
		'regdate' => '2003. Május 25.'),
	'Toxin' => array(
		'posts' => 3070,
		'regdate' => '2003. Május 25.'),
		);

Mivel ebben a tömbben csak maximum két szinten van tömb ezért két-dimenziós tömbnek nevezzük. Ugyanígy lehetnek három-, négy-, …, n-dimenziós tömbök.

A tömb elemeit a tomb[kulcs] formában érhetjük el. Így az előző tömbban BlackY hozzászólásainak számát a $members[“BlackY”][“posts”], míg Zsola regisztrációjának dátumát a $members[‘Zsola2′][‘regdate’] módon érhetjük el. Fontos megjegyezni, hogy bár működik a $members[Zsola2][regdate] szintaxist kerüljük: a Zsola2 és a regdate (miután megállapítottuk, hogy ilyen nevű állandó nem létezik) Zsola2 és regdate tartalmú sztringként értékelődik ki (mint az aposztrófos megoldásnál), de ez több ellenőrzést, így lassab futást eredményez; arról nem is beszélve, hogy amint létrehozunk egy konstanst regdate néven (nem “regdate” tartalommal) a szkriptünk máris hibásan fog működni! (Ráadásul E_NOTICE szintű hibaüzenetekkel jár…)

Természetesen a tömbök elemeit nem csak így lehet elérni. Egy külön szerkezet, a foreach is rendelkezésünkre áll. A foreach szerkezet a megadott tömb összes elemére lefuttatja az adott kódot. Két formája létezik:

1
2
3
foreach(tömb as érték)
és
foreach(tömb as kulcs => érték)

A kulcs és érték mindkét esetben változók, amelyekben az aktuális tömb-elem kulcsa és értéke elérhető lesz. Például (felhasználva a fenti tömböt):

1
2
3
4
foreach($members as $name => $memberData)
	{
	print "<strong>" . $name . "</strong> regisztrációjának dátuma: " . $memberData['regdate'] . "";
	}

A fenti tömbbel ez a következőt eredményezi:

Harder regisztrációjának dátuma: 2003. Március 16
LeGaS regisztrációjának dátuma: 2004. August 2.
BlackY regisztrációjának dátuma: 2003. Május 25.
Zsola2 regisztrációjának dátuma: 2003. Május 25.
Toxin regisztrációjának dátuma: 2003. Május 25.

A PHP 5 a foreach szerkezethez is hozott újítást: objektumokkal (ezekről később) is használhtjuk (erről szintén lesz még szó), valamint referenciaként is lekérhetjük az elem értékét, így közvetlenül tudjuk azt módosítani.

A következő két kód ugyanazt fogja eredményezni, csak az egyik fut PHP 4 és 5 alatt egyaránt, a második azonban csak az 5-ös verzióval

1
2
3
4
5
6
7
8
foreach($array as $key => $value)
	{
	$array[$key] = 42;
	}
foreach($arrays as &$value)
	{
	$value = 42;
	}

Mindkét kód a tömb összes elemét 42-re fogja állítani.

Van természetesen még rengeteg módszer a tömbök elemeinek elérésére; minimális magyarázattal bemutatok hármat:

1
2
3
4
5
6
while($value = current($array))
	 {
	 $key = key($array);
	 ...
	 next($array);
	 }

Ez megegyezik azzal, hogy

1
2
3
4
foreach($array as $key => $value)
	 {
	 ...
	 }

Azonban a while-os kód a tömb-kezelő függvényeket használja, így valószínűleg jóval lassabb.

A következő megoldás már valamivel gyorsabb:

1
2
3
4
while( list($key, $value) = each($array))
	{
	...
	}

Ez is a fentivel megegyező működésű…

Folyamatosan számozott tömböknél használhatjuk még ezt is:

1
2
3
4
5
6
for($i = 0; $i < count($array); $i++)
	 {
	 $key = $i;
	 $value = $array[$i];
	 ...
	 }

Objektumok

A legösszetettebb adattípus az objektum. Ezek már az objektum orientált programozáshoz tartoznak, és átfogó képet adni róluk a leírás terjedelme miatt gyakorlatilag lehetetlen, mivel a PHP-beli (elsősorban az 5-ös verzió fölött) OOP lehetőségeket több száz oldalas leírásban lehet igazán bemutatni. A témában rengeteg könyv íródott, ezek rendesen bemutatják az OOP lehetőségeit.

Én most erről eltekintenék.

A PHP osztály-alapú OOP-rendszerében az objektumok egy-egy osztály (class) egy-egy példányai (instance) – ellentétben mondjuk a prototípus-alapú javascript-el. Ezeket a fogalmakat a Wikipedián pár mondatban kifejtik az Object-oriented programming oldalon. (A magyar wikipedián is van leírás az OOP-ről, a linkért köszönet Toxinnak!)

Ami számunkra fontosabb az az objektum adattípus. Egy objektum ún. tulajdonságok (property) és metódusok (method) “gyűjteménye”. Már unalomig ismert példa az ember. Úgyhogy tekintsünk ettől el, és a nem kevésbé népszerű autók példát hozzuk fel. Az autó osztály PHP alatt például így is kinézhetne:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class auto
   {
   var $fogyasztas;
   var $maximumSebesseg;
   var $terfogat;
 
   function elindul()
	  {
 
	  }
 
   function megall()
	  {
 
	  }
   }

A var kulcsszóval tudunk tulajdonságot állítani – PHP 4 alatt, PHP 5 alatt a public/private/protected kulcsszavak használatával. A tulajdonságok bármilyen típusúak lehetnek, az objektumoknál is lehetséges a végtelen szinteződés [elméletben, gyakorlatban a memória határt szab ennek].

Az osztály-definíción belül található függvények (function) az osztály metódusai lesznek, példánkban az elindul() és megall(). Nem tud sokat az autónk, de ez van :)

Azonban azzal, hogy az osztályt definiáltuk még nem hoztunk létre objektumot. Ezt a new kulcsszóval tudjuk megtenni:

1
$trabant = new auto();

Az így elkészület trabant objektumunknak egyelőre az összes auto-ra jellemző tulajdonságai lesznek: mind a fogyasztása, a maximum sebessége, mind a térfogata (motortérfogat?) Null. A fogyasztásnál ez még jó is lenne :)

Úgyhogy gyorsan állítsuk is be a tulajdonságait a trabinak. Az objektumok tulajdonságait $objektum->tulajdonság formában, míg a metódusait $objektum->metódus() formában érhetjük el.

Fontos még itt kiemelni, hogy a PHP 5.1-től kezdve van lehetőség a foreach szerkezet használatára objektumok esetében is, amikor a kulcs a tulajdonság neve, az érték pedig annak értéke lesz.

1
2
3
$trabant->fogyasztas = array('kombinalt' => 8, 'varosi' => 10, 'orszaguti' => 6);
$trabant->maximumSebesseg = 130;
$trabant->terfogat = 900;

Így már van egy autónk. Ha már így belejöttünk készítsünk egy újat is:

1
2
3
4
5
6
class Fiat extends auto
	{
	var $terfogat = 1000;
	var $gyarto;
	var $legkondi = false;
	}

Ezzel létrehoztunk egy Fiat nevű osztályt, ami kiterjeszti az auto osztályt – örökölve ezzel annak minden tulajdonságát és metódusát [ezek felülírhatóak, lásd a terfogat tulajdonság alapértéke]. Mivel Fiat-ot ketten is gyártottak (Polski fiat és az eredeti olasz Fiat) fontos itt megjegyeznünk a gyártót is.

1
2
3
$polski = new Fiat();
$polski->gyarto = 'Polski fiat';
$polski->legkondi = false;

Ha már ennyi autónk van érdemes őket vizsgálnunk is. Például, hogy objektumok-e egyáltalán. Erre az is_object() függvényt használhatjuk:

1
2
is_object($polski); /* Ha az előző kód után rakjuk igazat fog visszaadni */
is_object((string)$trabant); /* Karakter-lánc típussá alakított objektumnál - értelemszerűen - hamisat fog adni */

Egy objektumnál persze nem csak ezt szeretnénk vizsgálni. Például jó lenne megnézni, hogy adott objektum autó-e vagy sem.

1
is_a($autom, 'auto');

Ha az $autom valóban egy, az autó osztályhoz, vagy valamelyik abból származtatott osztályhoz tartozik (példánkban: Fiat), akkor igazat fog visszaadni.

Hasznos függvény lehet még a get_class() függvény, amely megmondja, hogy az objektum melyik osztálynak példánya:

1
2
$object = new stdClass();
print get_class($object);

Ez az ‘stdClass’ szöveget fogja kiírni (amely a PHP egyik beépített osztálya, mindig elérhető).

Az objektum típusról ennyi egyelőre elég, akit a téma részletesen érdekel az kérdezhet a fórumon, vagy elolvashat egy-két könyvet a témában :)

Resource

A Resource, azaz erőforrás típusú adatokat kódszinten nem lehet előállítani, azokat a PHP – és a kiterjesztések – belső kódjai állítják elő. A típusról sok mindent nem lehet elmondani, két ezzel kapcsolatos fontos függvény van:

1
2
is_resource()
get_resource_type()

Az első függvény a resource típusba sorolást adja meg, a második pedig az adott erőforrás értelmezhető formában levő típusát; pl.: mysql link, file.
A PHP.net-en van egy szép hosszú lista az erőforrásokról, az azokat előállító és felhasználó függvényekkel együtt. Ha olyan erőforrással találkozunk a kézikönyvben, amelyről nem tudjuk hogyan keletkezik nagy segítség lehet.

Pszeudó-típusok

A következő típusokat a dokumentációkban igen gyakran használják, így érdemes röviden jellemezni őket

mixed

A mixed típus többféle típusú adatot is elfogad, amelyeknek listáját általában a leírásban kifejtik. Azonban azt érdemes kiemelni, hogy elég sok függvény hiba esetén boolean false-t ad vissza, visszatérési értéke mégsincs mixed-ként jelölve a dokumentációban, mivel az ott levő típusok az optimális esetet jelölik.

Példáért nem is kell messze menni, a sokat emlegetett strpos is int-ként van jelölve, holott – mint feljebb értelmeztük – boolean false-al is visszatérhet.

Callback

Ez egy érdekes típus, a kézikönyben “visszahívható” néven emlegetik, én az angol megnevezést jobban kedvelem. A callback típus olyan adatot jelöl, amely függvény vagy metódusnévként értelmezhető, és végrehajtható. Egy példán keresztül talán érthetőbb lesz:

1
2
$callback = 'unlink';
$callback('index.php');

Ez a kód az unlink függvény használatával törli az index.php-t. A $callback változónk – bár a típusa valójában karakterlánc – a létező unlink függvény miatt használható callback-ként.
Mint írtam metódusokat is meg lehet vele hívni. Ekkor egy kételemű tömböt kell létrehoznunk, melynek első eleme (0-s index) az adott osztály egy példánya (vagy arra mutató referencia) vagy neve, a második eleme (1-es index) a metódus neve.

1
2
3
4
5
6
7
8
9
10
11
12
13
class test
	{
	function myUnlink()
	   {
	   foreach(func_get_args() as $arg) { @unlink($arg); }
	   }
	}
 
$test = new Test();
$callBack1 = array($test, 'myUnlink');
$callBack2 = array('test', 'myUnlink');
$callBack1('index.php', 'config.php');
$callBack2('index.php', 'config.php');

A $callBack1 és a $callBack2 ugyanazt fogják tenni: törlik az index.php-t és a config.php-t, csak míg a $callBack1 esetében a létrehozott $test objektum myUnlink() metódusát használjuk addig a $callBack2-nél példányosítás nélkül a test osztály myUnlink metódusát hívjuk meg. ( test::myUnlink() formában.
(Időnként hasznos az ősosztályok metódusaira vagy tulajdonságaira hivatkozni, vagy olyan osztálymetódusokat meghívni, amelyek nem példányosított objektumokhoz tartoznak. A :: operátor erre használható. – Forrás: Paamayim-nekudotayim (hatókör megadó operátor) a PHP.net-en)

Amennyiben PHP kódhoz készítünk dokumentációt érdemes figyelni arra, hogy a PHP függvény-referenciájában a visszatérési érték típusánál soha nem adnak meg callback-et, csak paraméter típusánál. Teljesen érhető (mégiscsak ál-típus), bár a create_function() függvény esetében – amely mindig Callback típussal tér vissza – megkérdőjelezhető.

Gyorsan nézzünk meg egy példát a create_function() alkalmazására!

1
2
$var = create_function('$output', 'echo $output;');
$var('BlackY');

Ez ki fogja írni a BlackY szöveget. A példa teljesen egyszerű, ám egy fontos dologra máris mutatott megoldást: mint írtam a callback-ek csak függvényeket képesek meghívni. A nyelvnek azonban vannak elemei, amelyek – bár sokan tévesen annak hiszik – nem függvények. Ezek a következők:

  • array()
  • echo()
  • empty()
  • eval()
  • exit()
  • isset()
  • list()
  • print()
  • unset()

A visszahívhatóságról az is_callable() függvénnyel bizonyosodhatunk meg:

1
2
3
4
$var = 'echo';
var_dump(is_callable($var));
$var = 'var_dump';
var_dump(is_callable($var));

Mivel az echo nem függvény így először hamisat fog visszaadni, a var_dump esetén azonban már igazat.

Number

A Number típus a számot tartalmazó adatok együttes neve. Ahogy már fentebb írtam a (string)6 is egész szám (ezért a Number pszeudó-típushoz is tartozik), valójában mégis karakterlánc-típusú. Típusba tartozásnak ellenőrzésére az is_numeric() függvényt használhatjuk.

Scalar

Skalár értékeknek nevezzük a boolean, az integer, a float és a string típusú adatokat. Az array, null, object és resource típusok azonban nem skalárok. Típusba tartozásnak ellenőrzésére az is_scalar() függvényt használhatjuk.

Remélem hasznos – és nem túl száraz – volt ez a rövidnek nem igazán nevezhető leírás, de ez a téma már megért egy ilyen terjedelmű kifejtést…

Kérdés, vélemény, probléma esetén ajánlom a fórumot!

Kapcsolódó bejegyzések:
  • Az Adattípusok PHP-ben című leírásban végignéztük, hogy egy-egy kifejezés milyen típusú lehet; néhány helyen jeleztem, hogy majd lesz szó a típus-konverzióról is …

  • A PHP nyelvről szóló sorozatunknak ebben a részében a tömböket fogom bemutatni. A PHP tömb vagy eredeti nevén array egy úgynevezett összetett változó típus. Az ö …

  • Személy szerint már sokszor jártam úgy, hogy egy eredményt, ami várhatóan egy tömb volt be kellett járja. Ilyen esetekben általában meg szoktuk vizsgálni, hogy a …

  • Ismerjük meg a PHP változókat! Ahogy minden nyelvnek, úgy a PHP-nak is a változók képezik az alapját. A változók arra valók, hogy adatokat tároljunk bennük. Eze …

  • Bizonyára sokszor megesett már veletek is, hogy egy végtelen nagyságú tömböt objektummá szerettetek volna alakítani.  Ez a megoldás rendkívül hasznos,  s gyakran …

A cikket beküldte: BlackY ()

Szólj hozzá
a Adattípusok PHP-ben c. bejegyzéshez

- Engedélyezett HTML elemek: <a> <em> <strong> <ul> <ol> <li>
- Forráskód beküldéséhez tedd a kódot ezek közé: <pre lang="php" line="1">Kódrészlet helye itt</pre>