NagyEniko Webprogramozas 2

TÁMOP-4.1.1.
F-14/1/KONV-2015-0009
„A GÉPÉSZETI ÉS INFORMATIKAI ÁGAZATOK DUÁLIS ÉS
MODULÁRIS KÉPZÉSEINEK KIALAKÍTÁSA A PÉCSI
TUDOMÁNYEGYETEMEN „
Dr. Nagy Enikő
Web-programozás II
Pécs
2015
A tananyag a TÁMOP-4.1.1.F-14/1/KONV-2015-0009 azonosító számú,

„A gépészeti és informatikai ágazatok duális és moduláris képzéseinek kialakítása a
Pécsi Tudományegyetemen” című projekt keretében valósul meg.
TÁMOP-4.1.1.F-14/1/KONV-2015-0009
„A GÉPÉSZETI ÉS INFORMATIKAI ÁGAZATOK DUÁLIS ÉS
MODULÁRIS KÉPZÉSEINEK KIALAKÍTÁSA A PÉCSI
TUDOMÁNYEGYETEMEN „
Web-programozás II
Dr. Nagy Enikő

Szakmai lektor: Gyurák Gábor
Nyelvi lektor: Veres Mária
Pollack Press
7624 Pécs, Boszorkány u. 2.
Felelős kiadó:
ISBN szám
Pécsi Tudományegyetem
Műszaki és Informatikai Kar
Pécs, 2015
© Dr. Nagy Enikő
2
TARTALOMJEGYZÉK
Web-programozás II
1. Bevezetés....................................................................................................... 8
2. A tantárgy célkitűzése ...................................................................................... 9
3. Követelmények ..............................................................................................10
4. A szerver oldali programozás ...........................................................................11
4.1. Az Apache .............................................................................................................................. 11
5. Programozás PHP nyelven ...............................................................................13

5.1. A PHP telepítése .................................................................................................................... 13
5.2. Programkészítés PHP-val ....................................................................................................... 16
8.2.1. Az első PHP-programunk ..................................................................................................... 17
5.3. A PHP nyelv elemei ................................................................................................................ 19
5.3.1. A literálok ............................................................................................................................ 19
5.3.2. A kifejezések ........................................................................................................................ 20
5.3.3. Változók ............................................................................................................................... 22
5.3.4. Konstansok .......................................................................................................................... 23
5.3.5. A tömbök ............................................................................................................................. 23
5.4. A PHP vezérlő szerkezetei ..................................................................................................... 25
5.4.1. Elágazások ........................................................................................................................... 25
5.4.2. Ciklusok................................................................................................................................ 27
5.5. Függvények ............................................................................................................................ 29
5.5.1. Függvény létrehozása .......................................................................................................... 30
5.5.2. Beépített függvények .......................................................................................................... 32
5.6. Adatbázis-kezelás MySQL-lel ................................................................................................. 33
5.6.1. Műveletek az adatbázissal ................................................................................................... 33
5.7. Objektumok a PHP-ben ......................................................................................................... 38
5.8. Egyéb lehetőségek ................................................................................................................. 41
3
5.8.1. Felhasználó kezelése ........................................................................................................... 41
5.8.2. Hiba- és kivételkezelés ........................................................................................................ 43
6. Gyakorló feladatok .........................................................................................45

6.1. HTML gyakorló feladatok ...................................................................................................... 45
6.2. JavaScript gyakorló feladatok ................................................................................................ 52
6.3. PHP gyakorló feladatok ......................................................................................................... 57
7. Összefoglalás .................................................................................................65
8. IRODALOMJEGYZÉK ........................................................................................67
4
ÁBRÁK JEGYZÉKE
1. ábra XAMPP telepítése I. ................................................................................................................................... 14
2. ábra XAMPP telepítése II. .................................................................................................................................. 14
3. ábra XAMPP telepítése III. ................................................................................................................................. 14
4. ábra XAMPP telepítése IV. ................................................................................................................................. 15
5. ábra XAMPP telepítése V. .................................................................................................................................. 15
6. ábra XAMPP Control Panel ............................................................................................................................... 16
7. ábra „PHP-próba” kimenet ................................................................................................................................. 18
8. ábra 1. HTML-feladat ......................................................................................................................................... 45
9. ábra 2. HTML-feladat ......................................................................................................................................... 46
10. ábra 3. HTML-feladat ....................................................................................................................................... 47
12. ábra 5. HTML feladat ....................................................................................................................................... 49
15. ábra 1. JavaScript-feladat ................................................................................................................................ 52
16. ábra 3. JavaScript-feladat I. ............................................................................................................................. 55
17. ábra 3. JavaScript-feladat II. ............................................................................................................................. 55
18. ábra 3. JavaScript-feladat III. ........................................................................................................................... 56
5
TÁBLÁZATOK JEGYZÉKE
1. táblázat Operátorok .......................................................................................................................................... 20
2. táblázat Műveletek precedenciája .................................................................................................................... 21
3. táblázat Logikai kifejezések operátorai ............................................................................................................ 22
4. táblázat Függvények ........................................................................................................................................ 23
5. táblázat Hibakezelés ........................................................................................................................................ 44
6
Web-programozás II
7
1. Bevezetés
A magyar felsőfokú informatikusképzésről elmondható, hogy a képzésfejlesztés folytonos
kihívások elé állítja az oktatásban szereplő szakembereket. Az Európai Unió által deklarált
globális kérdéskörök – közéjük tartozik az informatika is – hatással vannak a felsőoktatásra. A
felsőoktatási szektor versenyképességének javítása ugyanis az informatikai képzési eljárások
folyamatos fejlesztését igényli, és ez kemény feladatokat jelent a szakembereknek. Az
információs technológia hallatlan fejlődésével új kommunikációs csatornák, új internetes
felületek jönnek létre, amelyek folytonos változásban tartják az informatikai képzési területet.
Ezenkívül mindennapivá váltak a jelenkori információs társadalom

környezetének változásai, és ehhez kapcsolódóan az elektronikus környezeté is. A hálózat
alapú kommunikációs megoldások jelentősége megnőtt, amely nagy hatással van munkánkra,
életünkre. Az online világnak meghatározó a szerepe már a hétköznapjainkban is. Eddigi
tananyag-fejlesztési munkáimmal, elkészült jegyzeteimmel ebből következően az volt a célom,
hogy segítséget nyújtsak az elsősorban nem informatikai szektorban elhelyezkedni
szándékozó hallgatóknak az eligazodásban, az új ismeretek átadásában.
Mára viszont elmondható, hogy szinte nincs is olyan munkakör, ahol ne lenne
szükség informatikai tudásra. A jegyzetkészítésnél tehát azt a fajta segítségnyújtási
koncepciót választottam, amellyel azt szeretném elérni, hogy olyan segédanyagot adjak a
kedves olvasók kezébe, amelynek áttanulmányozása segíthet mind az informatikai, mind a
nem informatikai szektorban történő munkák elvégzésében.
Konkrétabban megfogalmazva, ezt a jegyzetet olyan, a webprogramozásban

kezdő hallgatóknak ajánlom, akik szeretnének megismerkedni a statikus és a dinamikus
honlapok fejlesztésével, legyen az magán vagy akár üzleti jellegű honlap. Ez a tananyag olyan
alapozó ismereteket foglal magába, melyekkel leendő informatikusok is, és más szakon
tanulók, de a téma iránt érdeklődők is megbirkózhatnak.
Ennek a jegyzetnek tehát az elsődleges célja, hogy hozzásegítse a hallgatót

a webprogramozás alapjainak elsajátításához.
Ezek után már csak az a kérdés merülhet fel, hogy mit értünk
webprogramozáson? A programfejlesztésnek olyan aspektusait, amelyeknek eredményei
webes felületekre készülnek. A webböngésző, a webszerver, a HTTP-protokoll, a HTML nyelv,
az URL-címzés, a kliens, a JavaScript, a PHP stb. olyan kifejezések, amelyeknek egy
webprogramozó alapszókincsének részévé kell válniuk, és a programozónak a megértésük
olyan szintjét kell birtokolnia, amellyel képes webes alkalmazások fejlesztésére.
Bízom benne, hogy munkámmal hatékonyan hozzájárulok ahhoz, hogy egy

átlagos felhasználó számára olyan kiterjedt ismereteket nyújt az anyag, amelyekre szüksége
lesz webes felületen futó távoli alkalmazások megértéséhez és fejlesztéséhez.
a szerző
8
2. A tantárgy célkitűzése
A felsőfokú alapképzési szakok képzési és kimeneti követelményrendszerében szerepel, hogy
alapfokozat birtokában a mérnök informatikusoktól legalább két kompetencia elvárt arra
vonatkozóan, hogy alkalmas legyen számítógépes és távközlő hálózatok telepítésére,
konfigurálására, hibaelhárítására, üzemeltetésére, továbbfejlesztésére; kliens
szerverrendszerek programozására, webprogramozásra, vállalati információs rendszerek
folyamatalapú funkcionális tervezésére és készítésére, valamint döntéstámogató rendszerek
tervezésére, készítésére, működtetésére. Ebből következően, jelen tananyaggal a
webprogramozáshoz szükséges kompetenciák, ismeretek és attitűdök kifejlesztése az
alapvető cél.
A webprogramozás tantárgy célkitűzéseit tekintve tehát a következőket fogalmazom meg:
- Alapvető cél – a bevezető ismereteken túl – megérteni a webes felületek és

alkalmazások működését.
- Cél, hogy megismerjük az internet működését, és az ezzel kapcsolatos technikai

megvalósításokat, protokollokat.
- Olyan szakkifejezések, fogalmak ismereteit, azaz szakszókincsét kell elsajátítanunk,

mely nélkül nem válhatunk sikeres szakemberré.
- A jegyzetben célul tűzzük ki a kliens és szerver oldali programozás megértését, az

ehhez tartozó kompetenciák kifejlesztését.
- Kliens oldalról a HTML5 leíró nyelv alapjainak megismerése, és ehhez kapcsolódóan

a használati rutin megszerzése elsődleges célként szerepel.
- A statikus és dinamikus weboldalak közötti különbségek, hasonlóságok és

összekapcsolódások megértése, és ide tartozik a JavaScript programozásba való
bevezetés is.
- Jelen jegyzetben viszont nem kívánunk hangsúlyt fektetni a honlapok formailag

professzionális megjelenését szolgáló CSS stíluslapok megismerésére. Erre a
bevezető kurzus utáni, ismereteket elmélyítő tanfolyamon kerülhet sor.
- A szerver oldali programozás megismeréséhez és megértéséhez a PHP programozási

nyelvvel kapcsolatos alapfeladatok megoldása a cél.
- Végül, de nem utolsósorban, célkitűzéseink között szerepel, hogy a hallgatók olyan

webprogramozási alaprutint és ismereteket szerezzenek, melyeknek birtokában
képesek lesznek majd önfejlesztéssel saját célokat kialakítani, mi több, azokat
teljesíteni is.
9
3. Követelmények
Jelen tananyag elsajátításához elengedhetetlenek a következők:
A tananyag feldolgozása során feltételezzük, hogy a hallgató birtokában van a középiskolai

informatikai ismeretanyagnak, a közoktatásról szóló informatikai vonatkozású tananyag
előírásai alapján.
Számítástechnikai alapismeretek, számítógépes hálózatok működésének alapjai,

valamint dokumentumkezelési alapok és készségek szükségesek az anyag megértéséhez,
készségszintű elsajátításához.
Ezen kívül, mivel programozási feladatok megoldására kerül sor, szükség lesz alapvető
algoritmikus gondolkodásmódra. Ide tartozóan feltételezzük a programozási alapokkal
kapcsolatos ismereteket.
Mivel alapvetően internetes felületekkel foglalkozunk, ezért fontos, hogy a hallgató

jártas legyen az internetes böngészésben, elektronikus tartalmak felhasználói szintű
kezelésében.
Alapkövetelményként említendő továbbá az alapfokú angolnyelv-tudás, illetve a Közös

Európai Referenciakeret nyelvtudás fokozatait tekintve a minimum A2-es szint.
Infrastrukturális megközelítésből a tananyag elsajátításához szükségünk lesz

internetkapcsolatra, és a webes fejlesztésekhez szükséges telepítésekre alkalmas asztali
számítógépre vagy laptopra.
10
4. A szerver oldali programozás
Mint ahogy arról az első fejezetekben is szóltunk, a webszerver elsődleges feladata, hogy
kiszolgálja a kliens gépeket, azok kéréseire reagáljon. Ha a klienstől egy kérés megy a
webszerver felé, az egy HTML-kódot juttat vissza válaszként, amely kódot a kliens gépen lévő
böngésző értelmez és jelenít meg a felhasználó számára.
A honlapok tekintetében eddig statikus oldalak létrehozását tárgyaltuk, de mi a helyzet
a dinamikus oldalakkal? Azt már jól tudjuk, hogy statikus weblapról beszélünk akkor, ha annak
tartalmát a fejlesztő előre meghatározza, leírja és tárolja. Az ilyen weblapok tartalma minden
egyes letöltéskor, megtekintéskor ugyanaz. Dinamikus honlapok esetén azokat vagy azok egy
részét nem a fejlesztő, hanem a programkód hozza létre. A program általában adatokat fogad,
és azok feldolgozása után dinamikusan állítja elő a weblap HTML-szövegét. A dinamikus
weblapok tartalma ezért nem állandó, hanem a program által feldolgozott adatoktól függ.
A dinamikus tartalom előállítását, módosítását szerver oldalon vagy kliens
számítógépen futó programkód is végezheti. Szerver oldali programról beszélünk akkor, ha a
dinamikus weblapot manipuláló programkód egy távoli gépen működik, és hozzánk már csak
a kész weblap jut el.
Mivel szerver oldali programozás esetén a programkód a szerveren tárolódik, és
végrehajtása is ott történik, így nem a böngésző, hanem a távoli gépen elhelyezett
alkalmazásszerver futtatja a programkódot. Az alkalmazásszerver olyan keretrendszer
(programozási nyelv, futtatókörnyezet, futásidejű könyvtárak, csatolófelületek együttese),
amely egymástól függetlenül működő programkódok párhuzamos futását biztosítja. Az
alkalmazásszerverek kiváló lehetőséget biztosítanak az adatbázisszerverek által működtetett
adatbázisok elérésére, és webes alkalmazások készítésére is. A webalkalmazás olyan
szoftver, amelynek kódja távoli gépre telepített alkalmazásszerver segítségével fut, de
kezelőfelülete a felhasználó gépén futó böngészőben jelenik meg. Mivel az
alkalmazásszerveren futó program képes adatbázisszerverek elérésére is, a
webalkalmazások kiválóan alkalmasak adatbázisok web felületen történő kezelésére.
4.1. Az Apache
Mielőtt elkezdenénk egy szerver oldali programnyelvnek a megismerését, ismerjük meg ide
tartozóan az egyik leggyakrabban használatos webszerver tulajdonságait. Az Apache egy
erős, nagy webszerver, amely kompatibilis a HTTP-vel. A webszerver HTML-oldalakat szolgál
ki HTTP protokollon keresztül. Alapértelmezetten a 80-as porton. Titkosított adatátvitelre is
képes SSL vagy TLS felett, a 443-as porton (HTTPS protokoll). Az Apache weboldala
http://apache.org. Az Apache valójában egy alapítvány, amelynek nagyon sok projektje van, a
webszerver (httpd) csak az egyik projekt a sok közül.
Az Apache projekt koordinálását több vezető és fejlesztő végzi, ami az Apache
Software Foundation néven fut. Ez a szerver nyílt forráskódú webkiszolgáló alkalmazás,
szabad szoftver és megfelel a gyorsan változó internet követelményeinek. Szabadon
használható akár üzleti, vállalati felhasználási célokra is. Az Apache több kiszolgáló oldali
programnyelvet támogat. Ezek többek között a Perl, a Python és a PHP is.
11
A virtual hosting segítségével egyetlen Apache installáció ki tud szolgálni több
különböző webhelyet is, aminek a lényege az, hogy például egyetlen gép egyetlen Apache
szerverrel képes kiszolgálni több, különböző címre érkező HTTP-kérést.
Statikus és dinamikus weboldalak közzétételére egyaránt használják. Sok
webalkalmazást az Apache által nyújtott környezethez és szolgáltatásokhoz terveznek. Az
Apache alkotja a webszerver komponenst a népszerű LAMP nevű alkalmazáscsomagban,
melynek további komponensei a MySQL adatbázisszerver és a PHP/Perl/Python
programozási nyelvek.
12
5. Programozás PHP nyelven
Ha szerver oldali környezetben szeretnénk webfejlesztéssel foglalkozni, ahhoz létre kell
hoznunk a megfelelő programozói környezetet, telepíteni kell a szükséges szoftvereket. A PHP
professzionális lehetőségeket kínál a webprogramozásban, amelynek alapjait szeretnénk
most elsajátíttatni. Így ebben a fejezetben a PHP nyelvvel és lehetőségeivel foglalkozunk. A
teljesség igénye nélkül vesszük sorba a nyelv legfontosabb elemeit, melyek megértését példák
illusztrálásával könnyítjük meg.
A PHP programozási nyelv létrejötte egy dán származású, kanadai programozóhoz,
Rasmus Lerdorfhoz köthető. 1994-től kezdődően jelentős fejlődésen ment keresztül a nyelv,
mire szerver oldali programnyelvként igazán alkalmas lett webalkalmazások kifejlesztésére. A
PHP rövidítés eredetileg a Personal Home Page Tools makró gyűjteményből (1995-ből) ered,
de mára a hivatalos neve Hypertext Preprocessorként van nyilvántartva.
5.1. A PHP telepítése
A PHP nyelv megtanulásához, és a későbbi fejlesztésekhez célszerű saját gépünkön is

kialakítani a megfelelő szoftverkörnyezetet. Mivel a PHP több webszerverrel és
adatbázisszerverrel is képes az együttműködésre, így jogosan oszlanak meg a vélemények is
arról, hogy melyik szoftverrendszert érdemes használni. Az ide tartozó szoftverkörnyezetek, a
LAMP (Linux+Apache+MySQL+PHP), a WAMP (Windows+Apache+MySQL+PHP) és az
XAMPP (Cross-platform+Apache+MySQL+PHP+PERL) programcsomagok közül mi az
XAMPP platform független szoftverkörnyezet kialakítására törekszünk.
Az XAMPP telepítéséhez első lépésként látogassunk el a
http://www.php.net/manual/en/ini.list.php oldalra, ahonnan le tudjuk tölteni a szükséges
szoftvercsomagot. Érdemes a meghajtónk gyökérkönyvtárába menteni, és ott installáláskor
automatikusan létrejön majd egy xampp nevű mappa, amibe telepíteni fogjuk a programokat.
A letöltést követően a lépésről lépésre módszer alkalmazásával telepítsük, és alakítsuk ki
fejlesztő környezetünket. A következő ábrasorozat prezentálja a telepítési lépéseket egészen
az xampp control panel megjelenéséig, amelyben a Start gombok segítségével indíthatjuk, és
a Stop gombokkal állíthatjuk le a szerverek működését:
13
1. lépés XAMPP telepítő csomag letöltése
1. ábra XAMPP telepítése I.
2. lépés A telepítő elindítása
2. ábra XAMPP telepítése II.
3. lépés A rendszer felajánl egy helyet a telepítéshez, amit célszerű elfogadni.
3. ábra XAMPP telepítése III.
4. lépés A telepítés folyamata, ami pár percig is eltarthat.
14
4. ábra XAMPP telepítése IV.
5. lépés A telepítés befejezése és a Control Panel elindítása.
5. ábra XAMPP telepítése V.
6. lépés Az XAMPP Control Panel megjelenése.
15
6. ábra XAMPP Control Panel
Miután a telepítést elvégeztük, próbáljuk ki, működik-e a webszerverünk! Ehhez keressük meg
a létrehozott xampp mappában (c:/xampp), azon belül a htdocs nevű mappában az index.php
nevű fájlt és próbáljuk megnyitni egy böngészővel, a következő útvonallal:
http://localhost/index.html. Abban az esetben, ha a kijelzőnkön a „Something is wrong with the
XAMPP installation” feliratot látjuk, akkor valami hiba történt telepítés közben. Ilyenkor
érdemes megnézni, hogy a Control panelen futnak-e az Apache és MYSQL moduljaink.
Amennyiben futnak a moduljaink, és nem kapunk hibaüzenetet (hanem bármi mást, pl.
„IT works!”), azt jelenti, hogy működik a rendszer. A webszerver indítása után természetesen
nem tudunk majd bármelyik mappából weblapokat letölteni. Webböngészővel csupán egyetlen
könyvtár, a xampp\htdocs mappa tartalma lesz elérhető. Ez a mappa a webszerver
DocumentRoot könyvtára, ezt tekinti az Apache a weben keresztül látható könyvtárszerkezet
gyökerének.
A htdocs nevű mappán belül hozzunk létre egy webprog nevű mappát, hogy a tanulás
folyamán ide tudjuk menteni az elkészült PHP-állományainkat, és innen tudjuk majd futtatni
azokat.
5.2. Programkészítés PHP-val
Miután föltelepítettük és kipróbáltuk a webszervert, szükségünk lesz a weblapok és PHP-

programok megírására alkalmas szerkesztőprogramra. A célra valójában bármilyen
szövegszerkesztő alkalmas (Jegyzettömb, NotePad++ stb.), de ezen kívül léteznek
kifejezetten programozásra fejlesztett alkalmazások, amelyeket használhatunk. Mi maradunk
a Notepad++ szerkesztőnknél.
A PHP-állományokról tudnunk kell, hogy míg legtöbb programozási nyelvben az
utasítások nem keveredhetnek más nyelvek kódjával, PHP esetén a programkód HTML-
oldalakba ágyazható, sőt az értelmező eleve abból indul ki, hogy a programsorokat HTML-
szöveg veszi körül. A webszerver az állományok kiterjesztéseiből (.php, .htm, .html) ismeri fel
és különbözteti meg, hogy milyen kódról van szó.
A szerver a böngészők HTML-oldalakra vonatkozó kéréseire rögtön a weboldal
elküldésével válaszol, a PHP-kódot tartalmazó állományokat pedig előbb a PHP-értelmező
(interpreter) kapja meg, ami feldolgozza a fájlt. Az értelmező értelmezi és végrehatja az
16
utasításokat, műveleteket. Például a PHP-program használhatja a fájlrendszer fájljait,
adatbázisokat vagy akár hálózati kommunikációt folytathat. Ha elvégezte a műveleteket, akkor
visszaadja a webszervernek az utasítások által létrehozott kimenetet. A webszerver ezt a
kimenetet küldi vissza a böngészőnek.
Az értelmező mindig HTML-módban kezdi egy állomány feldolgozását, azaz abból
indul ki, hogy a dokumentum alapvetően HTML-szöveg, amelybe egy vagy több ponton PHP-
kódot ágyaztak. PHP módba akkor vált át, amikor a szövegben a PHP-kód kezdetét jelző
karaktersorozatot (<?php ) talál. Amikor a feldolgozásban eléri a kód végét jelző jelölőt (?>),
akkor ismét HTML-módba vált vissza. A .php kiterjesztésű állomány végrehajtásakor a html-
php-html váltás tetszőleges számban ismétlődhet, tehát a fájlban bármennyi PHP kódrészlet
lehet.
Egy PHP-program készítésekor a következő szintaktikai szabályokat figyelembe kell
venni:
- Az utasításokat pontosvessző zárja (;).
- Az utasítások esetleges paramétereit vesszővel választjuk el egymástól (,), és az
utasítás után kerek zárójelben adjuk meg őket ().
- A ciklusokhoz, elágazásokhoz és eljárásokhoz tartozó utasításblokkokat francia
zárójelek közé tesszük {..}.
- A változók nevében a kis- és nagybetűk között különbséget tesz, pl. $valtozo nem
ugyanaz és nem egyenlő $VALTOZO-val.
Léteznek olyan szabályok is, amelyek ugyan nem kötelezőek, de alkalmazásuk ajánlott a
praktikum és jobb áttekinthetőség miatt. Ezek szerint:
- Az utasításokat egymás alá írjuk, több sorban helyezzük el őket.

- A nyelvi elemeket elválasztó karakterekkel (whitespace) (pl. szóköz, tabulátor, sorköz)
jól tagolhatjuk a programkódot, így tovább növelhetjük az olvashatóságot.
- A programkódban egy- vagy többsoros megjegyzések helyezhetők el. Az egysoros
megjegyzések // jellel kezdődnek, a többsorosokat pedig /* */ karaktersorozatok közé
kell tenni. A megjegyzéseket az értelmező figyelmen kívül hagyja, azonban a
programozó számára fontos információkat tartalmaznak.
8.2.1. Az első PHP-programunk

Egy egyszerű PHP-program előállítása a következőképpen történik:
Nyissunk meg a szerkesztőben (Notepad++) egy új állományt és gépeljük be

a következő PHP forráskód szövegét:
<?php
print("Hello World!");
?>
A program egy utasítást, a print() függvényt használt, mellyel karakterláncot ír ki a
képernyőre. A forrásszöveget mentsük el elso név alatt php kiterjesztéssel, majd a
http://localhost/elso.php webcím begépelésével töltsük be a megszerkesztett PHP-fájlt a
webböngészőbe. Ekkor a PHP-program végrehajtása a webkiszolgálón megtörténik.
17
A PHP-kód beépítése egy HTML-oldalba a PHP kódblokk beírásából áll a HTML-
elemek közé. A következő példa HTML- és PHP-kódot is tartalmaz egy oldalon. Készítsük el
ezt is!
<?php
header ("Content-Type: text/html; charset=utf-8");
?>
<h1> PHP próba </h1>
<hr/>
<ul>
<?php
$orszag=array ("Kalifornia ","Colorado és ","Arizona ");
for ($k=0; $k<3; $k++)
{
print($orszag[$k]);
}
?>
amerikai országok
A programunk kimenete a következő lesz:
7. ábra „PHP-próba” kimenet
A kiírásra a print() utasítást használtuk, amire ugyancsak használhatjuk az echo utasítást is.
Mindkettő a kimenetre írja az utasítás neve mellett feltüntetett adatot, azaz a kapott
paramétert. A különbség az, hogy a print csak egy, az echo pedig vesszőkkel elválasztott, több
paraméter kiírására is alkalmas.
Példa:
<?php
echo "Kalifornia ", "Colorado", "Arizona ";
print "Kalifornia, Colorado, Arizona amerikai országok.";
?>
A weblapok head elemében mindig jelezzük a weblap kódolását. Ha tisztán php-kóddal állítjuk
elő a weblapot, akkor a header() függvénnyel tudjuk elküldeni a kódolás típusát.
A fenti példában UTF8 kódolást használunk, ezért a példaprogramban szerepel a header()
függvény (header ("Content-Type: text/html; charset=utf-8");).
18
Ha egy komplett webalkalmazást tekintünk, akkor könnyen látható, hogy több PHP-fájlból
tevődik össze. Több, különálló fájlban kezeli például a kliens oldali felületet, vagy gyakori, hogy
külön fájlban kezeli a függvényeket. Fontos megjegyezni, hogy a függvényeket tartalmazó
állományokat a webszerver publikus könyvtárán kívül kell elhelyezni! Ilyenkor a külön lévő
PHP-fájlokat ideiglenesen valahogy össze kell fűzni. Erre a célra szolgálnak az include, az
include_once, a require és a require_once utasítások. Ezeknek az utasításoknak a
használatakor meg kell adni a csatolandó PHP-fájl paraméterenkénti útvonalát és nevét.
Amikor futtatjuk a kódot és az értelmező include utasításhoz ér, akkor felfüggeszti az eredeti
kód végrehajtását, és a paraméterként megadott állománnyal folytatja a művelet-végrehajtást.
Amikor végzett a becsatolt fájl feldolgozásával, visszatér az eredeti kódba.
Fontos: include-dal a csatolt állományban egyértelműen jelezni kell a PHP-kódok helyét!
Az include és a require utasítások között annyi különbség van, hogy hiba esetén az include
csak küld egy figyelmeztető üzenetet, majd folytatja tovább a munkát, a require azonban
figyelmeztetés után megszakítja a program futását.
Ha meg akarjuk előzni egy kód többszöri beillesztését, akkor használjuk az
include_once és a require_once utasításokat. Ezek abban különböznek az include és a require
utasításoktól, hogy mielőtt elvégeznék a műveletet, megvizsgálják, hogy a kódot korábban
nem illesztettük-e be. Ha igen, akkor nem ismétlik meg a csatolást.
5.3. A PHP nyelv elemei
Amikor egy program fut, az utasításokat hajtja végre, ezzel adatokat módosít, adatokon végez
műveleteket és ábrázolja azokat. Ezt úgy mondjuk, adatkezelést végez. Ahhoz, hogy tudjuk
ábrázolni az adatokat, meg kell ismerni a lehetséges alapelemeket, elemi lépéseket,
műveleteket, amelyekkel a program képes dolgozni. Ebben a fejezetben megismerjük az
adattípusokat, használható változókat, konstansokat, és ezekhez kapcsolódóan az ábrázolási
módokat.
A PHP nyelv elemei, a literálok, a kifejezések, a változók, a konstansok és a tömbök.
Nézzük meg, melyik elemnek melyek a jellemzői!
5.3.1. A literálok
A literál lehet szöveges és számérték, illetve logikai literál. A PHP a ’ ’ és az „” idézőjelek közé
gépelt karaktersorokat érti szöveg, így szövegliterál alatt. Az így megadott szövegeket az
azonnali megjelenítésre használjuk.
A számok ábrázolásakor egész és valós típusú numerikus adatokat tárolhatunk
literálban. A valós szám literálokat a számban elhelyezett pont (.) tizedes elválasztó
különbözteti meg az egész literáloktól. Utóbbiak esetében az oktális és hexadecimális
ábrázolásra is van lehetőség. Az oktális számokat 0 (011=>9), a hexadecimális számokat 0x
karakterekkel (0xff=>255) kell kezdeni. A valós számokat legtöbbször egyszerűen tizedes
elválasztóval jelezzük (3.14), de használhatjuk az exponenciális (normalizált) formát is (314e-
2=> 314*10-2=>3.14).
Példa:
echo "Egész szám: ",270,"</br>";
19
A logikai típusú adat mindössze kétféle, igaz vagy hamis értéket vehet fel.
5.3.2. A kifejezések
A program során az adatkezelésre használjuk alapvetően a kifejezéseket, melyek alapvetően
két részből állnak, a tényezőkből (operandus) és a műveleti jelekből (operátor). Az értelmező
úgy kezeli a kifejezéseket, hogy elvégzi a kifejezésben szereplő műveletet, és azt így kapott
eredményértéket helyettesíti be, azzal dolgozik tovább. Numerikus kifejezésekben aritmetikai
(matematikai) operátorokat, a szöveges kifejezésekben sztring operátorokat használunk.
Matematikai operátorok:
1. táblázat Operátorok
Operátor Művelet Példa Eredmény
+ Összeadás 6+3 9
- Kivonás 6-3 3
* Szorzás 6*3 18
/ Osztás 6/3 2
% Maradékképzés 7%3 1
Sztring operátor (konkatenálás):
Operátor Művelet Példa Eredmény

. Összefűzés "Hello ". "World" "Hello World"
Összehasonlító operátorok:
Operátor Állítás Igaz, ha Példa Eredmény

== egyenlő a két operandus értéke megegyezik 4 == 5 false
!= nem a két operandus értéke különbözik 4 != 5 true
egyenlő
=== azonos a két operandus értéke és típusa is „5”=== false
megegyezik 5
!== nem azonos a két operandus értéke vagy típusa „5”!== 5 true
különböző
> nagyobb, a bal oldali operandus értéke nagyobb a 5>4 true
mint jobb oldalinál
>= nagyobb a bal oldali tényező értéke nagyobb, vagy 4 >= 4 true
vagy egyenlő a jobb oldalival
egyenlő
< kisebb, mint a bal oldali operandus értéke kisebb a 5<4 false
jobb oldalinál
<= kisebb vagy a bal oldali operandus értéke kisebb a 3 <= 4 true
egyenlő jobb oldalnál vagy egyenlő azzal
Értékadó operátor:
20
Régi érték Operátor Példa Egyenértékű kifejezés Új érték
10 += $a += 5 $a = $a + 5 15
10 -= $a -= 5 $a = $a - 5 5
10 *= $a *= 5 $a = $a * 5 50
10 /= $a /= 5 $a = $a / 5 2
10 %= $a %= 5 $a = $a % 5 0
"Hello " .= $koszon.="World" $koszon = $koszon . "World" "Hello World"
Régi érték Operátor Példa Egyenértékű művelet Új érték

10 ++ $a++ $a=$a+1 11
10 -- $a-- $a=$a-1 9
Bináris operátorok:
Operátor Művelet
& ÉS, azaz AND
| VAGY, azaz OR
^ kizáró vagy, azaz XOR
~ NO
<< balra tolás
>> jobbra tolás
Forrás:Saját szerkesztés
Ha kifejezéseket használunk a programunkban, akkor nemcsak egyszerű, hanem összetett

kifejezésekkel is dolgozhatunk, amelyek több, egymást követő kifejezésből állnak (pl. 4+2-
6+3). A balról jobbra haladó feldolgozási sorrendet a műveleti precedencia, illetve a
zárójelezés változtathatja meg. Két, egymás mellett lévő művelet közül mindig a magasabb
precedenciájút hajtja végre először az interpreter. Azonos precedencia esetén a haladási
sorrend dönt. Az alábbi táblázatban fentről lefelé haladva soronként csökken a műveletek
precedenciája, az azonos sorban lévő műveleteké pedig azonos.
2. táblázat Műveletek precedenciája

++ --
!
*/%
+-.
<< >>
< <= > >= <>
== != === !==
&
^
|
&&
21
||
?:
= += -= *= /= .= %= &= |= ^= <<= >>= =>
and
xor
or
Forrás: Saját szerkesztés
Az összetett logikai kifejezések operátorai a következők lehetnek:
3. táblázat Logikai kifejezések operátorai

Operátor Jelentés Igaz, ha
|| vagy az egyik operandus igaz
or vagy az egyik operandus igaz
xor kizáró vagy csak az egyik operandus igaz
&& és mindkét operandus igaz
and és mindkét operandus igaz
! tagadás ha az egyetlen operandus hamis
5.3.3. Változók
A változó nem más, mint a memóriában egy érték, egy adat számára lefoglalt szakasz.
Ezeket a szakaszokat vagy memóriahelyeket a PHP-értelmező foglalja le a program futásakor
az értékek tárolására. A változó nevével hivatkozunk rá, az adat pedig az értéket jelenti.
Ahhoz, hogy változót tudjunk használni, deklarálnunk kell (nevet kell adnunk és helyet kell
lefoglalnunk a memóriában), majd kezdőértéket kell adni. A PHP nyelvben minden változónév
dollár jellel ($) kezdődik, betűkből, számjegyekből és aláhúzás karakterekből (_) állhat.
Fontos: A $ jelet követő első karakter nem lehet számjegy és a változónevek nem
tartalmazhatnak szóközt! A PHP az utasítások neveiben nem különbözteti meg a kis- és
nagybetűvel írt változatokat.
A PHP nyelvben egyszerű, összetett és speciális adattípusokat különbeztetünk meg.

Egyszerű adattípusok a boolean (logikai), az integer (egész számok), a double/float (tizedes
törtek) és a string (szöveg) típusok. Összetettek az array (különböző típusú adatok tárolására)
és object (adatok és műveletek tárolására) típusok. Speciális típusok pedig a resource
(erőforrás) és NULL adattípusok. A PHP úgynevezett gyengén típusos nyelv, ami azt jelenti,
hogy egy változó deklarálásakor nem kell megadni annak típusát. A változót egyszerű
értékadással, azaz implicit deklarációval hozhatjuk létre, ami azt jelenti, hogy a változó típusát
az érték típusa egyértelműen határozza meg.
Példa: $a=8;
PHP-ban arra is van lehetőség, hogy a változót a program különböző pontjain más-
más típusú adatként kezeljük, sőt típusát meg is változtathatjuk a futás során.
22
Erre mutat példát a következő programrészlet, amelyben a szorzás művelet hatására
az ’a’ szöveges változó típusa számra változik:
<?php
$a="8";
$b=6;
echo $a*$b;
?>
Ez a típusmegadási automatizmus ugyan megkönnyíti a munkánkat, de számos

esetben, főleg nagy programok fejlesztésénél szükségünk lehet direkt módosítanunk,
meghatároznunk a változóink típusait. Ehhez létezik több függvény is a nyelvben, melyekkel
megoldhatjuk a változótípussal kapcsolatok kérdéseinket. A következő táblázat tartalmazza
az ilyen gyakori függvényeket.
4. táblázat Függvények
Függvény neve Funkciója Példa
gettype változótípus meghatározása gettype($a);
settype változótípus megváltoztatása settype($a, „integer”);
unset változó törlése unset($a)
5.3.4. Konstansok
Az olyan adatokat, amelyekre alfanumerikus nevekkel lehet hivatkozni, és értéküket soha nem
szándékozzuk megváltoztatni, konstansoknak vagy állandóknak nevezzük. Létrehozásuk a
define() függvénnyel történik, amelynek első paramétere a konstans neve, a második az
értéke. A konstans neve a változókkal szemben nem kezdődik $ karakterrel, ellenben ugyan
nem kötelezően, a nevüket nagybetűkkel adjuk meg.
Példa:
<?php
define("PI",3.14);
$r=10;
echo "Terület: ",$r*$r*PI;
?>
5.3.5. A tömbök
A tömbök értékek indexelt listái, rugalmas adatszerkezetek és nagyméretű, összetett adatok
tárolására és kezelésére szolgálnak. Használatuk igazi értelme a nagyobb mennyiségű adatok
rendszerezése szempontjából fontos. A tömbök olyan programelemek, amelyekben az adatok
indexek segítségével érhetők el. Az indexelés számmal vagy karakterlánccal valósítható meg.
Alapértelmezés szerint a tömböket számokkal indexeljük, az első elem indexe mindig 0. Tehát,
bármely elem indexe eggyel kisebb az elem tömbbéli helyétől és az elem utolsó indexe mindig
eggyel kisebb a tömb méreténél.
Tömbhöz értéket kétféleképpen rendelhetünk:

az array() függvény segítségével,
23
szögletes zárójelek alkalmazásával.
Az array() függvény segítségével a következőképpen tudunk tömböt létrehozni:
$orszag = array(“Arizona”, "Colorado”, ”Kalifornia”, ”Új-Mexikó”, ”Utah”);

Ha a tömbből információt szeretnénk nyerni, akkor két adatra van szükségünk:
– a tömb nevére (a fenti példa esetében: $orszag),
– a megjelenítendő elem sorszámára.
Ha ki akarjuk íratni az $orszag tömb harmadik elemét, amelynek az indexe 2 (az indexet a
tömb neve után szögletes zárójelbe kell írni):
print $orszag[2];
A kiírás eredménye a következő karakterlánc lesz: ”Kalifornia”.
Ha szögletes zárójelek alkalmazásával akarunk tömböt létrehozni, a következőképpen kell

eljárni:
$orszag[]=”Arizona”;
$orszag[]=”Colorado”;
$orszag[]=”Kalifornia”;
$orszag[]=”Új-Mexikó”;
$orszag[]=”Utah”;
Szögletes zárójel alkalmazásával az array() függvény segítségével létrehozott tömbhöz új

elemet adhatunk:
$orszag[5]=”Wyoming”;
Asszociatív tömböknek hívjuk a karakterláncokkal indexelt tömböket. Az asszociatív tömbök

esetében meg kell nevezni a tömb elemeit. Létrehozhatók az array() függvény vagy a
szögletes zárójel segítségével is. Az array() függvény alkalmazásánál minden elemnek meg
kell adni a kulcsát és értékét. A következő programrészlet az $orszagok nevű asszociatív
tömböt hozza létre három elemmel:
<?php
$orszagok = array(
"nev"=> "Kalifornia",
"fovaros" => „Los Angeles”,
"lakosok" => "3819702",);
print $orszagok["fovaros"];
A fenti tömb második elemét a következő módon érhetjük el:
print $orszagok [“fovaros”];
24
5.4. A PHP vezérlő szerkezetei
Vezérlő szerkezetekkel a JavaScript tárgyalásánál is foglalkoztunk már. Egy vezérlő

szerkezet, funkcióját tekintve ugyanaz tulajdonképpen minden nyelvben, csak éppen a
megvalósítási, szintaktikai jellemzőik térhetnek el egymástól. Ebben az alfejezetben
összegezzük, főleg szemléltető példákon keresztül a PHP programozási nyelv vezérlési
szerkezeteit, amelyek rutinos ismerete nélkül nem boldogulnánk.
A PHP kapcsán is beszélhetünk elágazásról (kétágú és többágú) és ciklusról
(elöltesztelő, hátultesztelő, léptető és egymásba ágyazott) mint vezérlési technikákról.
Vegyük sorra ezeket!
5.4.1. Elágazások
Az elágazások, vagy más néven szelekciók esetén a kód több utasításágra bomlik. Minden ág
további utasításokat tartalmazhat, azonban a szelekció után az ágak újra találkoznak, és a
program végrehajtása ismét közös szekvenciában folytatódik.
A kétágú elágazás megvalósítására az if utasítást használhatjuk, ami az alábbi formában teszi

lehetővé az ágak leírását:
if (logikai kifejezés)
{
igaz_ág
}
else
{
hamis_ág
}
Példa egy egyszerű elágazásra:
<?php
$a=8;
$b=6;
if ($a>$b)
{
echo ("$a nagyobb <br/>");}
else{
echo ("$b nagyobb <br/>");
}
?>
A következő példa az egymásba ágyazott elágazást mutatja:
25
<?php
$a=8;
$b=6;
if ($a==$b)
{
echo ("$a egyenlő $b <br/>");}
else{
if ($a>$b)
echo ("$a nagyobb <br/>");
else
echo ("$b nagyobb <br/>");
}}
?>
A két példa alapvetően ugyanazt csinálja. Megvizsgálja két változó értékét, hogy melyik a
nagyobb és a nagyobbat kiírja. A különbség viszont a két példa között az, hogy a második
precízebb megoldás, mert azt az esetet is vizsgálja, amikor egyenlő a két változó értéke.
A sokszorosan egymásba ágyazott elágazások nehezen olvashatóvá teszik a
programkódot. A feladat egyszerűbb megvalósítására használható az if…elseif…else
szerkezet, ahol az igaz ágat követő elseif kulcsszóval új elágazást helyezhetünk el a
programkódban. Ennek a struktúrája így néz ki:
if(logikai kifejezés){
igaz_ág
} elseif (logikai kifejezés) {
igaz_ág_2
} else {
hamis_ág
}.
A többágú elágazás vezérlési szerkezete az switch, melynek szintaktikája:
switch (tesztkifejezés){
case tesztérték1:
ág_utasításai;
break;
case tesztérték2:
ág_utasításai;
break;
default:
különben_utasítások;
}.
26
Az ágak a tesztkifejezés után egyetlen kapcsos zárójelpár között helyezkednek el. Az egyes
ágak case kulcsszóval kezdődnek, amelyeket egy tesztérték, majd kettőspont követ. Minden
ág tetszőleges utasításokat tartalmazhat, de az utolsó szinte mindig a break. Amikor az
interpreter végrehajtja a switch utasítást, kiszámolja a tesztkifejezés értékét, majd megkeresi
az első olyan ágat, ahol a case kulcsszó utáni tesztérték megegyezik a tesztkifejezés kiszámolt
értékével. Ennek az ágnak az utasításait fogja végrehajtani. A breakre azért van szükség, mert
különben a kiválasztottat követő ág utasításait is végrehajtaná az értelmező. A break hatására
a vezérlés azonnal az elágazás (switch szerkezet) utáni első utasításra kerül.
A default különleges ág. Akkor kerül ide a vezérlés, ha az értelmező egyetlen, a tesztkifejezés
értékének megfelelő ágat sem talál. Ha nincs default ág, akkor ilyen esetben az elágazás utáni
részre kerül a vezérlés.
Példa:
<?php
$varos="Denver";
switch ($varos) {
case "San Diego";
case "Los Angeles";
case "Denver";
echo ("Amerikában van. <br/>");
break;
case "Budapest";
echo ("Európában van.<br/>");
break;
case "Tokio";
echo ("Ázsiában van.<br/>");
break;
default:
echo ("Nincs ilyen.<br/>");
}
?>
5.4.2. Ciklusok
A ciklusszervezési technikák is hasonlóan működnek, mint más programozási nyelvekben.
Beszélünk elöltesztelő, hátultesztelő és léptető ciklusokról. Nézzük meg, hogyan valósulnak
meg ezek a PHP nyelvén!
Elöltesztelő ciklus:
while(tesztkifejezés){
ciklusmag
}
27
Példa: A következő PHP-programmal kiíratjuk az amerikai városokat egy kívülről meghívott
állományból.
<?php
require ("amerikaivarosok.php")
$varosszam=count($varosok);
$i=0;
echo"Amerikai városok listája:";
while ($i<$varosszam){
echo "$i.város:", $varosok[$i]["neve"],"<br/>";
$i++;
}
?>
Hátultesztelő ciklus:
do{
ciklusmag
} while (tesztkifejezés)
Példa: A következő programrészlet a faktoriális számítással mutatja be a hátultesztelő ciklus

lényegét.
…
$n=5;
$i=1;
$fakt=1;
do {
$fakt*=$i;
$i++;
} while ($i<= $n);
echo ”$n!=$fakt”;
…
A léptető ciklus
Ezt a ciklusszervezési módot is használhatjuk az előző típusú feladatok megoldásához. Talán

elmondható az is, hogy a ciklusváltozó egyszerűbb kezelését eredményezi a for ciklus, amely
PHP nyelven a következőképpen alkalmazható:
for(kezdőértékadó kifejezés; logikai kifejezés; változtatás értékadó kifejezés){

ciklusmag
}
28
Amikor a ciklus kezdődik, a ciklusváltozó értéket kap. Ez az értékadás csak egyszer
zajlik le. Az értelmező mindig megvizsgálja azonban, hogy igaz-e a logikai kifejezés. Ha nem,
akkor átlépi a ciklusmagot és folytatja a programot. Ha igaz, akkor végrehajtja a ciklusmag
utasításait, majd a ciklusmag végén elvégzi a ciklusváltozót változtató kifejezést. Ezt követően
visszatér a ciklus elejére, és újra tesztel.
Példa: Az előző feladat alapján az amerikai városok kiírásához a következő for ciklust
szervezhetjük meg:
$varosszam=$varosok;
for ($i=0; $i<$varosszam; $i++) {
$szam=$i+1;
echo ” $szam. ”, $varosok[$i],”<br/>”;
}
Van egy speciális változata a léptető ciklusnak, a foreach ciklus. Tömbök bejárására
használatos leginkább ez a fajta módszer, miszerint a ciklusmag minden végrehajtása előtt a
ciklusváltozóba másolja az aktuális tömbelemet. Az egyes ismétlések alkalmával mindig a
következő elemet veszi. Az ismétlés addig tart, amíg a tömbelemek el nem fogytak. A
ciklusmagban mindig a ciklusváltozó tartalmazza az aktuális tömbelemet.
Szintaktikája a következő:
foraeach(tömbváltozó as ciklusváltozó){
ciklusmag
}
A ciklusoknál is beszélhetünk egymásba ágyazásról. Ez azt jelenti, hogy egy ciklus

magjában egy másik ciklust helyezünk el. Ilyenkor a befoglaló ciklust külső, a beágyazottat
belső ciklusnak nevezzük. A belső ciklus a külső ciklus minden egyes végrehajtásakor teljesen
végigfut, így ha a belső ciklus önmagában N-szer ismétlődne, a külső pedig M-szer, akkor a
belső ciklus végrehajtásszáma N*M lesz.
Az egymásba ágyazott ciklusok kiválóan alkalmasak többdimenziós tömbök
kezelésére.
Végül ciklusok használatával kapcsolatosan fontos megemlíteni olyan esetet, amikor
megszakítjuk a ciklus végrehajtását. A break és continue utasításokat lehet ilyenkor használni,
bár a gyakorlatban érdemes használatukat elkerülni. Break utasításhoz érve a ciklus
végrehajtását az értelmező azonnal megszakítja, és továbblép a ciklus utáni következő
utasításra. A continue esetén az értelmező nem a ciklusvég utáni utasításra lép, hanem vissza
a ciklusfejhez, és onnan folytatja a program utasításainak végrehajtását.
5.5. Függvények
Egy bonyolultabb program elkészítése PHP nyelven igen bonyolulttá válhat, ha nem figyelünk
oda kellőképpen a strukturáltságra. A strukturált felépítés sajátossága, hogy jól áttekinthető a
kód, mert az elkülönül fő programrészre és alprogramokra. Vagyis a jól megtervezett
29
programban az összetett feladatokat részfeladatokra bontjuk, amelyeket külön
alprogramokban oldunk meg. Ezeket az előre elkészített alprogramokat hívjuk meg a
főprogramba, vagyis elindítjuk a megfelelő alprogramot ott és annyiszor, ahol szükséges a
főprogramon belül. Miután az alprogram lefut, a főprogram folytatja a többi részének futtatását.
A részfeladatok megoldására szolgáló ezen alprogramokat hívjuk függvénynek. Ugyanúgy,
mint más nyelvekben (pl. JavaScript), a PHP-ban is tudunk létrehozni függvényeket, és vannak
úgynevezett beépített függvények is, amelyek adott részfeladatok megoldására alkalmasak.
Függvények használata esetén ismernünk kell még a paraméter és a visszatérési érték
fogalmakat. A bemenő paraméter a részfeladat kezdő értékeként értendő, ami ahhoz kell
esetlegesen, hogy a meghívott függvény ezen adato(ko)n, vagyis paraméter(ek)en el tudja
végezni az abban tárolt műveleteket. A visszatérési érték pedig az alprogram eredménye,
amelyet visszaad a főprogramnak, ami egy értékként kezeli tovább azt. A következőkben
nézzük meg, hogyan lehet függvényt létrehozni, majd a teljesség igénye nélkül, sorba vesszük
a PHP fontosabb beépített függvényeit.
5.5.1. Függvény létrehozása

Ha saját függvényt szeretnénk PHP-ban létrehozni, a következő meghatározott szintaxist kell
alkalmazni:
function függvénynév ([formális_paraméterlista]){

utasítások
[return visszatérési_érték]
}
formális_paraméterlista: Olyan, nem kötelező változók, amelyekre a függvénynek

szüksége van a működéshez. Ezekbe a változókba kerülnek azok az értékek, amelyekkel a
függvény dolgozni fog, és amelyek segítségével végrehajtja az utasításokat. Ahány
paraméterváltozót adunk meg a listában, annyi paramétert vár a függvény a végrehajtáshoz.
utasítások: Programsorok, melyek a függvény feladatát oldják meg.
return: Egy opcionális utasítás ahhoz, hogy visszatérési értéket adjon vissza a
függvény lefutása után a főprogramnak.
Példa egy egyszerű függvényre:
<?php
function negyzet($a)
{
return $a*$a;
}
print negyzetszamitas (10);
?>
Ebben a példában egy $a paraméter matematikai négyzetét kapjuk vissza eredményül

a negyzet nevű függvénytől, és a példa szerint 10-nek a négyzetét, vagyis 100-at fog kiírni a
képernyőre.
30
A következő példában egy kép pixelszámát határozzuk meg:
function gpixel($sor, $oszlop)

{
$pixel=$sor*$oszlop;
return $pixel;
}
Ez a példa, szerkezetét tekintve, abban különbözik az előzőtől, hogy két paramétert

vár a függvény, és az eredményt nem a kimenetre küldi, hanem visszaadja a főprogramnak
további felhasználásra a return utasítás segítségével. Ezt az eredményt, mint visszatérési
értéket, a főprogramban felhasználhatjuk arra, hogy egy változónak adjuk értékül.
Ha a return utasítás után nem szerepel semmilyen érték, a függvény futása akkor is
megszakad, de nem ad visszatérési értéket.
Egy függvényt többször is meghívhatunk a programban, tetszőleges helyen és időben.
Ha a visszatérési értékeket változókba szeretnénk tenni, akkor azt a következőképpen
adhatjuk meg:
$kep=pixel(1024,768);
Fontos! Alprogramok használatakor kétfajta változót használunk, a lokális és globális

változót. A főprogramban létrehozott változó globális, az alprogramban létrehozott pedig
lokális. A főprogram és az egyes alprogramok saját memóriaterülettel rendelkeznek, és
változóikat ezeken tárolják. A főprogram és a függvények is csak a saját memóriaterületükön
tárolódó változókhoz férnek hozzá. Így semmiféle hibát nem okoz, ha egy globális és egy
lokális, vagy két különböző függvény lokális változóinak neve megegyezik. Ezek különböző
változók, csak a nevük azonos.
A visszatérési érték vizsgálatakor felmerül egy kérdés. Mi történik akkor, ha a return
utasítással nemcsak egy, hanem több eredményértéket szeretnénk visszaadni a
főprogramnak? A PHP-ben egy függvény eredménye lehet akár numerikus vagy akár
asszociatív tömb is. Egy függvény visszaadott értéke bármilyen típusú lehet. Vagyis függvény
eredménye nemcsak egy érték lehet, hanem asszociatív tömb is.
Másik megoldási lehetőség a kérdésre, hogy úgynevezett címparamétert használunk.
Ennek szintaktikai jele a & jel és a következőképpen használhatjuk:
<?php
$kep=pixel(800,600, $pa, $mb);
echo ”800x600= $pa PX<hr/>”;
echo ”800x600= $mb MP<hr/>”;
function pixel($sor, $oszlop, &$p, &$m)

{
$pix=$sor*$oszlop;
$p=$pix/(1024*104);
31
$m=round($m,2);
}
?>
A program kimenete:
800x600 = 480000 PX
800x600 = 0.46 MP
A címparaméter használatakor a formális paraméterlistában elfoglalt helyükön

kizárólag változó állhat a függvény hívásakor. Az ilyen paraméterbe azonban nem a híváskor
megadott változó értéke, hanem a memóriabeli címe kerül. Így a függvényben csak a
paraméterváltozó neve lesz lokális, a néven keresztül a hívás helyén lévő változó értékéhez
lehet hozzáférni. A hívás helyén lévő változónévhez és a függvény címparaméteréhez ilyenkor
azonos memóriaterület kapcsolódik. Így a függvény át tudja írni a híváskor megadott változó
értékét.
A PHP lehetőséget ad arra is, hogyha egy függvény használatakor nem tudjuk előre a
bemenő paraméterek számát, akkor azt a nyelv úgy is le tudja kezelni. Vagyis elmondható,
hogy a PHP bármennyi (0 is lehet) paramétert le tud kezelni a függvényeken belül.
Végül a függvények létrehozásával kapcsolatban illik ismerni a statikus változó
fogalmát is. Ennek az a lényege, hogy a függvény befejeztével a változó által lefoglalt
memóriaterület nem szabadul fel. Erre akkor lehet szükség, ha azt szeretnénk, hogy a
függvényünk megőrizze egy előző állapot eredményét (pl. számok összegzésénél, amely
számok a függvény egyes hívásainak eredményei).
5.5.2. Beépített függvények

A következőkben összefoglaljuk a PHP programozási nyelvben előforduló beépített
függvények közül a legszükségesebbeket.
phpinfo() – a PHP-információk megjelenítésére szolgál (magáról a PHP-ről, a

kiszolgálói környezetről és a PHP-program változóiról).
include();– állományok beágyazása PHP-programokba, paramétere a fájl elérési útja.
Például a következő program kimenete „Utah” lesz:
Főprogram:
<?php
include("amerikaiallamok.php");
print $allam3;
?>
Beágyazott fájl (amerikaiallamok.php):
<?php
$allam1 = "Kalifornia";
32
$allam2 = "Arizona";
$allam3 = "Utah";
?>
array(); - tömb függvény (lásd: 8.3.5 fejezet).

ini_get() – PHP konfigurációs beállításainak a php.ini direktíváiban történő
lekérdezése.
isset() – egy változó létezésének ellenőrzésére szolgál. Logikai igaz eredményt ad
vissza, ha egy változó létezik, és értéke nem nulla.
unset() – törli a paraméterként megadott változókat.
get_type() – változók típusának lekérdezése.
set_type() – változók típusának megváltoztatása.
strlen(szöveg) – szöveg karakterszámát adja vissza.
mb_strlen(szöveg,kódolás) – adott kódolással tárolt szöveg karakterszámát adja meg.
strpos(szöveg,rész[,kezdet]) – azt a karakterpozíciót adja vissza, ahol a szövegben egy
szövegrész kezdődik.
count(tömb) – a paraméterként megadott tömb elemeinek számát határozza meg. Ha
a paraméter nem tömbváltozó, akkor az eredmény 1.
is_array(változó) – logikai eredménnyel jelzi, hogy a paraméterként kapott változó tömb
típusú-e.
in_str(ellenőrzött_érték, tömb,[típusellenőrzés]) – egy tömb elemei között szerepel-e
egy megadott érték.
5.6. Adatbázis-kezelás MySQL-lel
Eddigi fejezeteinkben megtanulhattuk, hogy a PHP hogyan tárolja az adatokat a változókban,

hogyan kezeli azokat. Viszont immár azt is tudjuk, hogy egy változó értéke alapvetően addig
tárolja a tartalmát, míg a program fut. Utána a számára lefoglalt memóriaterület felszabadul.
Ezzel szemben a mai webes alkalmazások triviálisnak mondható igénye, hogy az adatokat
időben és mennyiségben is tartósan, biztonságosan tárolja. Az ilyen jellegű feladatok
megoldására az adatbázis-kezelő rendszerek nyújtják a megoldást. Ezért fontosnak tartjuk,
hogy ismereteket szerezzünk a PHP MySQL-adatbázisokkal való kezelési lehetőségeiről. Ez
a fejezet körülöleli a legfontosabb ismereteket a PHP és az adatbázis kapcsolódásáról, a
szerver által küldött adatok feldolgozásáról, adatok lekérdezéséről, rögzítéséről és
módosításáról.
5.6.1. Műveletek az adatbázissal

Ahhoz, hogy adatbázis-kezelést tudjunk PHP-vel végrehajtani, szükség van a MySQL
adatbázisrendszerre, amellyel első lépésként kapcsolatot kell létrehozni. Az XAMPP
alkalmazáscsomag tartalmazza ezt, aminek telepítését már előzőleg bemutattuk (lásd.8.1
fejezet). A MySQL-lel történő kapcsolat létrehozásához egy csatoló felületre (API – Application
Programming Interface) is szükségünk van, és ugyancsak ennek segítségével tudjuk
elvégezni a kívánt műveleteket. Miután létrehoztuk a kapcsolatot, ki kell választani a használni
kívánt adatbázist. Meg kell fogalmazni a kért utasításokat, ezeket egy következő lépésként el
kell küldeni a MySQL-nek. Majd a szervertől kapott választ kell feldolgozni, és amennyiben
33
szükséges, egy kimeneten meg kell jeleníteni az eredményeket. Végül, ha már nincs
szükségünk az adatbázisra, nagyon fontos, hogy szakítsuk meg a MySQL-lel a kapcsolatot
egy utolsó lépésként.
A PHP–MySQL kapcsolat létrehozását a mysql_connect() függvénnyel végezhetjük el.
Az alábbi kódrészlet szerint egy localhoston lévő MySQL szerverrel szeretnénk csatlakozni,
application felhasználó névvel és amerika jelszóval.
$host="localhost";
$felhaszn="application";
$jelsz="amerika";
$con=mysql_connect($host,felhaszn,$jelsz)
Az alábbi kódrészlet pedig egy elágazásban a kapcsolat hibáját figyeli, és ha hiba lép
fel kapcsolódáskor, egy üzenetet küld a kimenetre és leállítja a folyamatot.
if (!$con=mysql_connect($host,$felhaszn,$jelsz)) die("Sikertelen kapcsolódás");
Mivel „sosem lehet tudni…”, ezért érdemes a kapcsolódási kísérletet ilyen módon
elvégezni. A mysql_close() függvénnyel tudjuk lezárni a megnyitott kapcsolatot. Egy
paramétere van, ami a mysql_connect() által visszaadott resource. Visszatérése egy logikai
érték, attól függően, hogy sikerült-e lezárni a kapcsolatot, ami elvileg csak abban az esetben
nem sikerülhet, ha már megnyitni se tudtuk.
Miután sikeresen kapcsolódtunk, érdemes megadni az alapértelmezett adatbázist, amit
használni akarunk, így nem kell minden egyes lekérdezésbe beleírni a nevét. Ezt úgy is
mondhatjuk, hogy miután sikeresen kapcsolódtunk a MySQL szerverhez, ki kell választanunk
a webalkalmazás adatait tároló adatbázist:
if (!$kiv=mysql_select_db($adatbnev)) die (” Az $adatbnev adatbázis nem elérhető!”);
Mielőtt rátérünk a lekérdezésekre, egy fontos opcionális problémát érdemes tisztázni.

Gyakran előfordulhat szövegkezelés esetén, hogy a magyar ékezetes betűket nem szépen,
azaz összevissza karakterekkel jeleníti meg. Ez a probléma akkor fordulhat elő, ha a PHP-
fájlunk és a szöveges állomány nem egyforma karakterkódolású. Ha adatbázist használunk,
akkor a programkódolásnak meg kell egyeznie a HTML-kód fejlécében (pl. <meta
charset="UTF-8" />) megadott karakterkódolással, az adatbázis létrehozásakor megadott
karakterkódolással és az adatbázissal történő kommunikációnál használt karakterkódolással
is. Magyar kódolás esetén az ISO-8859-2 karakterszettet érdemes használni, mert abban
benne van az összes magyar karakter. Az UTF-8-ban viszont szinte minden nyelv karakterei
benne vannak, így, ha biztosak akarunk lenni, akkor érdemes ezt használni. Ezért az
adatbázishoz történő kapcsolódás után célszerű kiadni egy SQL-utasítást a mysql_query()
függvény segítségével:
mysql_query(" SET NAMES 'UTF8' ");
Ezek után jöhetnek a lekérdezések.
34
Tábla sorainak kiíratása úgy történik, hogy először lekérdezzük a tábla tartalmát, majd
az így kapott eredményen végigmegyünk valamilyen MySQL-függvénnyel. A lekérdezéshez
egy SQL nyelven írt utasítást kell adnunk az adatbázis-szervernek, és az így kapott eredményt
kell kinyernünk. SQL-utasítások futtatására a mysql_query() függvény szolgál. A függvénynek
egy karakterlánc-paramétere van, ami egy vagy több SQL nyelven írt utasítást tartalmaz.
Pl.
$eredmeny = mysql_query("SELECT * FROM àllamok`");

if (!$eredmeny)
{
exit("Sikertelen művelet!");
}
A SELECT * FROM àllamok` SQL lekérdezés a teljes allamok nevű táblát adja vissza.
Az if ág után kell beolvasnunk az $eredmeny változót. Jobb megoldás lenne, ha a táblázat
tartalmát egy kétdimenziós tömbbe raknánk. Ezt megtehetjük a mysql_fetch_assoc()
függvénnyel. Ennek a függvénynek a visszatérési értéke egy asszociatív tömb, amiben a tábla
egy sora van. Ahhoz, hogy minden sort kiírjunk, addig kell meghívnunk ezt a függvényt, amíg
a visszatérési értéke false nem lesz, mert az azt jelenti, hogy nincs több sor. A tömb tartalmát
pedig például a következőképpen írathatjuk ki:
$allamok = array();
while ($sor = mysql_fetch_assoc($eredmeny))
{
$allamok[] = $sor;
}
print '<allamok>';
foreach ($allamok as $sor)
{
print '<tr>';
foreach ($sor as $ertek){
print '<td>'.$ertek.'</td>';
}
print '</tr>';
}
print '<allamok>';
Nézzük meg, hogy épül fel kompletten a teljes program a következő példán keresztül:
<?php
$con = mysql_connect("localhost", "application", "amerika")
or exit("Sikertelen kapcsolódás!");
mysql_select_db("gyakorlas")
35
or exit("Sikertelen adatbázis megnyitás!");
mysql_query("SET NAMES 'UTF8'");
$eredmeny = mysql_query("SELECT * FROM àllamok`");

if (!$eredmeny){
exit("Hibás lekérdezés!");
}
$tabla = array();
while ($sor = mysql_fetch_assoc($eredmeny)){
$tabla[] = $sor;
}
mysql_close($connect);
?>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>Gyakorlás</title>
</head>
<body>
<table>
<?php foreach ($tabla as $sor)
{
?>
<tr>
<?php foreach ($sor as $ertek)
{
?>
<td><?php print $ertek; ?></td>
<?php
}
?>
</tr>
<?php
}
?>
<table>
</body>
</html>
A rekordok kinyerésének másik megoldási lehetősége a mysql_fetch_row()

függvénnyel történhet. Ennek helyes használatát a következő példa szemlélteti:
…
$eredmeny = "SELECT * FROM allamok";
…
36
…
$eredmeny=mysql_query($eredmeny);
while ($sor=mysql_fetch_row($eredmeny))
{
foreach ($sor as $mezo)
{
echo ” $ mezo, ”;
}
echo ”<br/>”;
}
mysql_close();
…
További néhány fontos függvény:
mysql_num_rows(erőforrás_id) – lekérdezés rekordszámát adja vissza,

mysql_num_fields(erőforrás_id) – visszatérési értéke az eredmény-halmaz mezőszáma,
mezőneveket tudhatunk meg vele.
mysql_field_name(erőforrás_id,mező_sorszám) – visszatérési értéke a megadott
eredményhalmaz meghatározott sorszámú mezőneve.
mysql_free_result() – erőforrás felszabadítása.
A fenti lekérdező függvények és utasítások után nézzük meg, hogy lehet módosítani
adatbázisban tárolt adatokat. Az úgynevezett DML- (Data Manipulation Language) utasítások
abban térnek el az előzőektől, hogy nincs kilistázható eredményük (pl. tábla, tömb), hanem
egyszerűen true vagy false értékkel térnek vissza. Ilyen parancsok az UPDATE, a DELETE és
az INSERT.
Nézzünk meg egy példát az UPDATE használatára.
<?php
header=(„Content-type: text/html; charset=utf-8”);
$sql=”SELECT* FROM allamok”;
$dml=UPDATE allamok SET NEv=’ARIZONA’ where idAllamok=3”;
create_conn();
if (!$res=mysql_query($sql)) die (”Sikertelen lekérdezés!”);
echo ”<b>Előtte:</b>”;
write_table($res, ”Államok:”);
if (!$res=mysql_query($dml)) die (”A frissítés sikertelen! $dml”);

if (!$res=mysql_query($sql)) die (”Sikertelen lekérdezés!”);
echo ”<b>Utána:</b>”;
write_table($res, ”Államok:”);
mysql_close();
?>
37
A program eredménye az UPDATE utasítás előtt és után:
Előtte:
Államok:
idAllamok Nev
1 Kalifornia
2 Colorado
3 Arizona
4 Utah
Utána:
Államok:
idAllamok Nev
1 Kalifornia
2 Colorado
3 ARIZONA
4 Utah
5.7. Objektumok a PHP-ben
A PHP eredetileg strukturált programozási nyelvnek indult, de mára már az objektumorientált

programozás elterjedésével ez a nyelv is alkalmassá vált az objektumok kezelésére. Ebben a
fejezetben sorba vesszük az osztályokkal és az objektumokkal kapcsolatos fontosabb
ismeretanyagot, melynek körébe tartozik az objektum, az osztály, a konstruktor létrehozása,
hivatkozások objektumok tulajdonságaira és metódusaira.
Az objektumorientált programozás jelentősége a procedurális programozással
szemben abban rejlik, hogy a valós világot próbáljuk vele lemodellezni. Az objektum nem más,
mint a világ egy önálló, elkülönülő dolga, pl. személy, tárgy, fogalom stb. Az objektumok
úgynevezett osztályokba sorolhatók tulajdonságaik, tevékenységeik alapján. Egy osztályra
jellemző, hogy egységbe zárja az objektumaira jellemző tulajdonságokat, sajátosságokat. Az
adattagok pedig tulajdonképpen a változók, amelyekben tárolódnak a tulajdonságok értékei.
Végül van még egy fontos fogalom, a metódus, ami leginkább a függvénynek feleltethető meg.
Az objektumokat más néven példányoknak is nevezzük.
Példa:
Osztály: Állam
Adattag: Név
Adattag: Népesség
Adattag: Terület
Adattag: Nyelv
Metódus: Tevékenység()
Metódus: Fejlődik()
Van az úgynevezett kód-újrahasznosítás. Ez azt jelenti, hogy az osztály alapján

létrehozott objektumok mind rendelkeznek az osztály összes metódusával és adattagjával, így
38
az egyes objektumok számára nem kell külön kódot írni. A PHP a nyíl (->) operátorral teszi
elérhetővé egy objektum valamely tulajdonságát vagy metódusát:
objektumnev->adattag,
objektumnev->metodus() .
Kezdetben minden objektum egyforma, de adattagjaik értékének beállításával

megkülönböztethetjük, metódusaik segítségével pedig vezéreljük őket. Az objektumok
kezelésével kapcsolatban még két fontos fogalmat kell tudni. Ezek az öröklődés és a
polimorfizmus.
Abban az esetben, ha két osztály több adattagban és metódusban is megegyezik,
akkor az objektumorientáltság megengedi, hogy az egyik osztály örökölje a másik
tulajdonságait. Vagyis létrehozásnál ezt érdemes szem előtt tartani: amikor egy meglévő
osztályból tudunk létrehozni egy másikat a közös tulajdonságok alapján. Például, ha vesszük
az Állam osztályt és abból származtathatunk egy Kontinens osztályt is. Az objektumorientált
programozásban öröklődésnek nevezik azt a lehetőséget, amikor egy osztály, létrehozáskor
átveszi egy másik, már létező osztály kódját. Szülő osztálynak nevezzük az örökítőt,
származtatottnak az öröklő osztályt. Az öröklődés a kód újrahasznosításának másik
lehetősége. Amikor létrehozunk egy származtatott osztályt, abba új metódusokat vagy
adattagokat is helyezhetünk. Például, ha létezik a Kontinens osztály és abból leszármaztatjuk
az Európa és Amerika osztályokat, és Európa kap az Amerikától különböző adattagokat, akkor
polimorf úton jártunk el. Vagyis, ha egy származtatott osztály adattagjait kiegészítjük,
megváltoztatjuk, akkor az alkalmazott technikát polimorfizmusnak hívjuk.
Az objektumorientált nyelv sajátossága abban rejlik, hogy ezeket a dolgokat el lehet
végezni vele. Vagyis osztályokat, objektumokat lehet létrehozni, adattagokat, metódusokat
lehet meghatározni.
A PHP rendelkezik olyan osztállyal (ez a mysqli), amit előre definiáltak és adattagjaival,
metódusaival olyan műveleteket is el lehet végezni, amelyeket a procedurális módszerrel. Az
osztályok egyes objektumai speciális objektumváltozók, amelynek szintaktikája: változó=new
osztálynév([paraméterek]); és ezzel az úgynevezett konstruktort indítjuk el. Létrehozza a
példányt és beállítja a fontosabb tulajdonságainak a kezdőértékét.
Példa:
$db = new mysqli("localhost", "application", "amerika", "allamok");
$res=$db->mysql_query("SELECT * FROM allam");
Osztály létrehozásának szintaktikája:
class osztálynév {
adattagok
metódusok
}
39
Példa:
$orszag= new allam();

$orszag->set_name(”Colorado”);
echo $valaki->get_name();
class allam
{
var $nev;
function set_name($Nev);
{
$this->nev=$Nev;
}
function get_name()
{
return $this->nev;
}
}
A fenti osztálynak egy adattagja ($nev) és két metódusa (get_name, set_name) van. A
set_name a $nev adattagban tárolja az átvett paraméter értékét, a get_name pedig
visszatérési értékként adja vissza.
Adattagok és metódusok láthatóságát lehet szabályozni a public, private vagy a
protected kulcsszavakkal. A public az alapértelmezett.
A konstruktor segítségével azonnal be tudjuk állítani az objektum tulajdonságait (new
osztály).
Az feljebb definiált öröklődés szintaktikája pedig a következő:
class származtatott extends szülő

{
osztály_kódja
}
Az objektumorientált programozás tekintetében a PHP kevés megkötést tartalmaz. A
főprogram tartalmazza az osztályt, de akár külön programban is elhelyezhetjük. Egy fontos
szabály van, hogy a származtatott osztálynak a szülő osztály után kell elhelyezkednie a
forráskódban. Összefoglalva a következő kulcsszavak a legfontosabbak:
class – osztály létrehozása,
var – változó deklarálása,
public
private – metódusok és adattagok hozzáférésének szabályozása,
protected
construct – speciális metódus, a létrehozáskor átadott paramétereket kapja meg. Objektum
alaphelyzet beállítása,
destruct – speciális metódus, objektum megszüntetésekor kap vezérlést,
40
$this – speciális változó, hivatkozás az objektum saját elemeire,
parent: – származtatásnál a szülő osztály kódjának elérése.
5.8. Egyéb lehetőségek
Elérkeztünk jegyzetünk utolsó fejezetéhez. Az eddigiekben igyekeztünk a PHP programozási

nyelvről szóló ismereteinket megalapozni, és egy átfogó keretet adni az abban rejlő
lehetőségekről. Azt is nyugtázhatjuk viszont, hogy szinte kimeríthetetlen azoknak a
technikáknak, megvalósítási ötleteknek a tárháza, amelyet használhatunk webfejlesztés
során. Ennek a jegyzetnek az alapok átadása a feladata, és egyúttal továbbfejlődési
lehetőséget kínálni a hallgatóknak. A PHP programozási nyelv témájának zárásaként néhány,
eddig be nem sorolt lehetőséget szeretnénk megemlíteni, amelyek praktikus ismereteket
nyújtanak fejlesztő munkánk során.
5.8.1. Felhasználó kezelése

Dinamikus weboldalak fejlesztése során nagy jelentősége lehet annak, hogy kik látogatják
majd a kifejlesztett weboldalainkat. Egy külső látogató, a tulajdonos személye vagy éppen a
szerkesztő is a látogatók csoportjába tartozik, így nem utolsó szempont, ha ezeket rendben
tudjuk követni és tartani.
Lehetőség van olyan információcsomagok kezelésére, amelyeket a szerver küld a
böngészőnek, majd a böngésző visszaküld a szervernek minden, a szerver felé irányított kérés
alkalmával. Ezeket hívjuk sütiknek, vagy idegen szóval cookie-knak. Sütiket leggyakrabban
egy adott weboldal regisztrált felhasználóinak azonosítására, „bevásárlókosár”
nyilvántartására vagy látogatok nyomon követésére használnak. Sütifájloknak nevezzük
azokat az állományokat, amelyekben szöveges formában tároljuk a sütik tartalmát úgy, hogy
azt megőrizze a böngésző kikapcsolása és újraindítása során is. A sütikkel kapcsolatos
alapvető műveletek a süti létrehozása, kiolvasása és törlése. Nézzük meg ezek
megvalósításait!
Süti létrehozása:
setcookie(name, value, expire, path, domain);
Fontos: A setcookie függvényt a doctype és a html tag előtt kell meghívnunk.
Példa:
<?php
setcookie("felhaszn", "Amerika", time()+3600);
?>
<html>
<body>
</body>
</html>
41
Ebben a példában egy felhaszn nevű sütit hoztunk létre, Amerika értéket
hozzárendelve, és egy órában határozzuk meg az érvényességi időt.
A süti kiolvasása a következőképpen történhet:
<?php
echo $suti["felhaszn"];
print_r($suti);
?>
Az isset függvény segítségével ellenőrizzük, hogy érkezett-e süti.
<html>
<body>
<?php
if (isset($suti["felhaszn"]))
echo "Üdvözlet! " . $suti["felhaszn"] . "!<br>";
else
echo "Jó napot!<br>";
?>
</body>
</html>
Süti törlése az érvényességi idő beállításával történhet.
<?php
setcookie("felhaszn", "", time()-3600);
?>
A sütik kezelésén kívül beszélünk a munkamenet kezeléséről is, mint felhasználó

kezeléséről. Ez a session, és arra használjuk, hogy információt tároljon a felhasználó
beállításairól vagy annak megváltozásáról. A session_start függvénynek a doctype és a html
tag előtt kell szerepelnie:
<?php session_start();
?>
<html>
<body>
</body>
</html>
A session változók tárolása és visszaolvasása a $_SESSION változóval lehetséges:
<?php
session_start();
42
$_SESSION['nezetek']=1;
?>
<html>
<body>
<?php
echo "Pageviews=". $_SESSION['nezetek'];
?>
</body>
</html>
Egy session változó törlésére az unset függvényt, a teljes session törlésére pedig a
session_destroy függvényt alkalmazzuk.
5.8.2. Hiba- és kivételkezelés

Amikor webalkalmazást fejlesztünk, elengedhetetlen, hogy foglalkozzunk a hibák kezelésével
is. A PHP-ben a hibák kezelésére használjuk a die() függvényt, egyéb hibakezelő
függvényeket, és kivételkezelő módszereket.
A die() használata egy példán keresztül:
Egy szövegfájlt nyitunk meg:
$file=fopen("amerika.txt","r");
Ha a fájl nem létezik, akkor a következő hibaüzenetet kapjuk:
Warning: fopen(amerika.txt) [function.fopen]: failed to open stream:

No such file or directory in C:\webfolder\test.php on line 2
Erre megoldást jelent, hogy megnézzük, a fájl valóban létezik-e, mielőtt megpróbálnánk
hozzáférni:
if (!file_exists("amerika.txt"))
{
die("Fájl nem található!");
} else
{
$file=fopen("amerika.txt","r");
}
Természetesen a fenti eseten kívül más hibákat is tudnunk kell kezelni, így szükséges
készítenünk hibakezelő függvényt. Egy speciális függvényt kell létrehozni, ami meghívható,
ha hiba merül fel futás közben. Legalább kettő (hiba szintje és hibaüzenet) és maximum öt
paramétert (fájl, a sor száma és a hiba környezete) fogadhat el a függvény.
43
Szintaktika:
error_function (error_level,error_message, error_file, error_line,error_context)
error_level: Kötelező. Megadja, hogy milyen hibákat akarunk lekezelni.

error_message: Kötelező. A hibaüzenetet tartalmazza.
error_file: Nem kötelező. A fájl nevét tartalmazza, ahol a hiba felmerült.
error_line: Nem kötelező. A sor szamát tartalmazza.
error_context: Nem kötelező. Egy tömb, amely tartalmaz minden használt valtozót, értéket.
5. táblázat Hibakezelés
Érték Konstans Leírás
1 E_ERROR Nem kezelhető futásidejű hiba. A program végrehajtása
megszakad.
2 E_WARNING Figyelmeztetés kezelhető futásidejű hibára. A program
végrehajtása folytatódik.
4 E_PARSE Fordításidejű hiba. A kódelemző generálja, még a futás
előtt. A program végrehajtása nem kezdődik meg.
8 E_NOTICE Futásidejű megjegyzés. Az értelmező lehetséges
hibaforrást talált. A végrehajtás nem szakad meg, ugyanis
nem biztos, hogy valóban bekövetkezik a hiba.
256 E_USER_ERROR A felhasználó által dobott problémát jelző hiba.
Súlyossága az E_ERROR-hoz hasonló, azonban ezt nem
a PHP, hanem a felhasználó generálja a trigger_error ()
függvénnyel.
512 E_USER_WARNING A felhasználó által, a trigger_error() függvénnyel generált
E_WARNING súlyú figyelmeztetés.
1024 E_USER_NOTICE A felhasználó által generált, E_NOTICE súlyú hiba.
4096 E_RECOVERABLE_ Elkapható, de végzetes hiba. Olyan hibát jelöl, ami nem
ERROR állította le a PHP-motort. Ha nem kezeljük a saját
hibakezelőben, akkor leállítja a szkriptet.
8192 E_DEPRECATED Olyan hiba, amit nem javasolt utasítások használatakor
küld az interpreter.
32767 E_ALL Ez a konstans az összes hibát és figyelmeztetést jelenti
egyben.
Egy másik hibakezelési módszer az objektumorientált programozásban, a kivételkezelés.
Kivételkezeles alkalmazásakor megváltoztatjuk az utasítások végrehajtásának eredeti
folyamatát hiba fellépése esetén. Gyakorlatilag ezt hívjuk kivételnek. Ebben az esetben az
éppen aktuális állapotot mentjük, és a végrehajtás átkerül egy másik, meghatározott
kivételkezelő kódra. A try, a throw és a catch utasítások használatosak a kivételkezelő kód
előállítására.
44
6. Gyakorló feladatok
Miután áttekintettük a webprogramozás elsajátításához szükséges ismereteket az elmélet
szintjén, az ebben a fejezetben található feladatokkal gyakorolhatjuk, kipróbálhatjuk az
eddigieket. HTML-, JavaScript- és PHP-feladatok következnek, az egyszerűbbtől a
nehezebbig. A feladatleírások után megadjuk a megoldásokat, illetve a megoldások kulcsát.
Javaslat: a feladatokat a jegyzet egyes fejezeteinek áttanulmányozás után érdemes

megoldani, ezzel is elősegítve és hatékonyabbá téve a megértést és a tanulást.
6.1. HTML gyakorló feladatok
1. Készítsen HTML-dokumentumot, amely kiírja a diákok személyi adatait. Használja a

következő jelölőelemeket: strong, br, b, p, em, i, u, address.
8. ábra 1. HTML-feladat
Megoldás:
<!doctype html>
<html lang=”en”>
<head>
<title>1. Példa</title>
</head>
<body>
<strong>Személyi adatok</strong>
<br /><br />
<b>Diákok Mesevárosból:</b>
<p>
<em>Kovács János
45
<br />
Virág u. 2.
</em>
<br />
<i>Meseváros</i>
<br />
<u>00-36-30-222-3334</u>
<br /><br />
<address>
Nagy Elemér
<br />
Fő út 111.
<br />
Meseváros
</address>
</p>
</body>
</html>
2. Készítsen HTML-dokumentumot, amely megjelenít két vízszintes vonalat és az

Amerika szöveget kiírja hat címszinten!
Megoldás:
<!doctype html>
<head>
</head>
46
<body>
<hr />
<h1>Amerika</h1>
<h2>Amerika</h2>
<h3>Amerika</h3>
<h4>Amerika</h4>
<h5>Amerika</h5>
<h6>Amerika</h6>
<hr />
</body>
</html>
3. Készítsen HTML-dokumentumot, amelyben a következő hiperhivatkozások

szerepelnek:
- második oldalra (masodik.html)
- http://www.mik.pte.hu webcímre!
Megoldás:
<!doctype html>
<head>
<title>3. Példa </title>
</head>
<body>
<h2>Hiperhivatkozások</h2>
<br />
<a href="masodik.html"> Hiperhivatkozás a második oldalra </a>
<br />
<br />
<a href="http://www.mik.pte.hu">www.mik.pte.hu</a>
</body>
47
</html>
4. Készítsen HTML-dokumentumot, amely az ábrán látható táblázatot jeleníti meg egy

tetszőleges képpel!

Megoldás:
<!doctype html>
<head>
<title>Példa 19</title>
</head>
<body>
<table border="1" align="center">
<caption><b>HTML táblázat</b></caption>
<thead>
<tr>
<th>Információ</th>
<th>Kép</th>
</tr>
</thead>
<tbody>
<tr>
<td>Encinitas</td>
<td rowspan="2"><img src="encinitas.jpg" border="0" id="kep" width="175"
height="240" alt="NINCS KÉP" /></td>
</tr>
<tr>
<td>Kalifornia</td>
</tr>
</tbody>
</table>
</body>
</html>
5. Hozzon létre HTML-dokumentumot, amely az ábrán látható keretekkel osztja fel a
lapot!
48
12. ábra 5. HTML feladat
Megoldás:
<!doctype html>
<head>
</head>
<frameset rows="25%,*">
<noframes>
<body>

</body>
</noframes>
<frame id="keret1" name="keret1" src="keret1.html" noresize="noresize"
scrolling="auto" frameborder="1" />
<frameset cols="25%,*">
<frame id="keret2" name="keret2" src="keret2.html" scrolling="no"
frameborder="1" />
<frame id="keret3" name="keret3" src="keret3.html" scrolling="no"
frameborder="1" />
</frameset>
</frameset>
</html>
6. Készítsen HTML-dokumentumot, amely weboldalon belüli keretet hoz létre az ábra

szerint!
49
Megoldás:
<!doctype html>
<head>
</head>
<body>
<p><h1>Amerika</h1></p>
<iframe id="keret" name="keret" src="masodik.html" width="200" height="100"
scrolling="auto" frameborder="1"></iframe>
</body>
</html>
7. Készítsen egy regisztrációs űrlapot szerkesztő HTML-dokumentumot megfelelő

alapértelmezett beállításokkal! Az űrlapon a képen látható objektumok szerepeljenek. A
mégsem gomb törölje az addig beírtakat, és állítsa vissza az alapértelmezett adatokat. A küld
gomb a beírt adatokat küldje a reg.php szkriptnek, amely feldolgozza az űrlapon megadott
adatot.
50
Megoldás:
<!doctype html>
<head>
</head>
<body>
<form id="urlap" name="urlap" method="post" action="reg.php"
enctype="multipart/form-data">
Regisztráld magad, írd be az összes adatod!<br />
<br />
<fieldset>
<legend><strong>Személyi adatok</strong></legend>
<label>vezetéknév:</label>
<input type="text" id="vnev" name="vnev" />
<br />
<label>keresztnév:</label>
<input type="text" id="nev" name="nev" />
<br />
<label>e-mail:</label>
<input type="text" id="email" name="email" />
<br />
<label>jelszó:</label>
<input type="password" id="jelszo" name="jelszo" />
<br />
<label>kép:</label><input type="file" id="kep" name="kep" />
<br />
51
<br />
<label>operációs rendszer:</label>
<input type="checkbox" id="or" name="or" value="windows" />windows
<input type="checkbox" id="or" name="or" value="linux" />linux
<br />
<br />
<label>megjegyzések</label>
<br />
<textarea id="megjegyzes" name="megjegyzes" rows="3" cols="20" ></textarea>
<br />
<br />
<input type="submit" id="gomb" name="gomb" value="küld" />
<input type="reset" id="gombr" name="gombr" value="mégsem" />
<br />
<br />
</fieldset>
</form>
</body>
</html>
6.2. JavaScript gyakorló feladatok
1. Készítsen olyan HTML-dokumentumot, amely a csatolt JavaScript program

segítségével kiír szöveget és egy üdvözlő üzenetet is megjelenít a bevitt név részére az ábra
szerint.
15. ábra 1. JavaScript-feladat

Megoldás:
<!doctype html>
<head>
<title> 1 Példa </title>
<noscript>
Az ön böngészoje nem támogatja a JavaScriptet!
</noscript>
<script type="text/javascript" src="script.js">
52

</script>
</head>
<body>
<br />
<br />
Gyakoroljuk a JavaScriptet!<br /><br />
<form name="udvozlet" id="udvozlet" onsubmit="szia();" >
<input type="text" name="nev" id="nev" />
<input type="submit" value="Személyes üdvözlet" />
</form>
</body>
</html>
JavaScript-kód:
document.write("<strong><i>JavaScript feladat</i></strong>");
function szia()
{
var t=document.forms.udvozlet.nev.value;
alert("Szia "+t);
}
2. Készítsen HTML-dokumentumot, amely az onmouseover, onmouseout, onmouseup és

onmousedown JavaScript eseményszkriptek segítségével manipulál a képpel.
Megoldás:
<!doctype html>
<head>
<noscript>
</noscript>
<script type="text/javascript" >

//-->
</script>
</head>
<body>
<i> onmouseover, onmouseout, onmouseup & onmousedown</i>
<br /><br />
<img src="kepjs1.jpg" name="kep" alt="kep 1" onmouseover="valt_kepet()"
onmouseout="visza_kepet()" onmouseup="valt_kepet()" onmousedown="norm()"/>
</body>
</html>
54
3. Készítsen HTML-dokumentumot, amely az onclick, ondblclick, onkeypress és
onkeydown JavaScript eseményszkripteket kezeli. Az oldal tartalmazzon egy gombot,
amelynek segítségével kinyomtathatjuk az oldalt.
Ábra az első lépésről:
16. ábra 3. JavaScript-feladat I.
Ábra a második lépésről:
17. ábra 3. JavaScript-feladat II.
Ábra a harmadik lépésről:
55
18. ábra 3. JavaScript-feladat III.
Megoldás:
<!doctype html>
<head>
<title> 3. Példa </title>
<noscript>
</noscript>
<script type="text/javascript" >

</script>
</head>
<body>
Java Script:
56
<i> onclick, ondblclick, onkeypress & onkeydown</i>
<br /><br />
<img src="kepjs1.jpg" id="kep" ondblclick="height=height+10" />
<br /><br />
<input type="button" value="Nyomtast ki az oldalt" onclick="printpage()" />
<form action="harmadikjs.html" method="post" id="myform" name="myform">
<label>megjegyzés</label><input type="text" name="szoveg"
onkeypress="changeBg1()" onkeydown="changeBg2()" />
</form>
</body>
</html>
6.3. PHP gyakorló feladatok
1. Készítsen egy PHP-szkriptet, amely kiírja a következő szöveget!
Üdvözlet
Amerikából!
Kovács Lujza
Megoldás:
<?php
echo "Üdvözlet";
echo "<br />Amerikából!";
echo "<br /><b>Kovács Lujza</b>";
?>
2. Készítsen egy PHP szkriptet, amely kiírja négy változó értékét és típusát!
Példa kimenetre:
1. változó (Amerika) – string

2. változó (2015) – integer
3. változó (65.4) – double
4. változó (11.111) – double
Megoldás:
<?php
$1valtozo = "Amerika";
$2valtozo= 2015;
$3valtozo= 65.4;
$4valtozo= 11.111;
$tipus1=gettype($1valtozo);
57
echo "<br />1. változó ($1valtozo) - $tipus1";

?>
3. Készítsen egy PHP-szkriptet, amely létrehoz két tömböt és kiírja a tömbök adatait. Az
elsö tömb országokat, a második pedig városneveket tartalmazzon!
Megoldás:
<?php
$orszag[0]="Kalifornia";
$orszag[1]="Új-Mexikó";
$orszag[2]="Nevada";
$varos[0][0]="Los Angeles";
$varos[0][1]="Santa Fe";
$varos[0][2]="Las Vegas";
echo" <br>$orszag[0], $orszag[1], $orszag[2]";
echo" <br>{$varos[0][0]}, {$varos[0][1], {$varos[0][2], }";
?>
4. Készítsen egy PHP-szkriptet, amely kiszámolja és kiírja a kör kerületét és területét!
Megoldás:
<?php
define("PI",3.14);
$rad=15;
$kerulet=$rad*$rad*PI;
$terulet=2*$rad*PI;
echo "<br />A kör kerülete = $kerulet";
echo "<br />A kör területe = $terület";
?>
5. Készítsen egy PHP-szkriptet, amely az if-else elágazás segítségével kiírja az amerikai

dollár valutaárfolyamát!
Példa kimenetre:
Amerikai dollár árfolyam(Ft): 270
Megoldás:
58
<?php
$dolcsi=270;
if($dolcsi!=280)
echo ("Amerikai dollár árfolyam(Ft):$dolcsi");
else
echo ("Érdekes árfolyam!");
?>
6. Készítsen egy PHP-szkriptet, amely az időponttól függően kiírja a megfelelő szöveget,

és megjeleníti a megfelelő képet! Ha az időpont 12 h-nál nagyobb, akkor jelenítsen meg egy
fehér színű szöveget: „Finom volt az ebéd!” és egy képet kedvenc ételéről. Az oldal háttérszíne
legyen kék. Abban az esetben, ha 12-nél kisebb, jelenítsen meg egy fekete színű szöveget:
„Éhes vagyok!” és egy képet, amely egy üres tányért ábrázol. Az oldal háttérszíne legyen
sárga!
Megoldás:
<head>
<title>php 8 - <?php echo Date("F d, Y") ?></title>
</head>
<?php
$ora=Date(H);
if ($ora<12)
{
$szin="yellow";
$uzenet="Éhes vagyok!";
$betuszin="black";
$kep="kep1.jpg";
}
else
{
$szin="blue";
$uzenet="Finom volt az ebéd!";
$betuszin="white";
$kep="kep2.jpg";
}
echo"<body style=\"background-color:$szin;\">";
echo"<p style=\"color:$betuszin\">$uzenet</p>";
echo"<img src=\"$kep\" alt=\"\" ide=\"kep\" name=\"kep\" />";
?>
59
7. Készítsen egy weboldalt, amely egy űrlapot jelenít meg! Az űrlap tartalmazzon:
– egy szövegmezőt (név)
– hat rádiógombot (piros, kék és zöld szín, Arial, Verdana és Tahoma betűtípus)
– egy legördülő menüt (betűméretek 10-18)
– send gombot.
A send gomb küldje az adatokat a f7.php szkriptnek, amely feldolgozza az űrlapon megadott
adatot. Az f7.php szkript jelenítsen meg a bevitt név részére (a választott színben, a választott
betűtípussal és betűmérettel) egy üdvözletet.
Megoldás:
<!doctype html>
<head>
<title>7. PHP feladat </title>
</head>
<body>
<form method="post" action="f7.php">
<input type="text" id="nev" name="nev" /><br /><hr />
<input type="radio" value="red" name="szin" id="szin" checked="checked" />red<br />
<input type="radio" value="green" name="szin" id="szin" />green<br />
<input type="radio" value="blue" name="szin" id="szin" />blue<br />
<hr />
<input type="radio" value="Arial" name="ftipus" id="ftipus" checked="checked" />Arial<br />
<input type="radio" value="Verdana" name="ftipus" id="ftipus"/>Verdana<br />
<input type="radio" value="Tahoma" name="ftipus" id="ftipus"/>Tahoma<br /><hr />
<select name="meret" id="meret">
<option value="10">10</option>
</select><hr />
<input type="submit" name="gomb" value="send" />
</form>
</body>
</html>
A HTML-kód:
<!doctype html>
<head>
<title>7. PHP feladat</title>
</head>
60
<body>
<?php
$szin=$_POST["szin"];
$ftipus=$_POST["ftipus"];
$meret=$_POST["meret"];
$nev=$_POST["nev"];
echo "<p style=\"color:$szin;font-family:$ftipus;fontsize:${meret}pt;\">Szia $nev</p>";
echo"<br />";
?>
</body>
</html>
8. Készítsen egy számológépet! A számológép tartalmazzon:

– két szövegmezőt (a és b változók)
– négy rádiógombot (összeadás, kivonás, szorzás és osztás)
– küld gombot.
Megoldás:
<!doctype html>
<head>
<title>Számológép</title>
</head>
<body>
<form method="post" action="f8.php">
a=<input type="text" id="a" name="a" /><br />
b=<input type="text" id="b" name="b" /><br />
<hr />
<input type="radio" value="összeadas" name="muvelet" id="muvelet"checked="checked"
/>+<br />
<input type="radio" value="kivonás" name="muvelet" id="muvelet" />-<br />
<input type="radio" value="szorzás" name="muvelet" id="muvelet" />*<br />
<input type="radio" value="osztás" name="muvelet" id="muvelet" />/<br />
<hr />
<input type="submit" name="gomb" value="küld" />
</form>
</body>
</html>
<!doctype html>
<head>
<title>8. Feladat</title>
61
</head>
<body>
<?php
$ertek=0;
$muvelet=$_POST["muvelet"];
$a=$_POST["a"];
$b=$_POST["b"];
switch ($muvelet)
{
case "összeadas":$ertek=$a+$b;break;
case "kivonás" :$ertek=$a-$b;break;
case "szorzás" :$ertek=$a*$b;break;
case "osztás" :$ertek=$a/$b;break;
default : echo"művelet?!";break;
}
echo"$muvelet: $ertek";
?>
</body>
</html>
9. Készítsen egy PHP-szkriptet, amely függvények segítségével kiszámolja és kiírja az a

és a b változóval történő összeadás értékét!
Megoldás:
<!doctype html>
<head>
<title>Összeadás</title>
</head>
<body>
<?php
$a = 6;
$b = 7;
echo"\$a=$a \$b=$b<br />";
function osszeadas()
{
global $a, $b;
$b = $a + $b;
}
osszeadas();
echo "\$a+\$b=$b";
?>
</body>
62
</html>
10. Készítsen egy weboldalt, amely létrehoz egy bejelentkezési és egy regisztrációs
űrlapot! Az adatokat a login adattáblába tárolja.
Megoldás:
<!doctype html>
<head>
<title>Adatbázisos</title>
</head>
<body>
<hr/>
<b>Bejelentkezés</b><br />
<form method="post" action="check.php?cmd=1" id="login"
name="login">Email:<input type="text" id="email" name="email" /><br />Jelszo:<input
type="password" id="jelszo" name="jelszo" size="10" /><br/>
<input type="submit" name="sgomb1" value="küld" />
<input type="reset" name="rgomb1" value="mégsem" />
</form>
<hr />
<b>Új felhasználó:</b>
<form method="post" action="check.php?cmd=2" id="register"name="register">
Nev:<input type="text" id="nev" name="nev" /><br />
Vnev:<input type="text" id="vnev" name="vnev" /><br />
Email:<input type="text" id="email" name="email" /><br />
Jelszo:<input type="password" id="jelszo" name="jelszo" size="10" /><br/>
<input type="submit" name="sgomb2" value="küld" />
<input type="reset" name="rgomb2" value="mégsem" />
</form>
<hr />
<?php
if($uzenet==1)
echo "Nincs ilyen felhasználó!";
if($uzenet==2)
echo "Sikeres regisztráció!";
?>
</body>
</html>
<?php
$server="localhost";
$felhasznalob="root";
$jelszob="";
63
$ab="it";
if($cmd==1)
{
loginfelhasznalo($email,$jelszo);
}
elseif($cmd==2)
{
ujfelhasznalo($nev,$vnev,$email,$jelszo);
}
else
{
header("Location:login.php?");
}
function loginfelhasznalo($email,$jelszo)
{
global $server,$felhasznalob,$jelszob,$ab;
$kapcsolat = mysql_connect("$server", "$felhasznalob", "$jelszob") or
die(mysql_error());
mysql_select_db("$ab",$kapcsolat) or die(mysql_error());
$sql="select * from login where email='$email' and jelszo='$jelszo'";
$eredmeny = mysql_query($sql) or die(mysql_error());
if(mysql_num_rows($eredmeny)>0)
header("Location:menu.php");
else
header("Location:login.php?uzenet=1");
}
function ujfelhasznalo($nev,$vnev,$email,$jelszo)
{
global $server,$felhasznalob,$jelszob,$ab;
$kapcsolat = mysql_connect("$server", "$felhasznalob", "$jelszob") or
die(mysql_error());
mysql_select_db("$ab",$kapcsolat) or die(mysql_error());
$sql = "insert into login (nev,vnev,email,jelszo) values
('$nev','$vnev','$email','$jelszo')";
$eredmeny = mysql_query($sql) or die(mysql_error());
header("Location:login.php?uzenet=2");
}
?>
64
7. Összefoglalás
A gyakorló feladatok elkészítésével tananyagunk végéhez értünk. Ez azonban nem azt jelenti,
hogy a tanulnivalók végét is elértük. A webprogramozás misztikus világáról bátran állíthatjuk,
hogy a „végtelenhez konvergál”, így az ezzel kapcsolatos ismeretszerzési tanulmányainknak
nem érhetünk sosem a végére. Napjainkban elképesztő fejlesztési verseny van a
szoftverpiacon, és ha valaki ebbe belecsöppen, nem sok eséllyel tud kilépni a fejlődés
folyamatából. Azt gondolom, hogy ez így van jól.
Amikor elkezdtem dolgozni ezen a tananyagon, magam sem gondoltam, hogy ennyire
„hiányos” munkát fogok kiadni a kezemből. Ezeket a hiányosságokat azonban nem lehet
negatívumként jegyezni, mert a cél egyrészt nem is az volt, hogy egy teljes,
webprogramozással kapcsolatos, minden ismeretet tartalmazó egyetemi jegyzet szülessen.
Meggyőződésem, hogy ilyen munkát képtelenség lenne elkészíteni. Másrészt pedig a jegyzet
elkészítésével arra vállalkoztam, hogy bevezessem a hallgatókat a webprogramozás világába,
mellyel egyfajta inspirációt keltsek a tanulókban továbbfejlődési szándékukhoz.
Tartalmi összefoglalás címén elmondható, hogy jelen jegyzet tartalmazza mindazt az
ismeretanyagot, amelyet egy szemeszter alatt el kell sajátítaniuk azoknak a hallgatóknak, akik
felveszik a webprogramozás kurzust. A könyv első részében a szükséges alapvető
ismereteket gyűjtöttem össze a web működésével kapcsolatosan. A számítógépek fizikai
összekapcsolódásától kezdve eljutottunk a statikus és dinamikus honlapok kialakításáig.
Először a HTML-lel mint leíró nyelvvel kapcsolatos tudnivalókat szedtük rendbe. Kliens oldali
programozást tanultunk először a statikus lapok kialakításához, majd ezt követően még mindig
kliens oldalról, de már a dinamikusságot próbáltuk ki a JavaScript segítségével. JavaScripttel
interaktívvá tehetjük honlapjainkat, ami napjainkban marketingszempontból is fontos.
A jegyzet következő, lényegi része a szerver oldali programozásba vezette be az
olvasót. A PHP programozási nyelvvel kezdődött meg az ismerkedés. Megtanultuk, hogyan
tudjuk használni a szervert, és kapcsolatot létrehozni vele.
Telepítettük az XAMPP programcsomagot, majd el is készítettük első PHP-
programunkat. Lépésről lépésre vettük át az ehhez a nyelvhez kapcsolódó alapismereteket,
mint például a literálok szerepét, a függvények használatát, a MySQL adatbázisok használatát,
vagy akár a teljesség igénye nélkül, az objektumorientálás jelentőségét.
A jegyzetet záró fejezet a gyakorló feladatokat tartalmazza. HTML-ben, JavaScriptben
és PHP-ban megoldandó feladatokat gyűjtöttem össze gyakorláshoz. Szívből ajánlom,
önállóan dolgozzanak főleg azok, akik még sosem készítettek ezelőtt webes alkalmazásokat.
A feladatokat nem csupán a leírásukkal, hanem megoldási javaslatokkal is alátámasztottam
az ellenőrizhetőség megkönnyítése miatt.
Szinte biztos vagyok abban, hogy az alapok megismerése után mindenki úgy érzi, hogy
bővült az elsajátítandó ismeretek halmaza, annak ellenére, hogy megtanulta a könyvben
szereplő sok ismeretanyagot.
Bízom benne, hogy ezzel nem ment el senkinek a kedve a webprogramozástól, hanem
inkább, aki kicsit félve is kezdett bele a tanulásba, további webes kurzus felé kacsingat.
Innentől kezdve akár saját kreativitásunkat is elővehetjük és a fejlesztési lehetőségek végtelen
tárházába merülhetünk akár hobbi, akár hivatásunk szemszögéből is.
65
Végül bízom benne, hogy ezzel a jegyzettel érdemben hozzájárultam a hazai felsőfokú
képzésfejlesztéshez, és hatékonyan bővítettem a rendelkezésre álló tanulási segédeszköz-
repertoárt az informatikai képzési területen.
Sok sikert kívánok! Dr. Nagy Enikő
66
8. IRODALOMJEGYZÉK
Balássy György: Honlapépítés a XXI. században, Kezdőknek és haladóknak, Jedlik Oktatási
Stúdió Kft. Budapest 2010
Covic Zlatko: Internet technológiák, Szabadkai Műszaki Főiskola, Szabadka 2005
Dr. Medzihradszky Dénes: A webprogramozás alapjai, Főiskolai jegyzet 2007
Kupás Péter: Weblapszerkesztés, Oktatási segédlet, Károly Róbert Főiskola, Gyöngyös 2003
Matt Zandstra: Tanuljuk meg a PHP4 használatát 24 óra alatt, Kiskapu Kft. Budapest 2001
Mester Gyula: Web programozás, Szabadkai Műszaki Főiskola, Szabadka 2004
Nagy Gusztáv: Web programozás alapismeretek, Ad Librum Kiadó Budapest 2011
Paczona Zoltán: HTML technikák a gyakorlatban, Professzionális sorozat, Computer

Panoráma Kiadó, Budapest 2001
Szabó Bálint: Webprogramozás I. Médiainformatikai kiadványok, Eszterházy Károly Főiskola,

Eger 2013
http://www.w3schools.com
http://www.w3c.org
http://developer.mozilla.org/en/docs/JavaScript
http://www.apache.org/
http://www.mozilla.com/en-US/firefox/
http://weblabor.hu/
67

NagyEniko Webprogramozas 2

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

NagyEniko Webprogramozas 2

Diunggah oleh

Hak Cipta:

TÁMOP-4.1.1.

Dr. Nagy Enikő

A tananyag a TÁMOP-4.1.1.F-14/1/KONV-2015-0009 azonosító számú,

Dr. Nagy Enikő

5. Programozás PHP nyelven ...............................................................................13

5.2. Programkészítés PHP-val ....................................................................................................... 16

8.2.1. Az első PHP-programunk ..................................................................................................... 17

5.3. A PHP nyelv elemei ................................................................................................................ 19

5.3.1. A literálok ............................................................................................................................ 19

5.3.2. A kifejezések ........................................................................................................................ 20

5.3.3. Változók ............................................................................................................................... 22

5.3.4. Konstansok .......................................................................................................................... 23

5.3.5. A tömbök ............................................................................................................................. 23

5.4. A PHP vezérlő szerkezetei ..................................................................................................... 25

5.4.1. Elágazások ........................................................................................................................... 25

5.5. Függvények ............................................................................................................................ 29

5.5.1. Függvény létrehozása .......................................................................................................... 30

5.5.2. Beépített függvények .......................................................................................................... 32

5.6. Adatbázis-kezelás MySQL-lel ................................................................................................. 33

5.6.1. Műveletek az adatbázissal ................................................................................................... 33

5.7. Objektumok a PHP-ben ......................................................................................................... 38

5.8. Egyéb lehetőségek ................................................................................................................. 41

5.8.2. Hiba- és kivételkezelés ........................................................................................................ 43

6. Gyakorló feladatok .........................................................................................45

6.2. JavaScript gyakorló feladatok ................................................................................................ 52

6.3. PHP gyakorló feladatok ......................................................................................................... 57

2. ábra XAMPP telepítése II. .................................................................................................................................. 14

3. ábra XAMPP telepítése III. ................................................................................................................................. 14

4. ábra XAMPP telepítése IV. ................................................................................................................................. 15

5. ábra XAMPP telepítése V. .................................................................................................................................. 15

6. ábra XAMPP Control Panel ............................................................................................................................... 16

7. ábra „PHP-próba” kimenet ................................................................................................................................. 18

8. ábra 1. HTML-feladat ......................................................................................................................................... 45

9. ábra 2. HTML-feladat ......................................................................................................................................... 46

10. ábra 3. HTML-feladat ....................................................................................................................................... 47

11. ábra 4. HTML-feladat ....................................................................................................................................... 48

12. ábra 5. HTML feladat ....................................................................................................................................... 49

13. ábra 6. HTML-feladat ....................................................................................................................................... 50

14. ábra 7. HTML-feladat ....................................................................................................................................... 51

15. ábra 1. JavaScript-feladat ................................................................................................................................ 52

16. ábra 3. JavaScript-feladat I. ............................................................................................................................. 55

17. ábra 3. JavaScript-feladat II. ............................................................................................................................. 55

18. ábra 3. JavaScript-feladat III. ........................................................................................................................... 56

Ezenkívül mindennapivá váltak a jelenkori információs társadalom

Konkrétabban megfogalmazva, ezt a jegyzetet olyan, a webprogramozásban

Ennek a jegyzetnek tehát az elsődleges célja, hogy hozzásegítse a hallgatót

Bízom benne, hogy munkámmal hatékonyan hozzájárulok ahhoz, hogy egy

A webprogramozás tantárgy célkitűzéseit tekintve tehát a következőket fogalmazom meg:

- Alapvető cél – a bevezető ismereteken túl – megérteni a webes felületek és

- Cél, hogy megismerjük az internet működését, és az ezzel kapcsolatos technikai

- Olyan szakkifejezések, fogalmak ismereteit, azaz szakszókincsét kell elsajátítanunk,

- A jegyzetben célul tűzzük ki a kliens és szerver oldali programozás megértését, az

- Kliens oldalról a HTML5 leíró nyelv alapjainak megismerése, és ehhez kapcsolódóan

- A statikus és dinamikus weboldalak közötti különbségek, hasonlóságok és

- Jelen jegyzetben viszont nem kívánunk hangsúlyt fektetni a honlapok formailag

- A szerver oldali programozás megismeréséhez és megértéséhez a PHP programozási

- Végül, de nem utolsósorban, célkitűzéseink között szerepel, hogy a hallgatók olyan

A tananyag feldolgozása során feltételezzük, hogy a hallgató birtokában van a középiskolai

Számítástechnikai alapismeretek, számítógépes hálózatok működésének alapjai,

Mivel alapvetően internetes felületekkel foglalkozunk, ezért fontos, hogy a hallgató

Alapkövetelményként említendő továbbá az alapfokú angolnyelv-tudás, illetve a Közös

Infrastrukturális megközelítésből a tananyag elsajátításához szükségünk lesz

5.1. A PHP telepítése

A PHP nyelv megtanulásához, és a későbbi fejlesztésekhez célszerű saját gépünkön is

1. ábra XAMPP telepítése I.

2. lépés A telepítő elindítása