PHP nyelv 1. rész.

PHP nyelv 1. rész

Történelem A világháló kezdetben nem volt több egyszerű adatnál, a HTML (HyperText Markup Language) első változata még azt sem tette lehetővé, hogy képeket helyezzünk el weboldalunkon. Mára azonban hatalmas változásokon ment keresztül, rengeteg szolgáltatást tartalmaz: képeket, hangokat, mozgóképeket, és mindezek mellett szórakoztat, tanít és kapcsolatot tart. A web fejlődésével párhuzamosan fejlődtek az eszközök is, az egyszerű leírónyelvhez valódi programozási nyelvek csatlakoztak.

Történelem A statikus weboldalak igen fontos szerepet töltöttek be az Internet szolgáltatásaiban az ún. hőskorban. Ma azonban már nagyon sok olyan feladat létezik, melyeket nem lehet, vagy nem célszerű statikus oldallal megoldani. A cégek adataikat többnyire adatbázisokban tárolják. Ezekből az adatbázisokból le lehet ugyan képezni az adatokat különböző eljárásokkal statikus oldalakra, azonban ez több olyan problémát is felvet, mely az információ közzétételének ezen módját kizárja a lehetséges megoldások közül. Vannak olyan feladatok, melyek ugyancsak szükségessé teszik a szerver-oldali programfuttatást, ilyen lehet például egy egyszerű letöltés-számláló az adott oldalon, de lehet például egy Internetes portál friss hírek rovata, mely igen gyakran frissül. Ma már nincs arra energia, humán erőforrás, hogy ezeket statikus weblapon tartsák karban illetve frissítsék és, akkor még nem is beszéltünk a hibalehetőségekről (például elírás).

Történelem A dinamikus weboldal egyik változata, mely kliens-oldali programok segítségével kommunikál a felhasználóval. Ma a feladatok igen széles skáláját tudjuk a kliens oldalon elvégezni, kezdve a legegyszerűbb kérdőív adatainak ellenőrzésétől, a külön csatornán lebonyolított titkosított banki tranzakció kezelésig. A legelterjedtebb kliens-oldali szkript nyelv egyértelműen a Javascript. Erről már adtunk áttekintést a Javascript nyelv keretein belül, amely tipikusan erre a célra fejlesztettek. A kliens oldali programozásnak azonban van néhány hátulütője: a lassúság és a böngészőfüggőség. A felhasználók gyors, könnyen átlátható, könnyen kezelhető, stabilan működő oldalakat szeretnek használni.

Történelem Néhány éve a hangsúly ezért ismét a szerver-oldali megoldásokra terelődött. A CGI (Common Gateway Interface) szabvány lehetővé teszi más programok futtatását és a kimenetek szövegbe, hangba vagy videóba összegezve a kliensre juttatását. Szabványos felületet biztosítva a CGI lehetővé teszi a programozók számára programozási nyelvek széles spektrumának használatát. CGI programok dolgozhatják fel a kliens által kitöltött űrlapokat, számlálhatják az oldalt látogató felhasználókat, adatokat kezelhetnek adatbázisokban és több száz egyéb feladatot oldhatnak meg. A szerver-oldali programozáshoz sorolható: a Perl (Practical Extraction and Report Language), a Python, a PHP, az ASP (Active Server Pages), a JSP (Java Server Pages).

A PHP története A PHP első változatát - amely tulajdonképpen egy makrókészlet volt - Rasmus Lerdorf készítette 1994-ben. Ezeket a segítő eszközöket együttesen a Personal Home Page Tools névvel illette. Később egy friss elem került a csomagba, a Form Interpreter (Űrlapfeldolgozó), így PHP/FI néven vált ismertebbé. A felhasználók szemszögéből a PHP/FI nagyon hasznos segédeszköz volt, több fejlesztő is felfigyelt rá, így 1997-re már számos programozó dolgozott rajta. Az így elkészült PHP3-as már egy csapat együtt-működéséből született. A PHP3-as azonban még elég lassú volt ahhoz, hogy mentségül szolgáljon a Perl-höz értő programozóknak, miért nem váltottak.

A PHP története Az 1990-es évek végén a webszerver nyelvek nagy fejlődésen mentek át. A Perlt és az első PHP-t - mivel HTML oldalak voltak - soronként értelmezték. A fejlesztők később olyan rendszereket választottak, amelyek memóriába fordítottak. A nyílt forráskódú fejlesztéseknek köszönhetően megjelent PHP4 és a PHP3 közötti óriási teljesítménykülönbség az értelmezésről a fordításra való áttérésnek köszönhető. A PHP4 egy olyan nyílt forráskódú nyelv az új webfejlesztők számára, amely folyamatosan váltotta fel a Perl-höz hasonló régebbi nyelveket.

A PHP története Ma a PHP - hivatalosan a PHP: Hypertext Preprocessor elnevezést használja - egy széles körben használt, nyílt forráskódú, általános célú programozási nyelv, különösen jó webfejlesztés támogatással és HTML-be ágyazási képességekkel. A szintakszisa a C, Java és Perl nyelvekre épül és viszonylag könnyen megtanulható. A nyelv fő célja lehetőséget teremteni dinamikusan generált weboldalak gyors készítésére, de a PHP ennél sokkal többre is képes. A PHP főleg szerveroldali szkriptek írására készült, azaz bármire képes, amire más CGI programok, ilyen funkciók például az űrlap adatok feldolgozása, dinamikus tartalom generálása, vagy sütik küldése és fogadása.

A PHP előnyei Egyértelmű, hogy a PHP az egyetlen igazi nyelv, de vannak akiket csak a tények győznek meg, a tények pedig azt mutatják, hogy napjaink weboldalaihoz a PHP a megfelelő szkript nyelv. Fejlesztési sebesség Mivel a PHP lehetőséget ad a HTML elemek és a programkódok elkülönítésére, az alkalmazások fejlesztésekor lehetőség van elválasztani a kódolási, tervezési, és összeállítási szakaszt. Ez jelentősen megkönnyíti a programozók életét azzal, hogy elmozdítja az akadályokat a hatékony és rugalmas alkalmazások kialakításának útjából.

A PHP előnyei Nyílt forráskód
A PHP mint nyílt forráskódú termék jó támogatással rendelkezik, ráadásul a PHP az elterjedtebb operációs rendszerek bármelyikén képes futni, a legtöbb kiszolgáló-programmal együttműködve. Nagy az esély rá, hogy bármilyen problémával is kerüljünk szembe, kis keresgélés után választ kapunk rá, ha mégsem, egy levelezőlistára küldött üzenetre általában hamar érkezik a megfelelő válasz a megoldásra. A feldolgozóprogram hibáinak javítása nem sokkal felfedezésük után megtörténik, és a felmerült új igényeket kielégítő szolgáltatások is hamar beépülnek a nyelvbe. Nem kell várni a következő hivatalos kiadásra, hogy a fejlesztések előnyeit élvezzük. Nincs a PHP működtetéséhez egyedileg kiválasztott kiszolgáló vagy operációs rendszer. Szabadon választhatunk olyan rendszert, amely kielégíti saját vagy ügyfeleink igényeit, kódunk továbbra is futtatható lesz, bármi mellett is döntünk.

A PHP előnyei Teljesítmény
A hatékony Zend Engine-nek (a Zend Engine a PHP modulok mögött található, a programokat futtató mag elnevezése) köszönhetően a PHP4-es a mérések szerint messze maga mögött hagyja legtöbb versenytársát. Ehhez az előnyhöz hozzávehetjük még a napjaink programjait átszövő objektum orientált elméletet, amelyet szintén támogat a PHP (igaz ezt elsősorban az 5-ös verziótól teljesedett ki, de a lehetőség korábban is adott volt rá), akkor szinte teljes a kép. Hordozhatóság A PHP-t alapvetően úgy tervezték, hogy alkalmas legyen számos operációs rendszeren való használatra, együttműködve különböző kiszolgálókkal és adatbázis-kezelőkkel. Fejleszthetünk UNIX rendszerre és áttérhetünk NT alapokra minden probléma nélkül. A PHP alkalmazásokat kipróbálhatjuk Personal Web Serverrel, és később telepíthetjük azokat egy UNIX rendszerre, ahol a PHP-t Apache modulként használjuk.

PHP bevezetés A PHP egy szerveroldali szkript nyelv. A válaszlap formátumát leíró utasítások egy HTML dokumentumba ágyazva helyezkednek el. A webszerver a meghívott dokumentum URL-jéből ismeri fel, hogy a kérést a PHP szervernek kell feldolgoznia. A mintadokumentum HTML utasításai változtatás nélkül átkerülnek a válaszlapra, a PHP specifikus elemeket a PHP végrehajtja, és a generált válasz kerül be az eredménylapra. Ugyan a PHP leíró nyelve nem adatbázis orientált, hanem a C általános programozási nyelvre épül, mégis tartalmaz adatbázis kapcsolódási kiegészítő modult, amely lehetővé teszi, hogy elérhessük, és a válaszlapon megjeleníthessük a legkülönbözőbb adatbázisokban tárolt adatokat is. A PHP rendszer működési struktúrája az alábbi elemekből épül fel: webszerver PHP-szerver minta dokumentum

PHP bevezetés A PHP kérések feldolgozása az alábbi lépésekben fut le:
Az olvasott lapon kiadnak egy hiperlink kapcsolódást egy olyan URL-re, mely mögött PHP hívás rejlik. Egy ilyen cím lehet például a következő: illetve a hivatkozást más esetekben a formában is megadhatjuk. A hivatkozásokban az URL első része jelöli ki, hogy mely gépen található a webszerver és a PHP szerver. Az első mintában a ”/php/” rész egy virtuális könyvtár, amely jelzi a webszervernek, hogy itt egy PHP dokumentumot kell kezelni, és meg kell majd hívni a PHP szervert. A virtuális útvonal kijelölésének menete webszerver specifikus, rendszerint a webszerver konfigurációs állományát kell módosítani a virtuális útvonal kijelöléshez.

PHP bevezetés A második mintában nem kellett virtuális könyvtár ahhoz, hogy a webszerver tudja, hogy a PHP szervert kel meghívnia. Ebben az esetben ugyanis a dokumentum kiterjesztése utal arra, hogy a dokumentumot a PHP fogja kezelni. A kiterjesztések és a kezelő programok összerendelése is a webszerver konfigurációs állományában történik. Az URL utolsó tagja, példánkban az index.php rész a séma dokumentumot jelöli ki, mely megadja a válaszlap előállításának módját.

PHP bevezetés A webszerver érzékeli, hogy a meghívott URL a PHP szerverhez kapcsolódik, ezért meghívja a PHP modult végrehajtásra. A PHP szerver kétféle módban is működhet: CGI és API módban. Az első lehetőség esetén minden oldal lekérésekor és feldolgozásakor egy új példány fut le a PHP feldolgozóból. Mivel a szkript futtatása után egy ilyen példány leáll, minden erőforrás, amit lefoglalt, megszűnik. A népszerűbb a második forma, amikor a PHP-t modulként futtatjuk egy több processzes webszerveren. Egy több processzes webszerver tipikusan rendelkezik egy szülő processzel, ami koordinálja a többi kapcsolódó process (a gyermekek) munkáját, amik valójában a weboldalak kiszolgálását végzik. Amennyiben egy kérés érkezik egy klienstől, egy éppen szabad gyermekprocess kapja meg a kiszolgálásra az utasítást.

PHP bevezetés A PHP modul megkapja a végrehajtási feladatot a feldolgozandó séma dokumentum azonosítójával együtt, átolvassa és elemzi a séma dokumentumot. A PHP specifikus utasításokat értelmezi és végrehajtja. A,mennyiben adatbázis hozzáférési igények is felmerültek a PHP specifikus utasítások között, akkor a PHP szerver kapcsolatba lép az adatbázis-kezelővel, és végrehajtja a kijelölt műveletsort. A PHP specifikus utasítások között megtalálhatok azon elemek is melyekkel leírható, hogyan jelenjenek meg az eredményadatok a válasz-dokumentumban. A generált válaszlap a HTML utasítások és a dinamikus elemekből felépülve, átkerül a Web-szerverre, majd onnan eljut az őt igénylő böngészőhöz.

A PHP kód írása A PHP specifikus utasítások a HTML utasítások közé beillesztve, beágyazva foglalnak helyet. A HTML utasításoktól való egyértelmű és könnyen kezelhető szétválasztás érdekében az egyes PHP specifikus utasításokat keretbe foglaljuk. Az elhatárolás az alábbi változatok valamelyikével lehetséges: <?php PHP elemek ?> hagyományos <script language=”php”> PHP elemek</script> szkript stílusú <? PHP elemek ?> rövid <% PHP elemek %> ASP stílusú

A PHP kód írása A fenti kezdő- ill. záróelemek közül az utolsó kettő használatát a ”php.ini” fájlban engedélyezni kell a ”short_open_tag=on” ill. az ”asp_tags=on” beállításokkal. Éppen emiatt célszerű az elsőt vagy a másodikat használni. A PHP elemek a C nyelvi kifejezésekhez hasonló formátumot öltenek. Egy tagolt rész több elemi PHP kifejezést, utasítást is tartalmazhat. Ekkor az egyes PHP utasításokat pontosvesszővel határoljuk el egymástól: <?php PHP utasítás1; PHP utasítás2; ?>

A PHP kód írása Mivel a HTML fájlok egyszerű szöveges fájlok, bármilyen szövegszerkesztő segítségével írhatjuk a PHP kódokat is. A HTML-szerkesztők általában viszont nyújtanak valamilyen különleges támogatást PHP-szerkesztéshez is, ilyenek például a kódszínezés, a kifejezésszerkesztő vagy a tesztelő. Az évek során hagyománnyá vált, hogy a programozási nyelvek megismerését a program bemutatásával kezdik. A sorok elején található számozás és a kettőspont nem a kód része, ezek csak a kódhoz tartozó magyarázatok megkönnyítése miatt kerültek oda. <?php print("Hello, World!"); ?>

A PHP kód írása Ez a kód nem tartalmaz HTML tag-eket, mégis működőképes. Gépeljük be a kódot és mentsük el a fájlt ”hello.php” néven! Most már csak annyi dolgunk van, hogy a szerveren elhelyezzük a fájlt. Ha otthoni számítógépünkön dolgozunk, akkor meg kell keresni azt a könyvtárat, ami a ”localhost”-hoz tartozik, és oda be kell másolni, egyébként pedig FTP segítségével fel kell töltenünk egy másik számítógépre. Amennyiben minden rendben ment, akkor elérhetjük fájlunkat egy böngésző segítségével, és a következő eredményt kapjuk:

A PHP kód írása Ha a PHP-t nem sikerült telepíteni a kiszolgálóra vagy nem a megfelelő kiterjesztést használtuk, feltehetően nem az előző ábrán látható kimenetet kapjuk. Ebben az esetben általában a PHP program forráskódját látjuk viszont. Elemezzük ki a kódot! Az első és a harmadik sorban található nyitó- ill. záróelemeken kívül egyetlen egy új dolgot találunk. A print() parancs kiírja a böngészőbe a neki átadott adatokat. Az adat jelen esetben egy szöveg, mely az utasítás végrehajtásakor a böngészőbe kerül kiírásra. A print() tulajdonképpen egy függvény. A függvények olyan parancsok, amelyek valamilyen műveletet végeznek általában a nekik átadott adatokkal. A függvényeknek átadott adatokat majdnem mindig zárójelek közé kell tennünk a függvény neve után. Ebből a szempontból a print() kivételes, mert a zárójelpárja elhagyható. A print() helyett használható az echo() függvény is, melyek segítségével a HTML tag-eket is kiírathatjuk, például a print(" "); egyenértékű a tag HTML kódbeli elhelyezésével.

HTML-es változat <html> <head>
<title>Hello</title> </head> <body> <?php print("Hello, World!"); ?> </body> </html>

HTML-es változat Egy dokumentumban a HTML elemek közé tetszőleges számú PHP kódblokk írható, és ezek együttesen alkotnak egy programot. Bármi, amit egy megelőző blokkban határoztunk meg, a dokumentumon belül elérhető lesz a későbbi blokkokban is. PHP blokk nem csak a <body> és </body> tag-ek között helyezhető el, hanem használhatjuk a PHP-t például dinamikus oldalcím generálására is, ha a <title> és </title> tag-ek közé helyezzük el a kódot. A következőkben a HTML tag-eket csak a fontos helyeken hagyjuk meg a kód rövidíthetősége érdekében.

Megjegyzések a PHP kódban
A PHP utasítások közé elhelyezhető megjegyzéseknek is többféle szintaktikája van: // szoveg : ekkor a megjegyzés kezdetétől az aktuális sor végéig terjedő rész lesz a megjegyzés rész, a közrefogott szöveg nem kerül értelmezésre a PHP szerver által. # szoveg : ugyanolyan értelmezésű, mint az előző formátum. /* szoveg */ : ekkor több sorra is kiterjedhet a megjegyzés rész. A későbbiekben rendszeresen megjegyzések találhatók majd a példaprogramokban magyarázat céljából.

ADATOK Az adat a program alapvető alkotóeleme. A PHP-ben az adatokat definiálhatjuk szövegként (karakterlánc vagy sztring), egészként, lebegőpontos számként, logikai értékként, és a típusok összetett keverékeként. Változók $a="alma"; A $a egy változó, amely az alma szöveget tartalmazza, értékét bármikor megváltoztathatjuk. A konstansok értékét és a változók értelmezési tartományát viszont nem lehet megváltoztatni. A változókra a következő feltételek teljesülnek: A változók azonosítója mindig a $ (dollár) jellel kezdődik, az azonosító pedig betűket, számokat, és az _ jelet tartalmazhatja, kikötve, hogy számmal nem kezdődhet. A felvett érték szabja meg a változó típusát.

ADATOK A változók meghatározott típusúak lehetnek, például egész vagy sztring, a PHP azonban szükség esetén átkonvertálja a változót más típusúvá. $s="0"; A $s, amely a 0 (nulla) szöveget (karaktert) tartalmazza, automatikusan átkonvertálható üressé vagy hamissá. A változók nagysága/hosszúsága korlátozott, de a sztringek majdnem korlátlan hosszúak lehetnek (csak a memória korlátoz). A hiányzó változókat a PHP automatikusan létrehozza: $szam=4; print($szma);

ADATOK Az elgépelésnek nem hibaüzenet az eredménye. A PHP ugyanis létrehozza a $szma változót, a print() függvény pedig egy üres vagy tartalom nélküli változót kap, aminek hatására a böngészőben nem jelenik meg semmi. Az isset() függvény ellenőrzi, hogy a változó létezik -e, és logikai értéket szolgáltat vissza, míg az unset() függvény eltávolítja a változót. A későbbi részekben láthatunk majd példát e két függvény használatára.

ADATOK Konstansok define("a","alma"); A define parancs az első paraméterként megadott névvel létrehozza a konstanst, és a második paraméterként megadott értéket rendeli hozzá. A define parancs bárhol használható, a definiált konstansok pedig globális hatókörűek, azaz mindenhol, így a függvények belsejében is elérhetők.

ADAT-típusok Típus Leírás Példa integer egész szám 12 double
lebegőpontos szám (valós szám) 9.967 string szöveg vagy karakterlánc "Hello" boolean logikai (értéke igaz/true vagy hamis/false) true array tömb hatodik fejezet object objektum

ADATOK A változó típusának meghatározására a PHP gettype() függvényét használhatjuk. Amennyiben a függvényhívás zárójelei közé változót teszünk, a gettype() egy karakterlánccal tér vissza, amely a változó típusát adja meg. A változó típusának módosítására a PHP a settype() függvényt biztosítja. A settype()-ot úgy kell használnunk, hogy a megváltoztatandó típusú változót, valamint a változó új típusát a zárójelek közé kell tennünk, vesszővel elválasztva. $proba=3.14; print gettype($proba); //kiírja, hogy double settype($proba,"string"); //karakterlánccá alakítja

ADATOK Azok, akik már használták a C programozási nyelvet, nyugodtan alkalmazhatják e nyelvben megismert típusátalakítást vagy más néven típuskényszerítést: $proba=(string)$proba; Ez a sor egyenértékű a settype($proba,"string"); sorral Függvények formájában léteznek olyan típuslekérdező parancsok, melyek paraméterként megadva a változó nevét, logikai értékkel térnek vissza, ilyenek például: is_array() is_bool() is_double() is_numeric() is_string() is_object().

ADATOK Kifejezések Műveletek adatokkal
A PHP rengeteg kifejezést, operátort, függvényt, osztályt kínál, továbbá többféle lehetőséget nyújt az adatok kezelésére mind az adatbázisok, mind pedig a HTML felé. Kifejezések A PHP-ben minden kifejezés. A $kor=29; utasítás három kifejezést tartalmaz. Egyszer a $kor változót, a 29-et, és magát az egész utasítást. A kifejezés a függvények, értékek és operátorok (műveletjelek) olyan együttese, amely értéket határoz meg. Általánosságban azt mondhatjuk, hogy ha értékként használhatunk valamit, akkor az kifejezés.

Operátorok Az operátor (műveletjel) jel vagy jelsorozat, amelyet ha értékek összekapcsolására használunk, valamilyen műveletet végezhetünk, amely általában új értéket eredményez. Az operandus egy érték, amelyet a műveletjellel kapcsolatban használunk. Egy műveletjelhez általában két operandus tartozik. Hozzárendelő A $kor=29; utasítás a baloldali változóhoz a jobb oldal értékét rendeli. Egy utasításban több hozzárendelő operátort is használhatunk: $szam=$kor=29; Összehasonlító operátorok: ==; !=, ===, !==, <, >, <=, >= Az összehasonlító operátorok két értéket hasonlítanak össze, és hibákhoz vezethetnek a PHP automatikus típuskonverziója miatt. A hamis logikai érték és a 0 megkülönböztetésére alkalmasak a === vagy a !== operátorok, ugyanis a == ezen értékeknél nem a várt eredményt adja.

Operátorok Operátor Jelentés Igaz Hamis == egyenlő érték 4==4 3==4 !=
nem egyenlő érték 3!=4 4!=4 === egyenlő érték és egyező típus 0===0 0===false !=== nem egyenlő érték vagy nem egyező típus 0!==false 0!==0 < kisebb 3<4 6<4 > nagyobb 5>4 5>7 <= kisebb vagy egyenlő 4<=4 5<=4 >= nagyobb vagy egyenlő 9>=3 6>=8

Operátorok Aritmetikai operátorok: + - * / %
A + összeadáshoz, a - kivonáshoz, a * szorzáshoz, a / osztáshoz használható, a % pedig az osztás maradékát adja. A maradékos osztást két lebegőpontos számmal is elvégzi úgy, hogy elhagyja a tizedesjegyeket. A maradékos osztás eredménye mindig egész. Az aritmetikai műveleteket az operációs rendszer a számítógép hardverével végezteti el, így ezek pontossága egyrészt a hardvertől függ, másrészt attól, hogy az operációs rendszer hogyan kezeli a hardvertől kapott eredményt.

Operátorok Sztringoperátorok: . .=
Két sztring összefűzéséhez használható a ”.” operátor, míg egy sztring végéhez egy másikat a ”.=” operátorral lehet csatolni. $szin="piros"." "."kék"; //$szin="piros kék" $szin.=" lila"; //$szin="piros kék lila"

Operátorok Növelő/csökkentő operátorok: ++ --
A ++ és -- operátorok egyaránt írhatók változók elé és mögé. A különbség az, hogy ha például a $szam változó értéke 7, és kiadjuk a print(++$szam); parancsot, akkor a $szam változó előbb felveszi a 8 értéket, majd ez megjelenik a böngészőben, ha pedig a print($szam++); parancsot adjuk ki, akkor előbb kiíródik a 7, és utána növelődik meg a változó tartalma eggyel. Ez teljesen hasonlóan működik a -- operátor esetében, csak a változó tartalma eggyel csökkeni fog.

Operátorok Egyéb hozzárendelő operátorok: += -= *= /= %=
Ezek szintén az egyszerűbb leírást segítik. Például a $szam+=4 utasítás egyenértékű a $szam=$szam+4 utasítással, a $szam*=4 utasítás pedig a $szam=$szam*4 utasítással. Logikai operátorok: ! && || and xor or A logikai operátorok logikai értékeken végeznek műveleteket. A következő táblázat a lehetséges logikai műveleteket mutatja be. Arra a kérdésre, hogy miért van kétféle vagy és és logikai művelet, a műveletek sorrendje adja meg a választ.

Operátorok Operátor Név Igaz, ha Példa Eredmény || vagy
a bal vagy a jobb operandus igaz true || false true or true or false 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 and true and false ! tagadás az egyetlen operandus hamis !true

Operátorok Bináris operátorok: & | ^ ~ << >>
A számítógépben minden binárisan van tárolva, azaz minden egy különböző hosszúságú bináris sztring. Ezek kezelésére alkalmasak a bináris operátorok. Amennyiben van egy 1-es és egy 2-es számunk, akkor a nekik megfelelő bináris alakok a 01 és az 10 (napjainkban 32 biten szoktak tárolni, így például az 1-es 31 db 0 után egy 1-es). A bitenkénti és (&) eredményében azokon a helyeken lesz 1-es, ahol mindkét operandusban 1-es volt. Így az 1-es és a 2-es bitenkénti és-e 0. A bitenkénti vagy (|) eredményében azokon a helyeken lesz 1-es, ahol legalább az egyik operandusban 1-es volt, azaz az 1-es és 2-es esetében az eredmény a bináris 11 lesz, ami 3-at ér. A bitenkénti xor (^) eredményében azokon a helyeken lesz 1-es, ahol a két operandus közül az egyikben és csakis az egyikben 1-es volt. Az 1 ^ 2 szintén a 3-at adja.

Operátorok A bitenkénti tagadás (~) az összes bitet invertálja, azaz ahol 1-es volt, ott 0 lesz, és fordítva. Már csak két operátor maradt hátra: a jobbra tolás (>>) és a balra tolás (<<). Ezek az operátorok meghatározott értékkel eltolják a biteket a megfelelő irányba. Amennyiben a $szam változó értéke 3, akkor a $szam>>=1; utasítás hatására a $szam értéke 1 lesz (a bináris 11-et 1-gyel jobbra tolva a bináris 01-et kapjuk). Ha pedig a $szam<<=2; utasítást nézzük, akkor a $szam a 12-vel lesz egyenlő (az 11-ből az 1100-át kapjuk).

Operátorok Hivatkozás operátor: &
A hivatkozás operátort változónév elé kell tenni. Amennyiben a $szam változó értéke 4, és kiadjuk a $sz=&$szam; utasítást, akkor a $sz változó ugyanarra a memóriacímre fog mutatni, mint a $szam, szükségképpen az értéke is meg fog egyezni a $szam változó értékével, azaz 4 lesz. Ha későbbiekben bármelyik értékét változtatjuk, változik a másik is, hiszen ugyanarra a memóriacímre mutatnak. Hibaellenőrző A operátor elrejti a függvények és különböző kifejezések hibáit, ami néhány weboldalon hasznos lehet, hiszen a hibaüzenetek általában a felhasználóknak nem mondanak semmit. A hibaellenőrző operátort a függvénynév elé kell tenni.

Operátorok Műveleti sorrend new [
! ~ (int) (double) (string) (array) / % + - . << >> < <= > >= == != === !== & ^ |

Operátorok Műveleti sorrend && || ?:
= += -= *= /= .= %= &= |= ^= ~= <<= >>= print and xor or ,

Vezérlési szerkezetek
Az eddig bemutatott kódokban az utasítások mindig sorban egymás után végrehajtódtak, és a program mindig ugyanazt az eredményt adta. Ez a szekvenciális végrehajtás nem biztosít túl nagy teret a rugalmasságnak. A bonyolultabb programokban lehetőség van feltételek kiértékelésére, és a program ennek megfelelően változtatja viselkedését.

Elágazás Az elágazás teszi lehetővé, hogy a programunk egy adott ponton egy kifejezés logikai értékének megfelelően haladjon tovább. Az elágazásoknak általában három típusa szokott megjelenni a programozási nyelvekben: az egyágú (egyirányú), a kétágú (kétirányú), és a többágú (többirányú).

Az egyágú és a kétágú elágazás
if (kifejezés) { utasítás; } Amennyiben a kifejezés logikai értéke igaz, akkor a zárójelpárok által meghatározott blokk végrehajtódik. A két zárójel elhagyható, ha a blokk egyetlen utasításból ál. Az elhagyás azonban sokszor rontja az átláthatóságot, valamint ha később más utasítást is felveszünk a blokkba, esetleg megfeledkezhetünk a zárójelekről.

<?php $szam=2; if ($szam==2) { print "A szám értéke 2"; } //kiírja, hogy A szám értéke 2 ?> A fenti kódban a $szam változó tartalmát vizsgáljuk. Amennyiben a változó tartalma 2, akkor az if utáni blokkban található utasítás végrehajtódik, egyébként nem tesz semmit a program. Jelen esetben a böngészőben megjelenik ”A szám értéke 2” szöveg. Fontos megjegyezni, bár már volt róla szó, hogy a kifejezés vizsgálatakor a dupla = jelet használjuk a szimpla helyett. Ezek összekeverése súlyos hiba! Amennyiben azt írtuk volna, hogy if ($szam=2), akkor ez mindig az igaz logikai értéket szolgáltatja, ugyanis ilyenkor a $szam változónak értékül adjuk a 2-t (mivel ez mindig sikeres, igaz logikai értéket adunk az if számára).

A kétágú elágazás lehetőséget ad arra, hogy a kifejezés hamis logikai értéke esetén is utasításokat hajtsunk végre. if (kifejezés) { utasítás; } else Ilyenkor a két blokk közül valamelyik fog végrehajtódni.

A következő példaprogramban egy szám reciprokát szeretnénk előállítani majd megjeleníteni, de figyelembe kell vennünk, hogy a nullának nincs reciproka. <?php $szam=2; print "A szám: $szam "; if ($szam!=0) { print "A szám reciproka: "; print 1/$szam; } else print "Nincs reciproka!"; //kiírja, hogy 0.5 ?>

A többágú elágazás Többágú elágazást létrehozhatunk az előbbi kétágú elágazások egymásba ágyazásával, vagy az elseif kulcsszó használatával, és később látni fogjuk, hogy létezik egy külön utasítás is ehhez. Az if-elseif-else szerkezet alakja: if (kifejezés) { utasítás; } elseif (kifejezés) else

A többágú elágazás Ha az első kifejezés logikai értéke hamis volt, akkor program az elseif ágra ugrik, ahol megvizsgálja a második kifejezést, ha ez a logikai igaz, akkor végrehajtja az elseif által meghatározott blokkot, ha a logikai hamis, akkor az else ágra ugorva végrehajtja az else blokkját. Természetesen annyi elseif kulcsszót írhatunk ebbe a szerkezetbe, amennyit csak akarunk. A következő egyszerű példa az if-elseif-else használatát mutatja be.

A többágú elágazás <?php $hom=120;
print "A víz hőmérséklete: $hom °C Halmazállapota: "; if ($hom<0) { print "szilárd"; } elseif ($hom<100) print "folyékony"; else print "gáz"; //kiírja, hogy gáz ?>

A többágú elágazás A switch utasítás is egy lehetséges módja annak, hogy egy kódrészletet egy kifejezés értékétől függően hajtsunk végre. Van azonban néhány különbség az if és a switch között. Az if-et az elseif-el használva több kifejezés értékétől tehetjük függővé, míg a switch esetében a program csak egy kifejezést vizsgál meg, és annak értékétől függően különböző utasításokat hajt végre. A kifejezésnek valamilyen típusnak kell lennie (szám, karakterlánc vagy logikai érték). switch (kifejezés) { case érték1: utasítás1; break; case érték2: utasítás1; break; … default: utasítás; } A case alapszavak után tűntetjük fel az egyes értékeket, és az összes többi lehetséges értéket lefedhetjük a default-tal. A switch úgy működik, hogy ha egy case utáni érték azonos a kifejezés értékével, akkor végrehajtja az összes ez utáni utasítást az ágakon. Emiatt használjuk a break kulcsszót, amely segítségével „kiugorhatunk” a switch-ből.

A többágú elágazás <?php $szam=4; print "A szám: $szam ";
switch($szam) { case "1": print "1-est dobott!"; break; case "2": print "2-est dobott!"; case "3": print "3-ast dobott!"; case "4": print "4-est dobott!"; case "5": print "5-öst dobott!"; default: print "6-ost dobott!"; } //kiírja, hogy 4-est dobott! ?>

A ?: operátor A ?: ternális (háromoperandusú) műveletjel egy olyan if utasításhoz hasonlít, amely értéket is képes visszaadni. A visszaadott értéket a vizsgált feltétel határozza meg: (feltétel) ? érték_ha_a_feltétel_igaz : érték_ha_a_feltétel_hamis; Amennyiben a vizsgált feltétel igaz, a ? és a : közti kifejezés értékét adja, ha hamis, akkor a : utánit. Ehhez kapcsolódó egyszerű példa egy szám abszolútértékét adja meg: <?php $szam=-3; print "A szám: $szam "; $abs=($szam>=0) ? $szam : -$szam; print "Az abszolútértéke: $abs"; //kiírja, hogy 3 ?>

A ciklus A ciklusok segítségével arra is képesek vagyunk, hogy bizonyos programrészeket többször lefutassunk. Általában meg szoktunk különböztetni feltételes és nem feltételes ciklusokat. Nem feltételes ciklus a számláló ciklus, míg a feltételes ciklusokhoz tartozik ez elöl- ill. a hátultesztelő ciklus.

A while ciklus A while ciklus az elöltesztelő ciklus megfelelője a PHP nyelvben. Az elöltesztelő ciklus a kifejezés logikai értékét az ismétlendő rész előtt vizsgálja. A while szerkezete nagyon hasonló az if szerkezetéhez: while (kifejezés) { utasítás; } Amíg a kifejezés igaz logikai értékű, addig a program folytatja a blokk ismétlését. Ebből következik, hogy kell lennie egy olyan utasításnak az ismétlendő részben (vagy maga a kifejezés tartalmazza az utasítást), ami egyszer hamissá teszi a kifejezést, különben végtelen ciklust kapnánk.

A while ciklus <?php $szam=1; while ($szam<=10) { print "A szam változó értéke: $szam "; $szam++; } ?> Ez az egyszerű program 1-től 10-ig kiírja az egész számokat a böngészőbe. A fontos utasítás, amely segítségével majd kilépünk a ciklusból, a 6. sorban található.

A while ciklus A következő kód 10-től kettesével visszafele 1-ig kiírja a számokat és a négyzetüket (az 1-et nem). <?php $szam=10; while ($szam>0) { print "A szam változó értéke: $szam, négyzete: "; print $szam*$szam; print " "; $szam-=2; } ?>

A do ciklus A do ciklus hasonló a while ciklushoz, csupán egyetlen lényegi különbség van: a kifejezés vizsgálata a blokk után történik, ezért is hívják hátultesztelő ciklusnak. Ebből következik, hogy egyszer mindenképpen végrehajtódnak a blokkban található utsítások, még ha hamis is kezdetben a kifejezés logikai értéke. do { utasítás; } while (kifejezés);

A do ciklus <?php $szam=1; do { print "A szam változó értéke: $szam, négyzete: "; print $szam*$szam; print " "; $szam+=2; } while ($szam<=10); ?> Megjelenik 1-től indulva a szám és négyzete kettesével egészen 9-ig!

A for ciklus A for ciklust szokták számláló ciklusnak hívni, ám ez a szerkezet a PHP-ben sokkal általánosabb, mint például a Pascal vagy a Basic nyelvekben. A for a while-hoz képest rövidebb leírást és biztonságosabb használatot eredményez. A for ciklus általános alakja: for (kifejezés1;kifejezés2;kifejezés3) { utasítás; } A for ciklust könnyen while ciklussá írhatjuk át, így az előbbivel egyenértékű while ciklus: kifejezés1; while (kifejezés2) kifejezés3; A kifejezések közül bármelyik elhagyható, így végtelen ciklust a legkönnyebben az összes elhagyásával csinálhatunk: for (;;)

A for ciklus <?php for ($szam=1;$szam<=10;$szam+=2) { print "A szam változó értéke: $szam, négyzete: "; print $szam*$szam; print " "; } ?> A 2. sorban először kezdőértéket adunk a $szam változónak (ciklusváltozó), majd megadjuk a ciklusban maradás feltételét, végül megadunk egy utasítást, ami később majd a ciklus befejeződését váltja ki.

A for ciklus For ciklusok egymásba ágyazása
<?php for ($i=1;$i<5;$i++) { for ($j=1;$j<4;$j++) print "Az i változó értéke: $i"; print ", a j változó értéke: $j "; } ?> Ennél a példánál két ciklusunk van, két ciklusváltozóval ($i és $j). A futtatás után jól látszik, hogy az ilyen egymásba ágyazott ciklusoknál a külső ciklus ciklusváltozója egy értékénél a belső ciklus ciklusváltozója fölveszi az összes lehetséges értéket.

A break utasítás A break utasítással elhagyható (befejezhető) a while, do, for ciklus. <?php for ($szam=1;$szam<=10;$szam+=2) { if ($szam*$szam>50) break; print "A szam változó értéke: $szam, négyzete: "; print $szam*$szam; print " "; } ?> A 4. sorban meghatározzuk, hogy ha az adott szám négyzete nagyobb lenne, mint 50, akkor fejezzük be a ciklust.

A continue utasítás A continue utasítás segítségével a vezérlő kifejezések kiértékelésére kényszeríthetjük a while, do, for ciklust (a következő ismétlés azonnali elkezdésére kényszerítjük a ciklust). <?php for ($i=1;$i<6;$i++) { for ($j=1;$j<5;$j++) if ($j==2) continue; print "Az i változó értéke: $i"; print ", a j változó értéke: $j "; } ?> Mivel a continue a belső ciklusban található, így arra érvényes. Amikor a $j változó értéke 2, nem hajtódnak végre a continue után található print utasítások, hanem a következő ismétlésre ugrunk (azaz a $j 2 értéke sosem jelenik meg a böngészőben).

Függvények Előfordulhat, hogy egy probléma megoldására célszerű a feladatot önállóan is értelmes részekre bontani, majd ezeket tovább elemezve újabb, egyre elemibb egységekbe tagolni, amelyek megoldása már korábbról ismert, azaz ismert programozási szabályok vagy hozzá hasonló algoritmusok segítségével megvalósítható. Az is többször előfordul, hogy a feladat többször is felhasznál ilyen elemi részt. Amennyiben minden esetben ezt le kellene írnunk, akkor a programunk rendkívül terjengőssé válna, ezért kézenfekvő megoldás lenne, ha az ilyen részek nevet kaphatnának, ekkor csak a nevükre kellene hivatkozni. Az önállóan értelmes részfeladat megoldását végző algoritmust eljárásnak nevezzük.

Függvények Sokszor előfordul, hogy az eljárással egyetlen értéket határozunk meg, amelyet célszerű lenne a matematikai függvények mintájára kezelni. Ez azt jelenti, hogy olyan speciális eljárásokat kell létrehoznunk, amelyek a meghívást követően egyetlen, jól meghatározott típussal rendelkező értéket szolgáltatnak, olyan módon, hogy ezt az értéket az eljárás azonosítója hordozza. A közönséges eljárásoktól való megkülönböztetés céljából az előbbi tulajdonsággal rendelkező, önállóan értelmes algoritmusrészeket nevezzük függvénynek. Amennyiben a függvény nevére hivatkozunk, a függvényt meghívjuk, azaz a függvény törzse lefut. A függvénynek feldolgozás céljából értékeket adhatunk át, amikor pedig a függvény véget ér, a hívónak egy értéket ad vissza.

Függvények Az előző fejezetekben már láttunk példákat a függvényekre, a függvényhívásra. Ilyen volt például a print("Hello, World!");. A függvényhívásnál a függvény neve után zárójelek között (a print ebből a szempontból kivételes, zárójelei elhagyhatók) a függvény bemenő paramétereit soroljuk föl vesszővel elválasztva (azokat az adatokat, amiket átadunk a függvénynek). A függvényeknek általában van visszatérési értéke is, melyet a hívónak visszaad, például a print() visszatérési értéke logikai érték, azaz arról informál minket, hogy sikeres volt –e a függvény végrehajtása.

Függvények létrehozása, az érték szerinti paraméterátadás
A függvények létrehozásához a function kulcsszót kell használnunk: function fuggvenynev(formális paraméterek) { utasítás; } A fuggvenynev azonosító szerepet tölt be, így két egyforma nevű függvény nem lehet egy PHP programban, valamint betűt, számot, és az _ jelet tartalmazhat, de számmal nem kezdődhet. A formális paraméterek azok a paraméterek, melyekkel a függvény le van írva, a hívás során ezek helyére az aktuális paraméterek kerülnek.

Paraméter nélküli függvény <?php function koszon() //a koszon függvény definiálása { print "Üdvözlöm!"; } koszon(); //a koszon függvény meghívása ?>

Paraméterrel rendelkező függvény <?php function koszont($kit) //függvény definiálása egy paraméterrel { print "Üdvözlöm, $kit! "; } koszont("István"); //a koszont függvény meghívása $ki="Géza"; koszont($ki); //a koszont függvény meghívása $ki="Ferenc"; ?> A fenti példában a függvényt meghívtuk konstans értékkel, és úgy, hogy a PHP a változó tartalmát helyettesítette be.

Értékek visszaadása A függvényeknek visszatérési értéke is lehet (az olyan függvényt, amelynek nincs visszatérési értéke, eljárásnak szoktunk nevezni), ehhez a return utasítást fogjuk használni. A return befejezi a függvény futtatását, és az utána írt kifejezést küldi vissza a hívónak. A következő példaprogram két szám átlagával tér vissza:

<?php function atlag($egyik,$masik) { $atlag=($egyik+$masik)/2; return $atlag; } $szam1=2; print "Az első szám: $szam1 "; $szam2=5; print "A második szám: $szam2 "; print "A két szám átlaga: "; print atlag($szam1,$szam2); //az atlag függvény meghívása (az atlag által visszaadott érték kiíratása) print " "; print "A 6 és a 8 átlaga: "; print atlag(6,8); //az atlag függvény meghívása konstans paraméterekkel: kiírja, hogy 7 ?>

Cím szerinti paraméterátadás
Az eddigi programjainkban paramétereket csak érték szerint adtunk át, ami azt jeleni, hogy a paraméterek értékeit felhasználni tudja csak a függvény, megváltoztatni nem. Mit tehetünk akkor, ha azt szeretnénk, hogy a bemenő paraméterek értékei is megváltozhassanak? Ehhez használnunk kell az & (hivatkozó) operátort. Az alábbi program feladata, hogy felcserélje a paraméterként megadott két változó tartalmát.

Cím szerinti paraméterátadás
<?php function csere(&$egyik,&$masik) { $seged=$masik; $masik=$egyik; $egyik=$seged; } $szam1=2; print "Az első szám: $szam1 "; $szam2=6; print "A második szám: $szam2 "; csere($szam1,$szam2); print "Csere után:"; print " "; print "Az első szám: $szam1 "; //kiírja, hogy 6 print "A második szám: $szam2"; //kiírja, hogy 2 ?> Az egyetlen dolog, amit tennünk kellett, hogy a két formális paraméter elé beszúrtuk a & jelet (2. sor).

Változó számú paraméterek
Előfordulhat, hogy nem tudjuk hány paraméter kerülhet egy függvénybe. A PHP lehetővé teszi, hogy megállapítsuk, hány paramétere van a függvénynek, és ennek megfelelően használjuk. A függvényben a paraméterek kezelésére a func_num_args(), a func_get_arg(), és a func_get_args() függvényeket használhatjuk. Az első megadja a paraméterek számát, a második az adott sorszámú paramétert (0-tól sorszámozva), a harmadik pedig egy tömbbe rendezi az összes paramétert. Nézzünk erre egy kicsit bonyolultabb példát:

<?php function voros() { $szoveg=""; $paramszam=func_num_args(); //a paraméterek számának tárolása for ($i=0;$i<$paramszam;$i++) $szoveg.=func_get_arg($i)." "; //a paraméterek összefűzése } return print "$szoveg"; //a kapott sztring megjelenítése vörös színnel voros("Ez egy vörös színű sor","Ez is","Meg ez is"); //a függvény meghívása ?>

Ebben a példában már felhasználtuk a korábban megismert ”.” és ”.=” operátorokat. A $szoveg változó kezdetben az üres sztringet tartalmazza (4. sor), majd miután letároltuk a paraméterek számát a $paramszam változóba (5. sor), hozzáfűzzük a soron következő paraméter tartalmát az előzőekhez és közéjük az új sor tag-et (8. sor) egy for ciklus segítségével. Ami még magyarázatra szolgál, hogy a 10. sorban miért került a red ”-ei elé egy \ jel. Erre azért van szükség, mert a PHP úgy venné, hogy ott kezdődik egy sztring vagy ott van vége. A \ jel és utána leírt karaktereket vezérlőkaraktereknek hívjuk. A $ jelet például csak úgy írathatjuk ki, hogy \$-t írunk a print-be, ellenkező esetben a PHP egy változót keresne a kiíráshoz. Akkor is működőképes programot kapunk, ha a tag-ekben a " jeleket egyszerűen elhagyjuk.

Elhagyható paraméter Megtehetjük azt is, hogy egy formális paraméternek értéket adunk a függvény paraméterlistájában, és ekkor a paraméter a függvény hívásánál elhagyható lesz, a PHP azzal értékkel fog dolgozni, amit a paraméterlistában megadtunk. Ha viszont a hívásnál értéket adunk, akkor lecserélődik a listában megadott arra, amivel hívunk. Ezt mutatja be a következő kód: <?php function kiir($mit,$meret,$szin="red") { return print "$mit "; } kiir("Ez egy 4-es méretű, kék színű szöveg.",4,"blue"); //a függvény meghívása kiir("Ez egy 3-as méretű, vörös színű szöveg.",3); //a függvény meghívása ?>

Hatókör Amikor a hatókör kifejezést függvényekkel és változókkal kapcsolatban használjuk, arra gondolunk, hogy a kód mely részében látjuk ezeket az elemeket, és mely részében lehet használni őket. A PHP-ben a hatókör szabályai: A függvény paraméterlistájával bevitt változók lokális változók, kivéve, ha & jel van előttük. A függvényen belül definiált változók lokális változók, kivéve, ha a global kulcsszót eléjük írtuk a definiáláskor. A függvényen kívül definiált változók nem érhetők el a függvényen belül, kivéve, ha paraméterként vittük be őket a függvénybe, vagy ha a global utasítással definiáltuk őket. A define() utasítással definiált konstansok mindig globálisak, függetlenül attól, hogy a függvényen belül vagy kívül definiáltuk őket. A függvények mindig globálisak, így egy másik függvény belsejében definiált függvény mindenhol elérhető.

Hatókör A global kulcsszó használata: <?php
function csere($egyik,$masik) { global $seged; $seged=$masik; $masik=$egyik; $egyik=$seged; } csere(6,2); print "A segédváltozó tartalma: "; print $seged; //kiírja, hogy 2 ?> A global alapszót itt arra használtuk, hogy a függvény belsejében definiált változót a függvényen kívül is elérjük. Ha a függvényen kívül definiálunk egy változót, amit a függvényen belül szeretnénk használni, akkor a változó definiálásakor szintén ki kell tennünk a global kulcsszót.

Statikus változók Lehet a kódunkban egy olyan függvény, amelyet többször használunk, és minden használatnál továbbítania kell egy értéket a következőnek. Ezt meg lehetne oldani egy globális változó segítségével, de ennél egyszerűbb és logikusabb megoldás, ha statikus változót használunk. Nézzünk egy példát, amely egyszerűen kiírja a függvényhívások számát: <?php function kiir() { static $szam=0; $szam++; print "Függvényhívások száma: $szam "; } kiir(); //kiírja, hogy a Függvényhívások száma: 1 kiir(); //kiírja, hogy a Függvényhívások száma: 2 ?>

Statikus változók Ez egy nagyon egyszerű példa a static használatára, nézzük, hogy a static nélkül mit kellett volna tennünk: <?php $szam=0; function kiir() { global $szam; $szam++; print "Függvényhívások száma: $szam "; } kiir(); //kiírja, hogy a Függvényhívások száma: 1 kiir(); //kiírja, hogy a Függvényhívások száma: 2 ?>

PHP függvények A következő részekben a PHP függvényei közül a fontosabbak kerülnek megemlítésre egy kis magyarázat mellett. A PHP összes függvényének leírása egyrészt nagyon terjedelmes lenne, másrészt nem is cél, a PHP dokumentáció folyamatos böngészése ajánlott.

Matematikai függvények
Eredmény Függvény Leírás $integer_or_float = abs($int_or_float) Abszolútértékét adja. $float = acos($float) A szög arkusz koszinuszát adja radiánban. asin($float) A szög arkusz szinuszát adja radiánban. atan($float) A szög arkusz tangensét adja radiánban. atan2($float_l, $float_2) A két változó arkusz tangensét adja. cos($float) A radiánban meghatározott szög koszinuszát adja. exp($float) Az e-t a $float hatványára emeli. lcg_value() Kombinált lineáris kongruencia generátor. log($float) A $float természetes logaritmusát adja. $float= log10($float) A $float 10-es alapú logaritmusát adja.

$value = max($array) A tömbben levő maximális értéket adja. max($value_l, $value_2 ... $value_n) A paraméterlistában levő maximális értéket adja. min($array) A tömbben levő minimális értéket adja. min($value_l, $value_2 ... $value_n) A paraméterlistában levő minimális értéket adja. $string = number_format($float, $decimal_places, $decimal_point, $decimal_separator) A tizedesjel és az ezreseket elválasztó karakter használatával megformáz egy számot. $float = pi() A pi értékét adja 13 tizedes pontossággal. pow($floatx, $floaty) A $floatx-et a $floaty-dik hatványra emeli. sin($float) A radiánban meghatározott szög szinuszát adja. sqrt($float) A $float négyzetgyökét adja. tan($float) A radiánban meghatározott szög tangensét adja.

A PHP-ben az egész és lebegőpontos matematikán kívül létezik a tetszőleges pontosságú matematika is. Ez egy olyan matematika, ahol mi határozhatjuk meg a szükséges pontosságot. A szoftver, jelen esetben a BCMath, valamilyen módon mindig megbirkózik a nagy számokkal, legfeljebb bizonyos műveletek tovább tartanak. A dokumentációban a függvény referencia címszó alatt megtalálhatók ezek a függvények (mindegyik neve bc-vel kezdődik). A PHP ezen kívül támogatja a korlátlan hosszúságú egészekkel való számolást is. A GMP, vagy GNU MP egy nyílt forráskódú matematikai csomag, amely beillesztésével szintén tetszőleges pontosságú aritmetikai függvényekhez juthatunk, amelyekkel előjeles egész, racionális és lebegőpontos számokon lehet műveleteket végrehajtani. A csomag letölthető a címről.

Dátum- és időfüggvények
A PHP több dátum- és időfüggvényt tartalmaz, mint a legújabb csúcstechnológiájú karóra. A lenti táblázat a dátum és idő kiszámításához szükséges függvényeket tartalmazza, a többi számítást ezekből a függvényekből kapott eredményekkel, illetve ezen eredmények átalakításával lehet elvégezni.

Dátum- és időfüggvények
Leírás checkdate() Ellenőrzi, hogy a Gergely-naptár szerinti dátum helyes –e. date() A helyi dátumot és időt formázva adja vissza. getdate() A helyi dátumot és időt tömbként adja vissza. gettimeofday() Az aktuális időt tömbként adja vissza. gmdate() Ugyanaz, mint a date(), de a helyi idő helyett a GMT-t haszanálja gmmktime() A dátumot Unix-időjelzésre konvertálja. gmstrftime() A GMT dátumot és időt formázza. localtime() A helyi időt tömb elemeiként adja. microtime() A Unix-időjelzést a másodperc törtrészével adja vissza. mktime() A Unix-időjelzést adja vissza egy dátumból. strftime() Ugyanaz, mint a gmstrftime(), csak a helyi időt használja. time() Unix-időjelzést ad vissza. strtotime() A szöveges dátumot/időt Unix-időjelzésre konvertál.

Sztringfüggvények A sztringfüggvényekkel dolgozni a PHP-ban egyrészt szórakoztató dolog, másrészt az adatkezelésnek egy hasznos módja. A legtöbb sztringfüggvény bináris adatokat kezel, a PHP azonban elvégzi a szükséges konverziókat. A fontosabb sztringfüggvények leírását láthatjuk a következő táblázatokban:

Sztringfüggvények Eredmény Függvény Leírás $string =
$addslashes($string) Visszaper jeleket ad az idézőjelekhez, kétszeres idézőjelekhez, visszaper jelekhez és az üres karakterekhez, így a sztringet SQL-ekkel be lehet szúrni adatbázisba. bin2hex($string) Az input sztring bináris adatának hexadecimális megjelenítését adja vissza. chop($string) Eltávolítja a szóvégén álló szóközöket, így a szóközöket, \r, \n, \t és chr(13) karaktereket. chr($integer) A szám ASCII karakterkészletbeli megfelelőjét adja (az ord() ellentétje). $array = count_chars($string, $mode) Egy tömböt ad vissza, mely a sztring egyes karaktereinek gyakoriságát tartalmazza. A $mode opcionális és ellenőrzi, hogy mi van számolva. crc32($string) A sztring CRC32 értékét számolja ki. crypt($string, $key) Egy opcionális kulcs használatával DES eljárással rejtjelez egy sztringet. echo($string) Egy vagy több sztringet írat ki, hasonló a print()-hez.

Sztringfüggvények $array = explode($separator, $string)
Tömböt hoz létre a sztringből a $separator egyes előfordulásainál szétvágva azt. get_meta_tags ($file_name) A megnevezett fájl meta tag tartalmát adja tömbben vissza. $string = htmlentities($string) A<, >, ', ^, & és a nehezen megjeleníthető karaktereket HTML-elemekre konvertálja. htmlspecialchars($string) A <, >, ', ", és & karaktereket HTML-elemekre konvertálja. implode($separator, $array) A tömb elemeket egyesítve sztringet hoz létre. Az explode() ellentétje. levenstein($string_1, $string_2) A két sztring közötti Levenstein-távolságot számítja ki, ami az egyezőség mértéke. ltrim($string) Levágja a szóközöket, \n, \r, \t, \v és \0 karaktereket a sztring elejéről. md5() A sztring MD5-típusú digitális kivonatát adja vissza. nl2br($string) A sztringben az összes newline (\n) elé HTML sortörést ( ) szúr be. $integer = ord($string) A karakter ASCII értékét adja vissza (a karakter karakterkészleten belüli ordinális számát adja vissza),

Sztringfüggvények $boolean = print($string)
Egy sztringet írat ki, siker esetén igazat, hiba esetén hamisat ad vissza. printf($format, $variables) A $format sztringgel formázott változókat írja ki. $array = sscanf($string, $format) Egy tömböt ad vissza, melynek az értékei a $format használatával kerültek be a sztringből. $integer = strcasecmp($string_l, $string_2) Bináris-biztos, a kis-és nagybetűket nem megkülönböztető sztring összehasonulást végez el. 0-t ad vissza, ha $string_l == $string_2, -1-et, ha $string_l < $string_2, vagy 1-et, ha $string_l > $string_2. strncasecmp($string_l, $string_2, $length) A strcasecmp() változata, mely a sztringeket a $length által megadott hosszúságig hasonlítja össze. strcmp($string_l, $string_2) A strcasecmp() kis és nagybetűket megkülönböztető változata. $string = strip_tags($string, $tags) Eltávolítja a sztringből a HTML tag-eket a $tags-ben felsoroltak kivételével. stripcslashes() Az addcslashes()-sel hozzáadott visszaper jeleket távolítja el. stripslashes() Az addslashes()-sel hozzáadott visszaper jeleket távolítja el. Ha addslashes()-t használunk, majd ezt követően MySQL-ben tároljuk az adatokat, a MySQL eltávolítja a visszaperjeleket és használatra kész adatokat ad vissza. stristr($search, $string) A strstr() kis- és nagybetűket megkülönböztető változata.

Sztringfüggvények $integer = strlen($string)
A sztring hosszát adja vissza. $string = str_pad($string, $length, $pad, $mode) A szóközökkel a $length mértékben jobbra igazított sztringet adja vissza. Ha az opcionális $pad sztring meg van adva, akkor azt használja a szóközök helyett. Az opcionális $mode-dal választhatunk az igazítások közül. strpos($string_l, $string_2) A $string_l-el adja vissza a $string_2 pozícióját. strrchr($string, $char) A $string-ből az utolsó $char utáni sztringet adja vissza. str_repeat($string, $integer) Olyan sztringet ad vissza, amely a bemeneti sztringet $integer alkalommal tartalmazza. $string= strrev($string) A sztringet fordított karaktersorban adja vissza. strrpos($string, $char) A $string-ben levő utolsó $char pozícióját adja vissza. strspn($string, $char) A $string első részét adja vissza, amely csak a $char-ban levő karaktereket tartalmazza. strstr($search, $string) A $search-nek a $string-en belüli első előfordulásának pozícióját adja vissza. strtok($string, $separator) A $separator-nál elválasztja a sztringet és egyszerre egy szakaszt ad vissza.

Sztringfüggvények $string = strtolower($string)
Kisbetűsre konvertálja a sztringet. strtoupper($string) Nagybetűsre konvertálja a sztringet. str_replace($find, $replace, $string) A $string-ben a $find összes előfordulását $replace-re cseréli. strtr($string, $from, $to) A sztringben a karaktereket $from-ról $to-ra fordítja. substr($string, $start, $length) A sztring $start-tól kezdődő $length hosszúságú részét adja vissza. Ha a $length nincs meghatározva, akkor a $start-tól sztring végéig halad. $integer = substr_count($string, $char) A $string-ben levő $char előfordulásának számát adja vissza. substr_replace($string, $replace, $start, $length) Egy sztringet ad vissza, amelyben a $start-tól kezdődő szöveg a $length hosszúságban a $replace-re van cserélve. Ha a $length nincs megadva, a sztring végéig cseréli. trim($string) Levágja a szóközöket, \n, \r, \t, \v és \0 karaktereket a sztring elejéről és végéről. ucfirst($string) A sztring első karakterét nagybetűssé változtatja. Különösen mondatok formázásánál hasznos. ucwords($string) Minden szó első karakterét nagybetűssé változtatja. Fejezetcímek formázásánál hasznos (bár magyar nyelvben ez nem szokás). wordwrap($string, $length, $char) Newline-okat szúr be a sztringbe úgy, hogy a szöveget a $length-nek megfelelő hosszúságú sorokra töri. Ha a $length nincs megadva, akkor alapbeállításban soronként 72 karakter. Ha a $char meg van határozva, akkor azt szúrja be a newline helyett.

Tömbök Programjaink rugalmasságát a tömbök használata nagymértékben növeli, de vigyáznunk kell, mert néhány csapdát is rejtenek magukban. A PHP-tömböket úgy használhatjuk, mintha a memóriában tárolt mini adatbázisok lennének, hiszen rengeteg függvény áll rendelkezésünkre. Legyenek az adatok szöveges dokumentumokban, nyomtatható fájlokban, XML fájlokban vagy adatbázisokban, betölthetők tömbbe, és feldolgozhatók anélkül, hogy az eredeti fájlba belenyúlnánk. A tömb változók listája. Több változót tartalmaz, amelyeket számok vagy karakterláncok segítségével azonosíthatunk, így a különböző értékeket egyetlen névvel tárolhatjuk, rendezhetjük és érhetjük el.

Tömbök létrehozása Tömböket sokféleképpen létrehozhatunk: függvények és a tömbazonosító segítségével is. Az array() listából hoz létre tömböt, az explode() határolt sztringből, és használhatjuk a szögletes zárójelek között a tömbazonosítót is a tömbelemek értékeinek meghatározására. Az array() függvény és a [ ] használata: Az array() függvény akkor hasznos, ha egyszerre több értéket szeretnénk egy tömbhöz rendelni:

Tömbök létrehozása A PHP-ben a tömb sokkal rugalmasabb, mint néhány programozási nyelvben. A tömböknek bármennyi eleme lehet, bármikor hozzáadhatunk újakat, és az is megengedett, hogy különböző típusú adatok kerülhessenek bele. A fenti példa jól illusztrálja, hogy bármilyen típusú értéket adhatunk a tömb elemeinek (összetett típust is), majd az indexek (sorszámok) segítségével megjeleníthetjük a tömb tartalmát (a sorszámozás 0-val kezdődik). Egy tömb feltöltéséhez, vagy újabb elemek hozzáadásához ugyanúgy használhatjuk a szögletes zárójeleket. A rugalmasság kedvéért még a sorszámot sem kell megadni, a PHP tudja, hogy melyik a soron következő (létezik ugyanis egy ún. tömbmutató).

Tömbök létrehozása <?php $nevek=array("István",32,"Péter");
print $nevek[0]; //kiírja, hogy István print ": ".gettype($nevek[0])." "; //kiírja, hogy string print $nevek[1]; //kiírja, hogy 32 print ": ".gettype($nevek[1])." "; //kiírja, hogy integer print $nevek[2]; //kiírja, hogy Péter print ": ".gettype($nevek[2])." "; //kiírja, hogy string print $nevek[3]; //nem ír ki semmit, mert nincs 4. elem $szamok[]=3.14; //első elem a '3.14' $szamok[]="négy"; //második elem a 'négy' $szamok[]=true; //harmadik elem a 'true', a logikai igaz print $szamok[0]; //kiírja, hogy 3.14 print ": ".gettype($szamok[0])." "; //kiírja, hogy double print $szamok[1]; //kiírja, hogy négy print ": ".gettype($szamok[1])." "; //kiírja, hogy string print $szamok[2]; //kiírja, hogy 1 print ": ".gettype($szamok[2]); //kiírja, hogy boolean ?>

Asszociatív tömbök Amennyiben a tömbelemeket sorszámozás helyett elnevezzük, asszociatív tömböt kapunk. Tulajdonképpen a PHP-ben minden tömb asszociatív tömb, a számozott adatok is asszociatív adatokként viselkednek. Az elnevezés során csak egy dologra kell ügyelnünk: két egyforma nevet nem adhatunk, mert ekkor nem tudnánk egyértelműen azonosítani őket, ezért ezt a nevet kulcsnak hívjuk. Az asszociatív tömbök létrehozásához ugyanúgy használhatjuk az array() függvényt és a szögletes zárójeleket is:

Asszociatív tömbök <?php
$szemely=array("nev"=>"István", "szulido"=>" ", "szulhely" =>"Keszthely"); print $szemely["szulido"]; //kiírja, hogy print " "; $egyen["nev"]="István"; $egyen["szulido"]=" "; $egyen["szulhely"]="Keszthely"; print $egyen["szulido"]; //kiírja, hogy ?>

Többdimenziós tömbök Ebben a fejezetben már volt szó arról, hogy összetett típus is lehet egy tömb eleme, így lehet tömb és objektum is. Ez a lehetőség kifinomultabb adatszerkezeteket biztosít számunkra. A többdimenziós tömb azt jelenti, hogy a tömb elemei tömbök. A PHP-tömbök bármennyi dimenziót elfogadnak, és az egyes dimenziók bármennyi elemet tartalmazhatnak. Valójában az a helyzet, hogy előbb futunk ki a memóriából, mint elérnénk a PHP korlátjait. Persze más probléma is lehet, ha túl sok dimenzióval dolgozunk: egy idő után nem fogjuk már átlátni az egészet. Ezért erősen javasolt, hogy három dimenzió fölött ne próbálkozzunk, és abban is biztosak lehetünk, hogy kevesebb dimenziószámmal is meg lehet oldani a feladatot. A többdimenziós tömbök létrehozása:

Többdimenziós tömbök <?php $tablazat=array ( array(2,3,4),
); print $tablazat[0][2]; //kiírja, hogy 4 print " "; print $tablazat[1][1]; //kiírja, hogy 5 $szemelyek=array //asszociatív tömbök tömbje array "nev"=>"István", "szulido"=>" ", "szulhely"=>"Keszthely" ),

Többdimenziós tömbök array ( "nev"=>"Béla",
"szulido"=>" ", "szulhely"=>"Zalaegerszeg" ) ); print $szemelyek[0]["nev"]; //kiírja, hogy István print " "; print $szemelyek[1]["szulhely"]; //kiírja, hogy Zalaegerszeg ?>

A tömbmutató A tömbmutató csak néhány nyelvben áll rendelkezésre, és a PHP-ben található az egyik legjobb megvalósítása. A tömbmutató segít meghatározni, hogy hol vagyunk, amikor egy tömbben mozgunk. Több függvény is támogatja a tömbmutatót, hogy segítse a tömbben való mozgást. A reset() a tömb elejére állítja vissza a tömbmutatót. Ezt akkor célszerű használni, amikor egy ismeretlen állapotú tömbön kell végigmenni (azaz nem tudjuk, hogy hol áll benne a mutató). Amikor egy tömböt adunk át egy függvénynek, az alapértelmezésben értékként történik, így egy másolatot kap a tömbről, aminek az elején áll a tömbmutató. Ha viszont hivatkozással adjuk át, akkor a tömb az eredeti mutatót tartja meg, ami lehet, hogy ismeretlen pozícióban van. A mutató aktuális helyzetét a current() függvénnyel kérdezhetjük le, a next() a következőre léptet, a prev() az előzőre, míg az end() a tömb utolsó elemére állítja a tömbmutatót. Az each() függvény megadja az aktuális elem kulcsát és értékét, és átviszi a mutatót a következő adatra. Ennek segítségével bejárhatjuk a tömböt felhasználva egy while ciklust (a bejárás előtt azonban meg kell győződni arról, hogy a tömb elején van a mutató).

Tömbök bejárása Egydimenziós tömbök bejárása:
A tömbök bejárása történhet az előbb említett each() függvény segítségével, de a PHP-ben nemrég bevezettek erre egy külön ciklustípust is. A következőkben ezek használata látható: <?php $felhasznalok=array ("István", "Géza", "Béla"); $felhasznalok[5]="Kismalac"; foreach ($felhasznalok as $egyen) { print"$egyen "; } ?> A ciklus a foreach() (4. sor). Később látni fogjuk, hogy ezt lehet többdimenziós tömböknél is használni. Ennél a példánál megadtuk a $felhasznalok tömböt paraméterként a ciklusnak, majd az as kulcsszóval jelöltük, hogy a tömbelemek értékeit rendre a $ertek változóba szeretnénk megkapni. Ezután a ciklusmagban már csak a $ertek változó tartalmát kell kiíratni.

Tömbök bejárása Van itt még egy érdekes dolog: A tömbünk először három elemet tartalmaz (0,1,2 sorszámokkal), később hozzáadunk egy újat, aminek a sorszámát 5-re állítunk be. Ez azt jelenti, hogy ez a 6. elem, így nincs 4. és 5. elem. A PHP nem fog üres helyet hagyni, azaz a nem létező elemekre nem pazarol üres helyet (ebből látszik, hogy valójában a sorszámozott tömb is asszociatív tömb). Pontosan emiatt létezik a foreach() és az each() utasítás, mivel ezek a tömbmutatót használják fel, így nem lehet probléma a bejárással, a ”Kismalac” is megjelenik a böngészőben (ha for ciklust használtunk volna, mint ahogy sok nyelvben ezzel járjuk be a tömböket, indexproblémák merültek volna fel).

Tömbök bejárása Az asszociatív tömbök bejárása: <?php
$szemely=array("nev"=>"István","szulido"=>" ", "szulhely"=>"Keszthely"); foreach ($szemely as $kulcs=>$ertek) { print "$kulcs=$ertek "; } reset($szemely); while (list($kulcs,$ertek)=each($szemely)) print $kulcs.": ".$ertek." "; ?>

Tömbök bejárása A 3. sorban a ciklusnál módosítanunk kellett, itt a kulcs alapján jelenítjük meg az értéket. Ebben a példában a list() függvény minden egyes értéket külön változóban ment el (8. sor, a kulcs és az érték is változókba kerülnek), így megkönnyíti az eredmények feldolgozását. Az each()-et a nem asszociatív tömbökön alkalmazva a kulcsok megfelelnek az elemek sorszámainak. Ha a tömb többdimenziós, akkor a $ertek változó egy tömb lesz, amit teljesen hasonlóan lehet bejárni.

Műveletek tömbökkel Eredmény Függvény Leírás $array =
array_flip($array) Átvált az értékek és a kulcsok között. array_merge($array_1, $array_2) A két megadott tömböt egyesíti. array_pad($array, $integer, $value) A tömböt feltölti annyi darab $value-vel, hogy a tömb elemszáma $integer legyen. $value = array_pop($array) A tömb utolsó elemét törli, majd az elem értékével tér vissza. $integer = array_push($array, $value_1, $value_2, … $value_n) A tömbhöz hozzáfűzi a megadott értékeket, és a tömb elemszámával tér vissza. array_rand($array) A tömb egy elemét véletlenszerűen kiválasztja, majd az indexével tér vissza. array_shift($array) Eltávolítja a tömb első elemét, és annak értékével tér vissza. array_slice($array, $index_1, $index_2) Tömböt hoz létre az első indextől kezdve a másodikig a megadott tömb elemeinek értékéből. Ha a második indexet nem adjuk meg, akkor a végéig nézi. count($array) A tömbben lévő elemek számát adja meg. file($file_name) A $file_name-mel megadott fájl tömbbe olvasása. $boolean = is_array($variable) Egy változóról megmondja, hogy tömb –e. range($index_1, $index_2) Tömböt hoz létre az első indextől kezdve a másodikig a kulcsokból (kulcstartomány kijelölése). shuffle($array) A tömb elemeinek véletlen sorrendbe rendezése.

Tömbök rendezése A PHP-tömböket az alábbi lehetőségek szerint rendezhetjük függvények segítségével: érték szerint kulcs szerint abc-sorrendbe számos természetes és speciális sorrendbe

Tömbök rendezése Függvény Leírás sort($array)
Tömb rendezése érték szerint. asort($array) Asszociatív tömb rendezése érték szerint. rsort($array) Tömb érték szerinti fordított sorrendbe rendezése. arsort($array) Asszociatív tömb érték szerinti fordított sorrendbe rendezése. ksort($array) Asszociatív tömb kulcs szerinti rendezése. natsort($array) Tömb érték szerinti természetes rendezése. usort($array) Tömb nem természetes rendezése.

Objektumok Az objektumok a változókhoz hasonlóan adatokat tárolhatnak, ezeket az adatokat az objektumok adattagjaikban (tulajdonságaikban) tárolhatjuk. Képzeljünk el egy objektumot, amely egy személy adatait tartalmazza, az objektum adattagjai ebben az esetben a személy neve, lakcíme és telefonszáma lehetnek. Ezzel semmi újat nem mondtunk még, hiszen erre a feladatra egy asszociatív tömb is tökéletesen megfelel. Az objektumok viszont tagfüggvényeket (metódusokat) is tartalmazhatnak. Ezek olyan függvények, amelyek az objektum adataival dolgoznak. Az előbbi példánál maradva, az objektum tartalmazhat egy megjelenit() metódust, amely a személy adatait jeleníti meg.

Objektumok Az objektum-orientált (objektumközpontú) programozás (OOP) a természetes gondolkodást, cselekvést közelítő programozási mód, amely a programozási nyelvek tervezésének következetes fejlődése következtében alakult ki. Az így létrejött nyelvek sokkal strukturáltabbak, sokkal modulárisabbak és absztraktabbak, mint egy hagyományos programozási nyelv. Az objektum-orientált nyelveket három fontos dolog jellemez: Egységbezárás (encapsulation): az adatstruktúrákat (adattagokat) és az adott struktúrájú adatokat kezelő függvényeket (tagfüggvényeket) kombináljuk, azokat egységként kezeljük, és elzárjuk őket a külvilágtól. Az így kapott egységeket objektumoknak nevezzük. Az objektumok megfelelő tárolási egysége az osztály (class). Például, készítünk egy kör objektumot, amely maga képes elvégezni mindent, amit egy körrel megtehetünk, akkor ebbe beletartozik a kör adatainak - sugár és középpont - nyilvántartása, de ki kell tudnia számítani például más adatokból a sugarat, vagy éppen kirajzolni a kört. Tehát egy „csomagot” készítünk, amelybe mindent beleteszünk, ami szükséges.

Objektumok Öröklés (inheritance): az adott, létező osztályokból újabb osztályok származtathatók, az öröklés során pedig az osztályok öröklik a szülő-osztály adatstruktúráit és függvényeit, ugyanakkor új tulajdonságokat és metódusokat definiálhatnak, vagy újraértelmezhetnek, így egy osztályhierarchiához jutunk. Például, a körből gömböt készíthetünk, hiszen a gömb rendelkezik a kör minden jellemzőével, csak eggyel több dimenziója van. Többalakúság (polymorphism): egy adott metódus azonosítója (neve) ugyanaz lehet egy osztályhierarchián belül, ugyanakkor a hierarchia minden egyes osztályában a tevékenységet megvalósító függvény az osztályra nézve specifikus. Például, tegyük fel, hogy különböző alakzataink vannak, háromszögek, négyzetek és körök. Ekkor a sokalakúság segítségével általában minden alakzattal képesek leszünk dolgozni. A terulet() tagfüggvény az alakzathoz alkalmazkodva ki tudja majd számítani annak területét.

Objektumok Újrahasznosíthatóság (reusing): miután készítettünk egy osztályt, újra és újra felhasználva több objektumot gyárthatunk belőle. Az öröklés és a sokalakúság segítségével olyan eljárásokat készíthetünk, melyeket többször, többféleképpen is használhatunk, nem kell újra és újra ellenőrizni a működés részleteit. Az osztály tehát egy később készítendő elem meghatározása, a szóban forgó elem pedig az objektum. Gyakori példa ezek megkülönböztetéséhez a süteményforma és a sütemény. A süteményforma meghatározza a süti alakját, de önmaga nem sütemény (még csak nem is ehető), csak egy eszköz, amellyel süteményeket készíthetünk. Használatakor biztosak lehetünk abban, hogy a sütik egyformák lesznek, és nem fog elkopni, akármennyi süteményt is készítünk. A süteményformához hasonlóan az osztállyal is több objektumot készíthetünk, így ha van például egy kör osztályunk, akkor ezzel számos kört létrehozhatunk.

Objektumok Az objektum az osztály egy példánya, vagyis egy objektum nem más, mint az osztályban rögzített működési szabályok megtestesülése. Egy adott típusú objektum a new kulcsszó után írt objektumtípus nevének segítségével testesíthető meg. Amikor egy objektumpéldány létrejön, összes tulajdonsága és tagfüggvénye elérhetővé válik. A PHP 4-es verzióját még nem igazán az objektum-orientált programozásra tervezték. Ugyan rengeteg dolgot tartalmaz, amiről szó volt idáig, mégis vannak olyan részek, melyek megvalósítása még nem megfelelő vagy hiányzik. A PHP 5-ös változata teljesen új OOP lehetőségeket tartalmaz, amelyek sokkal inkább közelebb viszik a PHP-t az objektumorientált nyelvekhez.

Osztályok és objektumok létrehozása
Ahhoz, hogy létre tudjunk hozni egy objektumot, először létre kell hoznunk egy sablont (ez az osztály), ami megmondja pontosan, hogy az objektum milyen tulajdonságokkal fog rendelkezni, valamint hogy mit tehetünk majd az objektummal a tulajdonságait felhasználva. Az osztály létrehozásához a class kulcsszót kell használnunk: class legegyszerubb { } Ennél egyszerűbb osztályt nem lehet készíteni, gyakorlatilag semmit sem tartalmaz. Most már van egy legegyszerubb nevű osztályunk, hogyan készítjük el az osztály példányait? $obj1=new legegyszerubb(); $obj2=new legegyszerubb(); A $obj1 és a $obj2 is tehát egy példánya az osztálynak. A példányosításnál a new kulcsszó után az osztály nevét (azonosítóját) tüntettük fel, valamint tettünk utána zárójeleket. Úgy tűnik, mintha az osztály neve is egy függvény lenne. Erre majd később kapjuk meg a választ a konstruktor részben. Az objektumok típusa az object a PHP-ben, így ha a gettype() függvényt használjuk a $obj1 vagy a $obj2 változókkal, ezt kapjuk.

Adattagok (tulajdonságok)
Az előbbi példában bemutatott osztálynak példányai nem rendelkeztek sem tulajdonságokkal, sem függvényekkel. Hozzunk létre egy olyan osztályt, ami majd hozzárendel tulajdonságokat a példányához: <?php class szemely { var $nev="Péter"; //nev adattag létrehozása (string típusú) var $eletkor=30; //eletkor adattag létrehozása (integer típusú) } $obj=new szemely(); //$obj objektum létrehozása (példányosítás) print "$obj->nev, $obj->eletkor "; //adattagok tartalmának kiíratása $obj=new szemely(); $obj->nev="László"; $obj->eletkor=26; print "$obj->nev, $obj->eletkor"; ?>

Adattagok (tulajdonságok)
A szemely osztályt a 2. sorban definiáltuk, mely két adattagot határoz meg az objektumok számára: nev és eletkor. Az adattagok deklarálásához a var kulcsszót használtuk, majd kezdeti értéket rendeltünk hozzájuk, mint ahogy ez látszik a program 4. és 5. sorában, így a létrehozott objektumok adattagjai felveszik ezeket az értékeket a példányosításkor. Az objektum adattagjait a ”->” operátor segítségével érhetjük el (8. sor), és ennek segítségével értéket is adhatunk nekik (10. és 11. sor).

Tagfüggvények (metódusok)
A metódusok függvények egy osztályban, amelyek műveleteket hajtanak végre egy objektumban. Ezeket a függvényeket tehát az összes példányban elérhetjük és meghívhatjuk. A következő példa a szemely osztályunkat egy tagfüggvénnyel bővíti, melynek segítségével a személy neve megjeleníthető lesz: A tagfüggvényt a 6. sorban definiáljuk, és a 8. sorban a $this-szel a későbbi példányra hivatkozunk. A $this-> segítségével gyakorlatilag az objektumból elérhetjük az objektum bármely részét, így módosíthatjuk az adattagok értékeit, meghívhatunk metódusokat. Egy objektumnak lehet ugyanolyan nevű adattagja, mint tagfüggvénye, a zárójelek segítségével meg tudjuk különböztetni őket.

Tagfüggvények (metódusok)
<?php class szemely { var $nev="Péter"; var $eletkor=30; function nev() //nev tagfüggvény (metódus) létrehozása print $this->nev; //a leendő objektum nev adattagának tartalmát írja ki } $obj=new szemely(); //példányosítás $obj->nev(); //tagfüggvény meghívása: kiírja, hogy Péter $obj->nev="László"; print " "; $obj->nev(); //tagfüggvény meghívása: kiírja, hogy László ?>

Konstruktor A konstruktor fogalma már nem teljesen új, hiszen egy említést már tettünk róla az osztályok és objektumok létrehozása részben. Igen, létrehozható egy olyan függvény, aminek ugyanaz a neve, mint az osztálynak, ezt hívják konstruktornak (constructor). A példányosításnál a konstruktort hívjuk meg (ha nem hoztunk létre az osztályban, a PHP generál egy üreset), azaz ennek a feladata, hogy létrehozza (construct ~ felépít) a példányt. A konstruktornak lehetnek paraméterei, néhány nyelvben az is megengedett, hogy több konstruktort definiáljunk, melyek a bemenő paraméterek számában vagy típusaiban különböznek. A PHP-ben nem lehet két egyforma azonosítójú (nevű) függvényt definiálni, így nem lehet két konstruktort sem, viszont a függvények fejezetben megtanultuk, hogyan kezelhetjük a változó számú paramétereket. A példában ezt használjuk fel:

Konstruktor <?php class szemely { var $nev="Anonymous";
var $eletkor=0; var $cim=""; function szemely() //konstruktor $paramszam=func_num_args(); if ($paramszam>0) $this->nev=func_get_arg(0); if ($paramszam>1) $this->eletkor=func_get_arg(1); if ($paramszam>2) $this->cim=func_get_arg(2); } function nev() print "$this->nev ";

Konstruktor function eletkor() { print "$this->eletkor ";
} function cim() print "$this->cim "; $obj=new szemely(); //konstruktor meghívása paraméter nélkül (példányosítás) $obj->nev(); //kiírja, hogy Anonymous $obj->eletkor(); //kiirja, hogy 0 $obj->cim(); //nem ír ki semmit $obj=new szemely("Kiss László",25,"7624 Pécs, Petőfi u. 14."); //konstruktor meghívása paraméterekkel $obj->nev(); //kiírja, hogy Kiss László $obj->eletkor(); //kiírja, hogy 25 $obj->cim(); //kiírja, hogy 7624 Pécs, Petőfi u. 14. ?>

Konstruktor Az adattagok definiálása a 2. sortól kezdődik, ahol beállítottuk a megfelelő kezdőértékeket, azért, hogy a konstruktor paraméter nélküli hívásánál is mondjon valamit az objektum számunkra. A konstruktor leírása a 7. sortól kezdődik, a paraméterek kezeléséhez felhasználtuk a func_num_args() és a func_get_arg() függvényeket. A komolyabb objektum-orientált nyelvekben az adattagok és tagfüggvények hozzáférési jogait is megadhatjuk. Azokhoz az adattagokhoz, amelyeket privátnak definiálunk, kívülről nem férünk hozzá (csak az objektumból). Ilyenkor minden privát adattaghoz készíthetünk publikus (bárhonnan hozzáférhető) tagfüggvényeket, amelyek segítségével beállíthatjuk és lekérdezhetjük az adattagok tartalmát (általában a beállító metódusok neve a set szóval, míg a lekérdező metódusok neve a get szóval kezdődik).

Konstruktor A PHP-ben nincs ehhez hasonló hozzáférési jogosultság, azaz az adattagok és tagfüggvények bárhonnan elérhetők, de célszerű írni olyan tagfüggvényeket, amelyek segítségével kezelni tudjuk az adattagokat. Az előbbi példában ezért írhattunk volna a nev, eletkor és cim adattagokhoz olyan metódusokat, amelyek segítségével értéküket beállíthatjuk. A konstruktor párja a destruktor (megsemmisítő) az objektum-orientált nyelvekben, feladata az objektum megszűntetése. A PHP-ben nincs destruktor, így ha meg akarunk szűntetni egy objektumot, meg kell írnunk hozzá a kódot (felhasználva a környezeti változókat és az unset() függvényt).

Öröklés Az objektumközpontú szemlélet egyik nagyon fontos jellemzője, hogy ún. osztályhierarchiát építhetünk fel az öröklés segítségével. Az öröklés során a gyermekobjektumok örökölnek minden tulajdonságot és metódust szülőjüktől, de definiálhatnak újakat is. Nézzünk egy egyszerű példát az öröklésre:

Öröklés <?php class szemely { var $nev;
function szemely($neve="Anonymous") //konstruktor $this->nev=$neve; } function nev() print "$this->nev ";

Öröklés class dolgozo extends szemely //a dolgozo osztály a szemely osztály leszármazottja { var $fizetes; function fizetes() print "$this->fizetes "; } $obj=new szemely(); $obj->nev(); //Kiírja, hogy Anonymous $obj=new dolgozo("István"); $obj->fizetes=126500; $obj->nev(); //Kiírja, hogy István $obj->fizetes(); //Kiírja, hogy ?>

Öröklés A dolgozo osztályt a szemely osztály leszármazottjaként vezettük be az extends kulcsszóval a 14. sorban, majd egy új tulajdonsággal (fizetes) bővítettük a 16. sorban. Így minden személynek csak neve van, míg minden dolgozónak fizetése is. A fizetés lekérdezéséhez írtunk egy fizetes() tagfüggvényt is (17. sor). A 24. sorban létrehoztunk egy dolgozót István névvel. A dolgozo származtatott osztálynak nem írtunk konstruktort, így a szülő osztály (szemely) konstruktora hívódik meg. Ha valamely függvény (beleértve a konstruktort is) nincs újradefiniálva a gyermekosztályban, akkor a híváskor a szülőosztályban található hívódik meg. Természetesen megtehettük volna, hogy új konstruktort, és új nev tagfüggvényt írunk.

Sokalakúság Ebben az esetben felülírhatjuk a szülő osztály tagfüggvényeit, és esetleg teljesen más csinálunk ugyanolyan néven vagy ugyanazt csináljuk csak más típusú vagy számú paraméterrel.

Objektumfüggvények Eredmény Függvény Leírás
call_user_method(string_1, string_2, …, string_n, $object) A $object objektum metódusait hívja meg. A sztringek a metódusok nevei. call_user_method_array(string_1, string_2, …, string_n, $array) Ha az objektumok egy tömbben vannak ($array-ben), akkor meghívhatjuk mindegyik (a sztringekkel meghatározott) ugyanazon metódusait. $boolean = class_exist($string) Logikai választ ad arról, hogy $string nevű osztály létezik –e. $string = get_class($object) Megadja a $object osztályát. $array = get_class_methods($string) Egy tömbbe tölti a $string nevű osztály metódusait. get_class_vars($string) Egy tömbbe tölti a $string nevű osztály adattagjait. get_declared_classes() Egy tömbbe tölti a deklarált osztályokat. get_object_vars($object) Egy tömbbe tölti a $object objektum adattagjait. get_parent_class($string) A $string nevű osztály szülőosztályát adja meg. is_subclass_of($object, $string) Logikai választ ad arról, hogy a $object szülőosztálya –e a $string nevű osztály. method_exist($object, $string) Logikai választ ad arra, hogy létezik –e a $object objektumnak $string nevű metódusa.

PHP nyelv 1. rész.

Hasonló előadás

Az előadások a következő témára: "PHP nyelv 1. rész."— Előadás másolata:

Hasonló előadás

Projectumról

Visszajelzés

Bejelentkezés

A társadalmi hálózaton keresztül belépni:

PHP nyelv 1. rész.

Hasonló előadás

Az előadások a következő témára: "PHP nyelv 1. rész."— Előadás másolata:

Hasonló előadás

Projectumról

Visszajelzés