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:
<?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:
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:
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:
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:
$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:
$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:
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:
<?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.
$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ő:
<<<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.
$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:
$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:
$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)
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:
'hu' => 'google',
'com' => 'altavista'Míg a harmadik esetében:
0 => 0,
5 => 1,
'hu' => 'google'Az így létrehozott tömbökbe bármikor vihetünk fel új elemeket:
$var2[] = 3;
$var2['ize'] = 15;Ekkor a $var2 tömbünk más így fog kinézni:
0 => 0,
5 => 1,
'hu' => 'google',
6 => 3
'ize' => 15A 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.
$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:
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):
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
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:
while($value = current($array))
{
$key = key($array);
...
next($array);
}Ez megegyezik azzal, hogy
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:
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:
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:
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:
$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.
$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:
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.
$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:
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.
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:
$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:
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:
$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.
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!
$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:
$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!
Harder
Profil
