Király Roland

Első lépések weboldalak programozásáhozJegyzet

Tartalomjegyzék

Első lépések weboldalak programozásához................................................................................1Tartalomjegyzék..........................................................................................................................2Előszó..........................................................................................................................................2Tartalomkezelő rendszerek.........................................................................................................3Webprogramok............................................................................................................................4Változók......................................................................................................................................9Összetett adatszerkezetek..........................................................................................................10Eljárások és függvények...........................................................................................................13Adatbázisok...............................................................................................................................15Weboldalak felépítése...............................................................................................................18Menüpontok előállítása ............................................................................................................20Adatbázis alapú webalkalmazások............................................................................................21Adatbázis kezelő modul készítése.............................................................................................27Fájlkezelés, és jelszavak használata..........................................................................................31Weboldalak védelme.................................................................................................................33Formázott listák készítése.........................................................................................................36Captcha készítés........................................................................................................................39Felhasználók nyomkövetése......................................................................................................40CSS alapok................................................................................................................................46A böngészőkről általában..........................................................................................................50JavaScriptek beépítése a kódba.................................................................................................51A JavaScript és a CSS...............................................................................................................56Lenyíló divek használata...........................................................................................................61Kód-újrahasznosítás..................................................................................................................63Ellenőrző kérdések....................................................................................................................68Irodalomjegyzék........................................................................................................................72

Előszó

Ezen írás határozottan jegyzet jellegű, és nem tankönyv, ezáltal hathatós oktatói közreműködést, vagy legalábbis oktatói támogatást igényel a benne szereplő forráskódok és technológiák hatékony használatának elsajátítása.

A jegyzet célja nem a teljes körű referencia elkészítése a webes technológiák területén, hanem a bemutatott webes nyelvi elemek, és a gyakorlati alkalmazások alapszintű ismertetése, amely segíthet a weboldalak programozását frissen elkezdő, vagy azok működését megérteni kívánó olvasó számára.

Az ismertetett webes elemek leírása nem teljes, és kizárólag annyit mutatnak meg az adott témakörből, ami elegendő a továbblépéshez, és működő programok készítéséhez. Az bemutatott példaprogramok nagy része fájlokba helyezve futásra kész, de minden körülmények között biztosítani kell számukra a megfelelő szerver, vagy éppen a kliens oldali futtatórendszert. A feldolgozott témáknál, a HTML nyelv alapjai, a CMS rendszerek világa, valamint a szerver és kliens oldali szkriptek bemutatása, az volt az elsődleges szempont, hogy a lehető legtöbbet mutassunk meg a feltétlenül szükséges nyelvi elemek közül, ezáltal segítve a programozásban még nem járatos olvasót a működőképes programok készítésében.

Tartalomkezelő rendszerek

A tartalomkezelő rendszer az angol rövidítés után CMS (Content Management System) egy olyan félig elkészített weboldal, melyet némi konfiguráció, jelszóbeállítás és egyéb kisebb trükkök segítségével néhány perc alatt el tudunk készíteni. Egy általános CMS számos, az Interneten elterjedt komponensből áll: ilyenek a beléptető rendszer, az adminisztrációs felület, hírek, különböző galériák, RSS szolgáltatások, naptár, testre szabható külső megjelenés, valamint a csak az adott CMS-re jellemző modulok.

Fontos, hogy ezeket a gyakorlatban is lássuk működni, mivel csak így tudunk hasonló modulokat készíteni. A telepítés lépéseinek a bemutatásához a Word Press rendszerét fogjuk használni. A választás azért erre a rendszerre esett, mert igen elterjedt, másrészt pedig híres az ötperces telepítőjéről. Töltsük le az aktuális verziót a http://www.wordpress.com linkről. Nem kell feltétlenül ezt a CMS-t választani. Amennyiben az olvasó ragaszkodik egy másik rendszerhez, próbálkozzon azzal, vagy akár egyszerre többet is kipróbálhat. A telepítéshez szükségünk lesz egy szolgáltató által a rendelkezésünkre bocsájtott tárhelyre, vagy telepítenünk kell egy olyan CMS rendszert, amely webszerver-, PHP-futtatókörnyezet- és adatbázistárhely-szolgáltatásokat nyújt. Adatbázis kezelő rendszernek válasszunk SQL-alapút, lehetőség szerint MySQL alapokon működő rendszert. Jelenleg az XAMP és a WAMP szerverek elterjedtek a programozók körében, ezért alkalmazzuk mi is valamelyiket. Ahogy látjuk a szerver oldali környezet kialakítását is egy CMS-hez hasonló programmal oldjuk meg, és nem egy „valódi” szerverrel.

Linux operációs rendszer esetén mindképpen olvassuk el a telepítésről szóló fájlt, mielőtt hozzálátunk a telepítéshez. Egyébként ennek a változatnak a telepítése sem tart tovább néhány percnél. Indítsuk el a webszervert, majd keressük meg a htdocs könyvtárát, ahol a weboldalakat elhelyezhetjük. A Word Press CMS fájljainak készítsünk egy könyvtárat, majd indítsuk el a telepítőt.

Ahogy elkészültünk a telepítéssel, a program tájékoztat minket erről, és mindjárt el is kezdhetjük az oldalunk „finomhangolását”. Beállíthatjuk a külső megjelenésre vonatkozó paramétereket, és a nyelvet. Felvehetjük a felhasználókat, akik a leendő website-ot használhatják, átszervezhetjük a modulokat, és mindent olyat megtehetnünk, amit az oldal megenged a számunkra – komolyabb rendszerek esetén már a „fogd és vidd” (Drag&Drop) technika segítségével is. Ha a program leírásában szereplő lépéseket követjük, programozás nélkül készítettünk el egy működőképes weboldalt.

Sok CMS tartalmazza a lehetőséget a továbbfejlesztésre, de ez soha nem olyan egyszerű, mintha saját programjainkat alakítanánk át. Meg kell értenünk más programozók forráskódjait és át kell alakítanunk úgy, hogy ne rontsuk el az eredeti funkciókat, de az újakat integrálni tudjuk. A CMS rendszerek nagyon jók, de mindig arra a meghatározott célra, amire készítették őket. Ezt szem előtt tartva gondoljuk át, hogy az adott rendszer megfelel-e a számunkra hosszabb távon is.

Webprogramok

Saját, nem CMS alapú weboldalaink elkészítéséhez szükségünk van a HTML nyelv ismeretére. Ahhoz, hogy egy program futásának eredményét formázottan jeleníthessük meg, HTML-t (a formázáshoz CSS-t) kell használnunk. Sajnos a HTML nyelv nem alkalmas arra, hogy az interakciókat kezelni tudja. Nem tudunk elágazásokat, ciklusokat szervezni, valamint nem vagyunk képesek segítségükkel adatbázisokhoz kapcsolódni.

A böngészőprogram bővítmények segítségével kezeli a kép- és hangfájlokat, képes a Flash- és a JavaScript-alapú program futtatására. Ezeket mind-mind beépülő modulok felhasználásával futtatja a kliens oldali számítógépeken. A komolyabb webalkalmazások programja viszont elképzelhetetlen a szerver oldali szkript-nyelvek nélkül. Ilyen szkript-nyelv a PHP, amely igen nagy százalékban van jelen a webes alkalmazásokban. A forrásszövegek szerver oldali fordítása és futtatása komoly erőforrás-megtakarítást eredményez a kliens számítógépeken. Az adatok tárolása a szerveren történik, ami az erőforrásokkal való gazdálkodást tekintve nem elhanyagolható, nem beszélve a biztonságról. A forráskód nem látható a kliens számítógépeken, mivel oda csak a programok eredménye, vagyis az előállított HTML töltődik le. A PHP programokból állítjuk elő a weboldalak HTML alapú forrásszövegét, vagy a HTML kódba ágyazzuk a PHP programrészeket.

<BODY><? echo "Hello ". $user;?></BODY><? for ($i=0; $i<10; $i++) { echo "<TABLE><TR><TD>Aktuális sorszám: $i

</TD></TR></TABLE>"; }?>

A kliens számítógépek böngészőjében megjelenő oldalakat is érdemes külön modulokban, fájlokba elhelyezni. A szerverekre be kell jelentkezni ahhoz, hogy a programokat meg tudjuk írni, és a programjaink kimenetét nem a megszokott módon, a fejlesztőeszközben látjuk, hanem ugyanúgy, ahogy a felhasználóink, a kliens oldali webböngészőben.

Fájlok szerverre történő mozgatásához használjunk olyan fájlkezelő programot, amely ismeri az FTP-protokollt, terminálkapcsolat kialakításához viszont telepítsünk SSH kliensprogramot, mint a Putty, vagy a TerraTermPro. Próbáljuk ki a webszervert! A webkönyvtárában készítsünk egy fájlt index.php néven! Ügyeljünk arra, hogy a webszerver a különböző kiterjesztésű fájlokat más-más sorrendben veszi figyelembe. Amennyiben van a könyvtárban egy index.html nevű fájl, az fog futni, és nem a php kiterjesztésű. A könyvtár, amelyben a fájlt el kell helyeznünk,

Linux operációs rendszer esetén a var/www könyvtár valamely alkönyvtára az ahova a fájlokat el kell helyeznünk, felhasználók esetében pedig a home könyvtáruk public_html alkönyvtára játssza ugyanezt a szerepet. Az elkészített program eléréséhez a böngészőbe kell gépelni a weboldal címét: http:\\www.weboldalneve.hu. Megjegyzés: A cím regisztrált domainnév esetén a .hu tartományban lehetne érvényes. Felhasználók webkönyvtárai esetén az oldalt a szerver neve, a felhasználó neve, és annak az alkönyvtárnak az elérési útja azonosítja, ahol az index fájl található:

http:\\szerverneve.hu\~felhasználóneve\alkonyvtar

A felhasználói fiókok használata mellett a www előtag elhagyása kötelező. A címben a „~” karakter a felhasználó neve elé kerül és arra utal, hogy annak alkönyvtárában kell keresni az index fájlt. Amennyiben már van index fájlunk, nyissuk meg, majd írjuk bele a következő néhány függvényhívást:

<? phpinfo();

?>

Ez a függvény táblázatos formában jeleníti meg a szerver beállításait, a változókat, melyek jellemzik a futtató környezetet. A táblázat amellett, hogy információkat szolgáltat, megmutatja azt is, hogy a szerver megfelelően működik-e. Első lépésként készítsünk el a mára már klasszikussá vált Hello Világ programot. A forráskód kizárólag HTML nyelv használatával a következő:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"><html><head><title>Tesztprogram</title> <meta http-equiv="content-type" content="text/HTML; charset=utf-8"></head> <body> Hello Világ </body></html>

A HTML jó a szöveg formázására, de nem alkalmas arra, hogy a kiírást ismételjük, vagy feltételekhez kössük. Kevés sor esetén a másolás-beillesztés technológia segíthet az ismétlések megvalósításában, de mit tehetünk mondjuk 1000 sor esetén, vagy ha nem egy konstans szöveget kell kiírni a kliens oldal képernyőjére?

A dinamikus weboldalak erőssége pontosan ez utóbbi technikában rejlik, hogy a kimenetet nem csak formázni tudjuk, hanem adatbázisokból, felhasználói döntések mellett átalakítani is. Mivel adatbázisokat még nem tudunk használni, helyezzük el a kiírandó szövegrészeket egy tömbben (a tömbökről később részletesen írunk).

Ezután egy egyszerű for ciklus segítségével generáljuk le a megfelelő HTML-tegeket.

<html><head> <title>tesztprogram</title> <meta http-equiv="content-type" content="text/html; charset=utf-8"> </head><body>

<? $szoveg = array("Első", "Második", "Harmadik", "Negyedik", "Ötödik");

$db = count($szoveg); for ($i=0; $i<$db; $i++) { echo "$i = $szoveg[$i] <br>"; }

?> </body></html>

Ez a program sokkal általánosabb, mint a HTML-változat, mivel az adatokat egy tömbből veszi, a sorokat pedig a rendelkezésre álló adatokból és a ciklusváltozóból állítja elő.

A kód első ránézésre bonyolultnak tűnik, de nagyon hasonlít a C, C++ nyelvekre, vagy a Linux Shell programjainak nyelvezetére. A $ jelek változókat jelölnek, a kiíró utasításban található HTML-tagek pedig szokványos webes elemek. A dolog nehézsége abban rejlik, a program elkészítéséhez felváltva kell használnunk különböző programozási, vagy formátumleíró nyelveket, ráadásul egymásba kell tudnunk ágyazni ezeket. PHP nyelvű programokat a szerver futtatja, és a böngészőnk már csak a futás eredményét, vagyis a HTML szöveget kapják meg. Mivel a PHP programok írása, és a különböző szerver oldali alkalmazások használata a programozás során nem a megszokott „egy fejlesztőeszköz-egy program” stílusban történik, a nyelv megismerését is kezdjük rendhagyó módon, és ne a vezérlőszerkezeteket és az alap utasításkészletet vizsgáljuk. Nézzük meg azt, hogy a programjaink kimenete hogyan állítható elő a kliens számítógépek böngészője számára. Hogyan tudjuk a változók, vagy a kifejezések értékét kiírni HTML-szövegekbe ágyazva?

A szkripteket a <? ?> vagy a <?php ?> tegek közé kell gépelni, ugyanis ez alapján tudja a szerver kikövetkeztetni, hogy PHP nyelvű forrásszöveg következik, és azt, hogy az meddig tart. A nyelvben a szövegek kiírásához használhatjuk az echo, vagy a print függvényt. Az echo jobban átláthatóvá teszi a programok forráskódját (a kevesebb zárójel miatt) és egy kicsit gyorsabb is.

<? for (i=1; i<=10; ++i) { echo "$i. sor"; echo $i.". sor"; }?>

A kiírandó tartalmat " " (idézőjel) vagy az ' ' (aposztróf) jelek közé kell zárni. Mindkét formának más a jelentése, és más-más hatást gyakorolnak a szöveg típusú adatokra, a változókra ($a) és a kifejezésekre ($a + 2). A ' ' jelek közé írt változók nem helyettesítődnek be, értékük helyett a kódban szereplő azonosítójuk íródik ki.

<? $a = 2; echo '$a';?>

A forráskód eredménye nem a 2, hanem a $a szöveg. Ez azért van így, mert a ' ' közé írt karakterek úgy jelennek meg a képernyőn, vagyis a kliens számítógép böngészőprogramjának a felületén, ahogyan azokat leírta a programozó: minden leírt jelet karakterré kényszerítve. Amennyiben a változó tartalmát szeretnénk kiíratni, a " " aposztrófokat kell használnunk. Igazság szerint, ha nem kívánunk a változó tartalmán kívül más szöveget kiírni, a dupla idézőjel el is hagyható.

<? $a = 2; echo "$a<BR>"; echo $b;?>

Ahogy a forráskódban látható, minden utasítást ; zár le. Ennek elhagyása szintaktikai hibát eredményez, ami nem túl szerencsés weboldalak esetén, ahol a programot a szerver minden futtatáskor újra lefordítja és a hiba a minden futáskor láthatóvá válik a képernyőn. Ez a működési elv, ahogy a későbbiek során láthatjuk, számos lehetőséget hordoz magában, de a lehetőségek mellett komoly hibákat is eredményezhet, melyeket a szerver oldali rendszer azonnal meg is mutat a felhasználónak.

A kiírás, valamint a megfelelő formátum előállítása összetett adatok, tömbök, vagy a kifejezések használata mellett sem túlságosan bonyolult.

<? $t = array(1,2,3,4); $db = count($t); for ($i = 0; $i < $db; $i++) { echo "$i + 1<BR>"; }?>

A fenti forrásszövegben a ciklus nem a $i + 1 kifejezés értékét írja ki, hanem a $i változó értékét, valamint minden érték után a +1 szöveget:

0 + 11 + 12 + 13 + 1

Ez azért van így, mert a kiíró utasításban a ”$i + i” nem értékelődik ki. A kifejezés értékét először ki kell számítani, és csak ezután lehet kiírni. A megoldás az, ha a kifejezést szövegtől elkülönítve, egy másik echo használatával írjuk ki. Ebben az esetben a kiíró utasítás már az értéket, vagyis az eredményt jeleníti meg.

<? for ($i = 0; $i < $db; $i++) { echo $i + 1; echo "<BR>"; }?>

Lehetőségünk van arra is, hogy a kiírásra szánt szöveget darabokból illesszük össze. Erre a feladatra a PHP nyelvben nem a C, C++, vagy C# megszokott + jelet használjuk, hanem . (pont)-ot. Sajnos a . operátor nehezen olvashatóvá teszi a forráskódot, de némi gyakorlással, gyorsan meg lehet barátkozni ezzel a szintaxissal.

<? $t = array(1,2,3,4); $db = count($t); $e = ". tömbelem = "; for ($i = 0; $i < $db; $i++) { echo $i.$e.$t[$i]."<BR>"; } ?>

A program futásának az eredménye:

0. tömbelem = 11. tömbelem = 22. tömbelem = 33. tömbelem = 4

Ahogy láthatjuk a forráskódban, kissé körülményes az adatok kiírása, de ne csodálkozzunk ezen. Több nyelvet ágyazunk egymásba, és több rendszert használunk egyszerre.

Változók

A PHP a gyengén típusos nyelvek közé tartozik. A programokban használt egyszerű skalár változókat (egészek, szövegek, törtek, vagy a karakterek) nem kell deklarálni. A deklaráció elhagyása mellett vannak kikötések a változók használatára vonatkozóan, de ezek nem túl bonyolultak. Mielőtt használunk egyet, értéket kell adnunk neki. Ha ezt nem tesszük meg, a futtatórendszer leállítja a program futását, és hibaüzenetet ír a képernyőre (vagy a szerver konfigurációjában megadott helyre).

<? $a = 1; $t= 'szöveg';?>

Az összetett adatszerkezetek (tömbök, rekordok, osztályok, vagy fájlok) esetén viszont a típust be kell vezetni.

<? $t = array(1,2,3,4,5,6); $szoveg = array("Ázsia", "Afrika");?>

A gyenge típusosság nem jelenti azt, hogy a rendszer a típusokkal nem törődik, vagy nem kezeli őket. Inkább csak rugalmasabb a változókezelés, ami rengeteg lehetőséget rejt magában a dinamikusan működő weboldalak programozása során. Ne feledjük el azt sem, hogy az adatok és a különböző szöveges adatok megjelenítése szöveges formában történik, mivel a böngésző formázott HTML-kódot kap a szerver oldali programtól. Az adatok és a kifejezések minden esetben szöveggé konvertálódnak, ha kiírásban szerepeltetjük őket, így a formázás és a darabok összeillesztése a direkt adatkonverziók elhagyása mellett sem okoz különösebb problémát.

Egy változó akár több céllal, többféle típusú adat tárolására is alkalmas. A $a = 1 értékadást követheti a $a = "szöveg", majd a $a = 5 újbóli értékcsere után az $a változó szerepelhet akár egy kifejezésben is. A nyelv típusrendszere megengedő, de vigyázzunk, a sok lehetőség sok hiba lehetőségét is magában hordozza. A megengedő nyelv használata mellett a teljes körű tesztelés egyszerű programok esetén is nagyon körülményes. Néhány elágazást tartalmazó forrásszöveg több millió különböző végrehajtási ágat eredményezhet. Nem beszélve arról, hogy a tesztelés nagyon költséges dolog. Átgondoltan és körültekintően bánjunk a típusokkal és a változókkal, hogy ne kelljen hosszú órákat forráskódjavítással töltenünk.

Összetett adatszerkezetek

A PHP nyelvben több féle típus. A legegyszerűbbek a skalár változók, vagyis a számok, karakterek és minden egyszerű adat. A másik nagy csoport az összetett adatok csoportja. Ide tartoznak a tömbök, listák, string-ek (karakterláncok) és az osztályok. A tömböket a nyelv kétféleképpen is képes kezelni. Hivatkozhatunk a tömbökre indexelhető vektorokként, vagyis hash táblaként. Ezt a típust asszociatív tömbnek is nevezzük. Asszociatív tömb esetén az egyes elemeket kulcsokkal érhetjük el. Ez a gyakorlatban azt jelenti, hogy nem a $tomb[$index], vagy $tomb[1], hanem a $tomb["kulcs"] formulával érhetjük el az adott elemet. Mikor vektorként kezeljük a tömböket, egyszerűen indexek segítségével hivatkozunk az elemeikre. Minden elem eléréséhez az indexén keresztül vezet az út, vagyis ha ismerjük az adott elemnek a tömbben elfoglalt helyét (sorszámát), a $tombvaltozo[$index] formulával hivatkozhatunk rá. Természetesen a PHP nyelv is ismeri a több dimenziós tömb fogalmát.

$t[0][0] = "0.0";$t[0][1] = "0.1";

$t[1]["elso"] = 1;echo $t[1]["elso"];

$t1 = array(1,2,3);

$t2[0] = 1;$t2[1] = 2;$t2[2] = 3;

Az elemekre minden dimenzióban tetszőleges módon hivatkozhatunk, vagyis az egyik dimenzióban indexekkel, a másikban asszociatív módon. Létrehozhatunk tömb típusú változót az array, vagy a list függvények segítségével, esetleg direkt módon, az elemek megadásával. Asszociatív tömböket is könnyen készíthetünk az elem-index párosok definiálásával, vagy az array függvénnyel.

$a1["elso"] = 1;$a1["masodik"] = 2;

$a2 = array("elso" => 1, "masodik" => 2);

Az a1 és a a2 tömbök ugyanazokat az elemeket tartalmazzák, csak más a nevük. Nézzünk meg egy bonyolultabb példát, ami szemléletes módon mutatja be a tömbök használatát. A példaprogramban feltöltünk egy n × m méretű mátrixot véletlen számokkal. A mátrix elemeit két egymásba ágyazott ciklus segítségével hozzuk létre. A tárolt értékeket direkt módon adjuk meg és egy véletlenszám-generátorral hozzuk létre.

<? $M = array(); $n = 10; for ($i = 0; $i < $n; $i++) { for ($j = 0; $j < $n; $j++) { $M[$i][$j] = rand(1,9); } }

for ($i = 0; $i < $n; $i++) { for ($j = 0; $j < $n; $j++) { echo $M[$i][$j]." "; } echo "<BR>"; }?>

Ahogy látjuk, a PHP nyelv tartalmazza a C, C++ és a C# programoknál megszokott vezérlő szerkezeteket, elágazásokat, ciklusokat és a foreach listakezelőt, valamit a feltételes elágazás egyszerű és összetett formáját. Írhatunk if {} else {}, vagy switch típusú elágazásokat.

<? $a = 2; if ($a % 2 == 0) { echo "$a páros"; } else { echo "$a páratlan"; }?>

Természetesen egy utasítás esetén a { } jelek el is hagyhatóak, ezek elhagyása nem javasolt, mivel a program újabb utasításokkal való bővítése esetén nagyon körülményes utólag kitenni őket. Írhatunk több ággal rendelkező elágazásokat is az elif-ágak bevezetésével, vagy a switch feltételes utasítás használatával. Több ág esetén lehetőség szerint válasszuk a switch típusú elágazást.

<? $a = 2; switch ($a) { case 1: echo "Január"; break; case 2: echo "Február"; break; case 3: echo "Március"; break;

... default: echo "hibás sorszám"; break; }?>

A program a hónapok neveit írja ki a sorszámuk alapján. Ahogy megvizsgáljuk a forrásszöveget, észrevehetjük, hogy a az nem túl hatékony, mivel nagyon sok ágat kell tartalmaznia az összes hónap nevének kiírásához. A javításához használhatunk tömböt, vagy listát, melybe tároljuk a hónapok neveit, majd a $a változóval indexelve azonnal megkapjuk a hónap nevét.

<? $honapok = array('Január', 'Február', ..., 'November'); $a = 2; echo $honapok[$a – 1];?>

A $a-1 a tömb hivatkozásban azért szerepel, mert a tömbök és listák 0-tól indexelődnek, nem pedig 1-től. Ekkor az eredmény a 'Január' lesz.

A kitérő után nézzük meg újra a switch utasítást. A feltételben az egyes ágakat a case kulcsszó vezeti be. Az ágak végén a break kulcsszónak szónak és egy ;-nek kell állnia. Ha ezt elhagyjuk, az adott ág után következő minden egyes ág le fog futni a következő break; kulcsszóig. A default rész az egyéb ágat vezeti be, mely el is hagyható. A switch utasítás kitűnően használható weboldalak menükezelésének a megszervezésére, és erre a lehetőségre később még vissza is térünk.

Ciklusból PHP nyelvben négy féle létezik, ha ide számoljuk a foreach-et, melyet listák és tömbök bejárására használhatunk.

<? for ($i = 0; $i < 10; $i++) { echo "$i <BR>"; } echo "<BR>";

$i = 0; while ($i < 10) { echo "$i <BR>"; $i++; } echo "<BR>";

$i = 0; do { echo "$i <BR>"; $i++; } while($i < 10)?>

A fenti három ciklusutasítás ugyanazt a feladatot végzi el, vagyis kiírják a képernyőre a 0-9 számokat, mindegyiket új sorba.

A do-while a PHP nyelvben C, C++ és a C# programok mintájáraa ciklusban maradás és nem a ciklusból való kilépés feltételét tartalmazza. Ezt a működést pozitív kiértékelésnek nevezzük. A foreach viszont kissé eltér a megszokott C-beli formától. Nem a 'változó in lista' formulát használja, hanem a 'lista as változó' formát, ahol a listaelem címére hivatkozhatunk a változóval.

<?

$t = array(1,2,3,4,5,6); foreach ($t as &$i) { echo $i; }

?>

Ezért a '&$t' hivatkozás szükséges, mert a foreach utasításban nem a tömb, vagy a lista elemeire hivatkozunk, hanem magára a tömbre, így azt nem skalár típusú változóként kell kezelnünk, hanem tömb típusként.

Eljárások és függvények

A nyelv alapjai nem bonyolultak, különösen nem azok számára, akik már megtanultak más nyelveken programozni. Bonyolultabb programok készítéséhez viszont mindenképpen el kell sajátítanunk a függvények és eljárások használatát. Ahhoz, hogy alprogramokat tudjunk készíteni, tisztában kell lennünk a formális, és aktuális paraméterek fogalmával, valamint a függvényhívások alapvető módszereivel.

A függvényeket a function kulcsszó vezeti be. Ezután következik a paraméterlista () között, majd a függvény blokkja, melyet {} zárójelek közé zárunk. A () zárójelek a paraméterekkel nem rendelkező függvények esetén sem hagyhatók el. A függvényblokk tartalmazza az utasításokat és a return kulcsszó után függvény a visszatérési értékét megadó kifejezést. A return kulcsszó és az utána álló kifejezés elhagyható, ha típussal és visszatérési értékkel nem rendelkező eljárást szeretnénk előállítani.

Vizsgáljuk meg a következő programlistát, amely nagyon szemléletes, és a későbbi munkánk során még hasznos elemeket tartalmaz. Figyeljük meg, hogy a függvények paramétereinek nem kell típust adni. A paraméterátadás a függvények esetén nagyon fontos és elhagyása komoly hibákhoz vezethet, mivel a globális változók közül csak azok láthatóak a függvények törzsében, amelyeket regisztráltunk globális változónak.

<? function hello() { echo "Hello"; }

function hi($BODY) { echo "Hi ".$BODY."!"; }

function amount($A,$B) { return $A + $B; }

function sum($LIST) { $SUM = 0; for ($i = 0; $i < $db; $i++) { $SUM += $LIST[$i]; } return $SUM; }

function trim($TEXT, $LIST) { return str_replace($LIST,"",$TEXT); }

function createID($NAME,$BADList,$GOODList) { $NAME = str_replace($BADList, $GOODList, $NAME); return rand().$NAME; }

?>

Az hello függvény nagyon egyszerű, de a hasznossága vitatható (Hasonló a helyzet a másodikkal is...). Paramétere nincs, és ha meghívjuk, akkor kiírja a Hello szócskát. A második függvény bemenete egy név (vagy egy tetszőleges szöveg). Ahogy meghívjuk, a kapott paraméter elé írja 'Hi' szót, majd a végére egy felkiáltójelet helyez. Az amount a paraméterként kapott két számot összeadja, majd visszatér az összeggel. A sum egy listát kap paraméterként, majd visszaadja az elemek összegét. A trim már valamivel hasznosabb, mivel ez a függvény a paraméterként kapott szövegből törli, vagyis üres szövegre cseréli a második paraméterben megkapott részszó összes előfordulását. A függvényben leírt műveletsor webprogramok írásakor rutinfeladatnak számít ha beviteli mezők, vagy űrlapok adatait dolgozzuk fel. A createID a trim-hez hasonlóan működik, de ennek a paramétere egy azonosító, vagy név. A nemkívánatosnak vélt elemeket ($BADList) lecseréli a „jó” elemeket tartalmazó listában ($GOODList) szereplő párjukra, majd az eredmény elé ragaszt egy viszonylag nagy egész számot, így biztosítva annak egyediségét. Ez a függvény egyedi azonosítók, vagy fájlnevek generálásánál szinte elengedhetetlen, de nagyon hasznos képek, vagy szöveges fájlok kezeléséhez.

Adatbázisok

Az adatbázis-kezelő rendszerek a szokásos feladatok mellett az olyan jellegű problémákat is megoldják, amelyekkel a hálózaton működő adatkezelő alkalmazásoknál feltétlenül számolni kell.

• Az adatokat egy időben több felhasználó is elérheti, ezért biztosítani kell a párhuzamos hozzáférést az adatbázisokhoz.

• Adatbevitel esetén biztosítani kell a kizárólagos hozzáférést, hogy ne forduljanak elő különféle anomáliák.

• Az adatok tárolása nem feltétlenül egy gépen történik, ezért biztosítani kell az elosztott adatelérést.

• Az adatbázisok tábláinak indexeit karban kell tartani.• A hozzáférési szinteket szabályozni kell.• Biztosítani kell tárolt eljárások írásának lehetőségét, valamint az

adathozzáférést különböző hálózati eszközökön keresztül.

Bármilyen adatbázis-kezelőt is választunk, az első feladatunk annak az, hogy megvizsgáljuk a programozásra használt nyelv adatbázis-kezelő rutinjait és azokat a könyvtári modulokat, amelyek az adatbázis-kezelővel folytatott párbeszédek lebonyolításáért felelősek.

A kliens gépek kapcsolódnak a webszerver 80-as portjához. A szerver a hozzá intézett kérés, vagyis az URL alapján megkeresi a kéréshez tartozó könyvtárat és azon belül az index fájlt. Abban az esetben, ha a fájl tartalma (részben vagy egészben) PHP forrásszöveg, a rendszer a PHP fordítóprogramját segítségül híva lefordítja azt, és a programban szereplő utasításokat végrehajtja. Az adatbázis-kezelést ezen a ponton lehet megvalósítani a programokban elhelyezett adatbázis kezelő rutinok segítségével. Ez a gyakorlatban azt jelenti, hogy a nyelv által biztosított függvényeket a megfelelő paraméterekkel ellátva a forrásszövegbe ágyazzuk. Mi az egyszerűség kedvéért a MySQL rendszert fogjuk használni, mert nyílt forráskódú, ingyenesen hozzáférhető, könnyedén konfigurálható és nagyon elterjedt alkalmazás. Adatbázis-kapcsolat létesítéséhez rendelkeznünk egy saját adatbázis-kezelő rendszerrel, vagy hozzáférést kell szereznünk egy mások által üzemeltetett DBMS-rendszerhez.

Mindegy, hogy az első fejezet során bemutatott webszervert mi magunk készítettük el, és annak adatbázis kezelőjét használjuk, vagy a hozzáférés igénylését választottuk, mindkét esetben rendelkeznünk kell egy felhasználói névvel és egy jelszóval. Ezekre az adatokra szükségünk van a program megírása közben. A legtöbb szolgáltató nagyon ügyel a felhasználók és a saját adataik védelmére, ezért a szerverhez való hozzáférést a lehető legszigorúbb módon korlátozzák. Mindezek miatt előfordulhat, hogy az adott szerverre SSH, vagy Telnet kapcsolattal nem, kizárólag FTP-vel férhetünk hozzá. Sajnos ebben az esetben kizárt, hogy a MySQL rendszert közvetlenül, vagyis parancsosból használhassuk a táblák létrehozására. A megoldás a problémára az, hogy a táblák létrehozását is programok segítségével végezzük el, de mielőtt ezt megtennénk, tervezzük meg azt a táblát, melyben az adatainkat tárolni fogjuk.

Gyakorlásnak készítsünk egy egyszerű alkalmazást, amely felhasználók adatait tárolja egy kezdetleges „Home Location Register” alkalmazás számára. Készítsük el azt az SQL query-t, mely a tárolásra szánt táblánkat létrehozza. Az alábbi lista tartalmazza az SQL nyelvű utasítást, melyet a későbbiekben a PHP programunk segítségével, vagy a parancssorba gépelve elküldünk a DBMS számára.

CREATE TABLE users ( id int primary key auto_increment, nev varchar(255), kep varchar(255), telefon varchar(255), cim text)

Ha szükségünk van további adatokra, a táblát kiegészíthetjük az alter table utasítás segítségével. Vizsgáljuk meg, hogy mit jelent a query, vagyis mezőket tartalmaz az SQL utasítás. Az id mező a tábla elsődleges kulcsa (primary key). Erre minden tábla esetén szükség van, mivel ez a mező azonosítja a rekordokat (és nem mellesleg a tábláknak, valamint az egész adatbázisnak normál formában kell lennie). A mező típusa int, vagyis egy előjeles egész szám. Az auto_increment módosító azt jelenti, hogy az adatbázis-kezelőre bízzuk ennek a mezőnek a karbantartását. A rendszer adja az értéket és a törlések, módosítások után is gondoskodik a megfelelő következő érték megadásáról. A második mező a rekordokban szereplő személyek neveit hivatott tárolni. A típusa egy 255 karakter hosszú varchar, amely a MySQL lekérdező nyelvben a STRING típus megfelelője. A kep mező a személyekhez tartozó képeket fogja kezelni. A képeket nem az adatbázisban tároljuk, hanem a háttértáron a programjainkat tartalmazó fájlok mellett. A tábla csak a képek neveit és a hozzájuk tartozó elérési utakat tartalmazza, ezért elegendő a varchar típus. Az utolsó előtti mezőbe a telefonszámokat vihetjük be. Erre a célra egy 255 karakter hosszú változó szintén elegendő. Az cim esetében a text típust választottuk, mivel a cím meglehetősen hosszú is lehet.

Ahhoz, hogy a táblát létre is hozzuk, kapcsolódnunk kell az adatbázis-kezelőhöz és el kell küldenünk az elkészített query-t feldolgozásra. Ezt megtehetjük a szerver MySQL parancssorában, vagy egy PHP program felhasználásával. A következő programlista tartalmazza azt a programot, ami ezt a feladatot el is végzi. A forrást egy fájlba kell leírnunk, majd ezt a fájlt el kell helyeznünk a weboldalunk gyökérkönyvtárában. Ahhoz, hogy le is fusson, a böngészőben, a tanult módon hivatkozni kell rá.

<? $conID = mysql_connect('localhost', $USERNAME, $PASSWD); if (!isset($conID)) { echo "Hiba a kapcsolódás során. Hibaüzenet:".mysql_error(); }

mysql_select_db($DBNAME);

$querySTR = "CREATE TABLE users ( id int primary key auto_increment, nev varchar(255), kep varchar(255), telefon varchar(255), cim text)";

mysql_query($querySTR) or die ("Hiba a létrehozás során...<BR>".$querySTR); mysql_close($conID); echo "A tábla sikeresen létrejött...<br>"; echo $querySTR;

?>

Semmi esetre ne frissítsük a böngészőben a programot, mert a tábla létrehozása után az nem tud újból létrejönni, és csak újabb hibaüzeneteket kapnánk eredményül. Hibás program esetén sem fog a program a frissítések hatására megjavulni. A program futása után az „A tábla sikeresen létrejött” feliratnak kell megjelennie böngészőben. Hiba esetén viszont az adatbázis-kezelőtől érkező hibaüzenetnek, vagy az általunk kiírt hibának. Ha a „Hiba a kapcsolódás során...” kezdetű sort látjuk, a mysql_connect függvény környezetében keressük a hibát. A „Hiba a létrehozás során” üzenet, akkor jelenik meg, ha a query szövegét rontottuk el. Amennyiben túl vagyunk a hibakeresésen, vizsgáljuk meg a forrásszöveget (ennél a programnál nem ügyeltünk sem a karakterek megfelelő kódolására, sem a HTML kimenet minőségére. Ne csodálkozzunk hát, ha az ékezetes betűk helyett furcsa karakterek jelennek meg a képernyőn.)

A kód első sora a mysql_connect függvény hívását tartalmazza. Ennek a függvénynek többféle paraméterezése létezik. A mi programunkban a függvény első paramétere a localhost szó, mivel az adatbázis kezelő és a webszerver egyazon gépen foglal helyet. A localhost jelentése az, hogy a helyi hurokra kell kapcsolódni, vagyis a 127.0.0.1 IP-címre. Ez a paraméter kiegészülhet az adatbázis eléréséhez használt virtuális port számával. A második, és a harmadik paraméter az adatbázisok eléréséhez szükséges felhasználó nevet, és jelszót tartalmazza. Ezeket az adatokat érdemes védeni és egy helyen tárolni. Egyrészt azért, hogy ne törhessék fel a rendszerünket, másrészt, ha megváltoznak, ne keljen őket a program több pontján átírni. A függvény visszatérési értékét tároljuk egy változóban $conID abból a célból, hogy a következő feltételes elágazásban a kapcsolódás sikerességét meg tudjuk állapítani. Sikertelenség esetén hibaüzenetet írunk ki a böngésző ablakába.

A mysql_select_db függvény paramétere az adatbázis nevét tartalmazó változó. A név és a jelszó mellet ezzel az információval is rendelkeznünk kell. Az adatbázis azonosítóját a szolgáltatónktól kapjuk, vagy mi hoztuk létre saját rendszerünkön. Ebben az adatbázisban tárolódnak a tábláink, így a jelenleg használt users tábla is.

A $querySTR változóban helyeztük el a tábla létrehozását leíró parancsot. Az SQL utasításokat nem kell feltétlenül változóban tárolnunk, de érdemes, mivel így hiba esetén ki tudjuk íratni őket a képernyőre hibajavítási vagy ellenőrzési céllal. A mysql_query függvény elküldi az SQL parancsot a DBMS számára. Ha függvény valamilyen okból elbukik, a közvetlenül utána írt kivételkezelő átveszi az irányítást és kiírja a hiba lehetséges okát. A mysql_close függvénynek a feladata kapcsolat megszüntetése. Erre minden esetben szükség van, mert igaz, hogy a nyitva maradt kapcsolatok előbb-utóbb bezáródnak, de a nyitott kapcsolat még sebezhetőbbé teszi a könnyen támadható webes alkalmazásokat. Az adatbázisokkal dolgozó alkalmazások írásakor mindig ügyeljünk arra, hogy a kapcsolatokat a lehető legrövidebb időn belül zárjuk le. Másrészt ne számítsunk arra sem, hogy a kapcsolat a következő percben még nyitva van. Gondoljuk végig, hogy a weben tevékenykedő felhasználók miként használják a programokat. Néha kattintanak, előszednek egy régebbi címet, majd frissítik a böngésző ablakát. Akár hosszasan is várhatnak a monitor előtt, mire újra kattintanak valamire. Azt feltételezni, hogy a kapcsolat a két kattintás között eltelt idő alatt is fenn áll, tévedés. Ha rosszul írjuk meg a programot és nem gondolunk erre a körülményre, könnyen előfordulhat, hogy a kapcsolat magától bezáródik mire a felhasználónk rákattint a következő lekérdezésünkre. A programunk a legjobb esetben is egy hibaüzenetet ír a képernyőre. Az adatbázisokkal való kommunikáció az alábbi, egymástól jól elkülöníthető lépésekből áll:

1. Kapcsolódás a rendszerhez2. Adatbázis kiválasztása3. Query előállítása4. Query elküldése a szervernek5. Eredmény feldolgozása6. Kapcsolat bontása7. Hiba esetén a hiba kezelése

Ezek a rutinok ugyanabból a néhány lépésből, vagy utasítás sorozatból állnak, melyek szinte csak a paraméterekben térnek el (a felhasználó neve, a jelszó, vagy az SQL utasítás, amit a szervernek küldünk). Kézenfekvő megoldás a különböző rutinokat csoportokba foglalni, majd függvényeket írni, amely függvények bemenő paraméterei leírják a változó információt.

Weboldalak felépítése

Miután elkészítettük az adatok tárolásához szükséges táblát, megírtuk az adatbázis-kezelő rutinokat tartalmazó könyvtári modult, ne feledkezzünk meg arról sem, hogy a hálózaton mindenki számára elérhető, böngészőben működő alkalmazást fogunk készíteni. A programot valószínűleg fokozatosan tovább kell fejlesztenünk a felmerülő igények alapján. Ha mindezeket szem előtt tartva újratervezzük a programunkat, hamar beláthatjuk, hogy szükségünk van egy keretrendszerre, amelyben leírhatjuk a menükezelést, a menüpontokat és a tartalmukat tároló fájlokat. A különböző oldalak forrásszövegeit érdemes csoportosítanunk. Mielőtt tehát hozzákezdenénk az adatkezelő megírásához, készítsük el a keretprogramot.

Ebben a fájlban fogjuk leírni az oldal HTML kódját, vagyis a megjelenését. Ide linkeljük a menükezelő programrészeket, a menüpontok előállításához szükséges kódot, és a menük hatására megjelenő oldalak kódjának betöltése is ebben a részben kap helyet.

Ha ez sikerül, akkor az index.php fájlt már csak arra használjuk, hogy az újabb menük, vagy funkciók programjait integrálhassuk. Az oldalunk felépítése így némiképp hasonlítani fog a CMS-rendszerek szerkezetére. Ez bizonyára azért van így, mert a CMS-ek programozói is logikusan gondolkodva építik fel a programjaik szerkezetét. Az ábrán láthatjuk a moduláris szerkezet rajzát. Az ábra abban lesz a segítségünkre, hogy a modulszerkezetet jobban átlássuk és megérthessük.

<html><head><title>tesztprogram</title>

<meta http-equiv="content-type" content="application/xhtml+xml; charset=utf-8">

<meta http-equiv="content-style-type" content="text/css">

</head> <body> <table class=header> <tr> <td><? include "header.php"; ?></td> </tr> <tr> <td class=menu><? include "menu.php"; ?></td> <td class=content><? include "content.php"; ?></td> </tr> </table> </body></html>

A forrásszöveg a HTML-kód mellett tartalmazza a stíluslapra mutató hivatkozást, valamint a PHP-blokkokat. A blokkok kötelezően a <? ?> jelek között foglalnak helyet, hogy a webszerver felismerje a forrásszövegben leírt utasításokat. A

forráskód néhány pontján elhelyezett include függvények paramétere az adott ponton betöltendő fájlok neve (vagy elérési útja és neve). Készítsük el azt a HTML-kódot, amely segítségével betöltünk egy képet, valamint elhelyezünk egy rövid szöveget, ami a weboldal címeként funkcionál. Ezt a programot el kell mentenünk a header.php fájlba.

<table class="header" width="760"> <tr> <td><img src=images/header.jpg></td> <td>Weboldal fejléce</td> </tr></table>

A program úgy fog működni, mintha futás közben másolnánka helyére a paraméterként kapott fájlban leírt forráskódot, majd le is futtatnánk azt. Az include függvény számos lehetőséget kínál a programozó számára a dinamikus kódgenerálás, és kódátalakítás területén. Ezeket a lehetőségeket mi is ki fogjuk használni, méghozzá arra, hogy a menüpontokhoz tartozó tartalmak közül mindig csak az adott menünek megfelelőt mutassuk meg a böngészőben. A menüpontokat tartalmazó kódrészlet lehet akár egyszerű HTML-szöveg is, de a menüket is generálhatjuk listából, vagy adatbázis táblákban tárolt rekordok adataiból. Azért, hogy a weboldal a CMS-rendszerekhez hasonló módon működjön, tárolhatjuk a menüket is adatbázisban. A következő részben mindkét, vagyis a statikus és a dinamikus megoldásra is mutatunk példát.

Menüpontok előállítása <?

$menuk = array('1. Menupont neve', '2. Menüpont neve',...); $db = count($menuk); for ($i=0, $i<$db; $i++) { echo "<a href=index.php?d=$i>".$menuk[$i]."</a></br>"; }

if (!isset($_GET["d"])) {$_GET["d"] = 0;} switch($_GET["d"])) { case 1:include "menu1.php";break; case 2:include "menu2.php";break; case 3:include "menu3.php";break; case 4:include "menu4.php";break; default:include "kezdolap.php";break; }

//Az egyszerűség kedvéért elkészíthetjük tömbben a //az include-ban szereplő fájlok listáját is ... ... include $fajlok[$_GET['d']]; ...

?>

Az alábbi programlista tartalmazza a statikus menük leírását:

<table class="menutable" width="150"><tr><td><a class=menu href="index.php?d=0">Kezdőlap</a></td></tr><tr><td><a class="menu" href="index.php?d=1">Menü1</a></td></tr><tr><td><a class="menu" href="index.php?d=2">Menü2</a></td></tr>...</table>

Adatbázis alapú webalkalmazások

Az weboldal modulokra bontásának mintájára próbáljuk meg az adatbevitelt is a lehető legegyszerűbben megoldani. A webes felület nem teszi lehetővé az adatok közvetlen beolvasását. Mivel nem tudunk egyszerű beolvasó utasításokat használni, el kell gondolkodnunk a rendelkezésre álló lehetőségeken. A webböngésző elküldi a kéréseit a szerver 80-as portja felé. A webszerver feldolgozza a kérésben szereplő URL-t, és a benne hivatkozott oldalt megkeresi a gyökérkönyvtárban, majd a fájlban található PHP-forrásszöveget lefuttatva előállítja a kimenetet, amelyet visszaküld a böngészőnek. Láthatjuk, hogy a felhasználótól jövő adatok megszerzése lényegesen bonyolultabb, mint az operációs rendszeren futó, és felhasználói felülettel rendelkező programoknál. Webalkalmazások inputjának kezeléséhez kézenfekvő megoldás a webes űrlapok, közismert nevükön a formok használata. A form a HTML nyelvben használható egység, amely vezérlőelemeket, vezérléseket tartalmazhat. A vezérlés felhasználói interakciót segítő elem, melynek számos fajtája létezik. Az elemek listáját gyakran kiegészítik – kliens oldali szkriptnyelven írt – speciális vezérlésekkel.

A formokat a HTML-kódba vagy PHP-programokba ágyazva írhatjuk le, ahogyan ezt az alábbi programlistában is láthatjuk.

<form action="insert.php" method="post" enctype="multipart/form-data"> <input type="text" name="szoveg"> <input type="submit" name="btn1" value="OK"></form>

Vizsgáljuk meg az építőelemeket, amelyek segítségével a programban szerepelő formot létrehoztuk: Az action="insert.php" rész azt jelenti, hogy a form adatait az insert.php fájlban elhelyezett programmal dolgozzuk fel. A method="post" arra utal, hogy a form POST típusú, vagyis továbbküldi az adatokat a feldolgozó rutinokat leíró programrész felé. A multipart/form-data attribútumra azért van szükség, hogy később a fájlok kezelésénél a $_FILES változóba bekerüljenek a feltöltésre szánt fájlokat leíró, és azok feldolgozásához szükséges adatok. Az űrlapokban használható vezérlők elegendő támogatást nyújtanak, hogy bármilyen adatot el tudjunk juttatni a kliens oldaltól a szerverig és vissza, ezért érdemes megvizsgálnunk a fontosabbakat.

A text mező a rövid szöveges adatok beolvasására használható: <input type="text" name="szoveg" ...>. Ha az input jelölő type attribútumát password-re állítjuk, speciális szövegbeviteli mezőt kapunk, melyben a karakterek helyét csillagok vagy pöttyök jelölik (az operációs rendszer beállításaitól függően). A textarea egy páros HTML nyelvi elem, amely egy több soros szöveg bevitelére alkalmas szövegdobozt hoz létre. A <textarea> és a </textarea> tag-ek közé írhatunk szöveget, amely megjelenik a vezérlés felületén. A rows és a cols attribútumokkal a szövegdoboz sorainak és oszlopainak a számát adhatjuk meg, a name attribútum pedig a kontorllhoz rendelt változó nevét definiálja. A checkbox, segítségével a több lehetőség közüli választást tehetjük lehetővé a felhasználók számára. A checkbox-okat csoportosíthatjuk, és a csoportból egyszerre több, vagy akár mindegyik elem lehet aktív mikor a form elküldésre kerül. A radio nevű elem egy hagyományos rádiógombot hoz létre a form felületén. A checkbox-okhoz hasonlóan ezeket az

elemeket is tudjuk csoportosítani. Az elemek neveinek egyeznie kell, az értéküknek viszont különbözni egymástól (value). A csoportban egyszerre csak egy elem lehet kijelölve, így a csoport segítségével a felhasználót eldöntendő kérdések megválaszolására késztethetjük. <input type="radio" name="r1" value="1">.

Létezik fájlok tallózására alkalmas vezérlés is, amely a következő sor felhasználásával készíthető el: <input type="file" name="file1">. Amint láthatjuk, a vezérlés típusa file, a neve pedig file1. Ne használjuk a típussal megegyező nevet, mert ezzel sok problémát okozhatunk magunknak a változók feldolgozása során. Ez az elem úgy működik, hogy a nyomógombja elindít egy fájl tallózó varázslót, amelyben a feltöltésre szánt fájlt tudjuk kiválasztani. Ha nem akarunk tallózni, begépelhetjük az elérési utat és a fájl nevét. A fájltallózás során egyszerre csak egy fájl választható ki feldolgozásra.

Könyvtár kiválasztására alkalmas tallózót ne is keressünk. A több fájl, vagy könyvtár kezelése alapvető biztonsági rés lenne, mivel ebben az esetben a szerver oldali szkripteknek lehetőséget kellene adnunk a felhasználók helyi könyvtárainak az olvasására (Linux esetén az X jog használatára is). A form-on elhelyezhető elemek közül számunkra ennyi elegendő lesz. Segítségükkel minden olyan adatot be tudunk olvasni, amelyre szükség lehet, a beolvasáshoz viszont ennyi tudás még nem elegendő. A form segítségével megszerzett információt fel kell dolgozni, a megfelelő helyre eljuttatni, tárolni, valamint reagálni kell a felmerülő hibákra. A fejezet következő részében ezekkel a problémákkal foglalkozunk. A már elkészült weboldalunkba modulként helyezzük el az adatbevitelt megvalósító programrészeket, majd az adatbázis-kezelő modul segítségével tároljuk a felhasználótól jövő információt.

Ha az adatfolyam működését vizsgáljuk, ki kell térnünk a web sajátos állapotnélküliségére. Ellentétben az kliens gépeken működő programokkal, a weboldalak egy sajátos, úgynevezett „állapotnélküli” állapotban léteznek. Valójában ez az első látásra ellentmondásos helyzet teszi biztonságossá a webes felületet és a weboldalak egymás közötti, valamint a weboldalak és a webszerver közti adatáramlást. Ha egy oldal címét begépeljük a böngészőbe, akkor az letölti a szerverről a címben kért tartalmat. A weboldal forrásában szereplő programrészek létrehoznak változókat és feltöltik azokat adatokkal. Az így létrejött változók, valamint adatok halmazát nevezzük a program állapotterének. A weboldal használója kattint egyet az oldalon, vagy egyszerűen csak frissíti a böngészőjét, a program által használt változók nagy része teljesen, másoknak csak a tartalma vész el, mivel a frissítés esetén a program újra lefut és minden olyan utasítást végrehajt, amit az előző futása során is végrehajtott. Így sajnos felülírja a korábban értékkel ellátott változóit. Az „éppen futó” weboldalak közti adatcsere csak speciális módon oldható meg. Globális értékek tárolására használhatunk munkamenet-változókat, vagy külső tárolókat: fájlt, esetleg adatbázist. A form-ok esetében az adatátvitel nem ennyire kényelmetlen, de itt is oda kell figyelnünk, ha mindent szépen és helyesen akarunk megvalósítani. A webszerver beállításaitól függően kétféleképpen lehet az adatokat a form-tól megszerezni.

A rossz megoldás az, ha a form-ban definiált változókra a feldolgozást végző programban közvetlenül hivatkozunk ($szovegdoboz1, $file1). Ahogy azt korábban

már említettük, ez a megoldás egyes szervereken működik, ahol a REGISTER_GLOBALS direktíva alapértékre van állítva, de ezeknek a szervereknek a száma egyre kevesebb, és abban sem lehetünk biztosak, hogy a szerver üzemeltetője nem változtatja meg a beállításokat. A jó megoldás az, ha a $_GET a, $_POST, és fájlok esetén a $_FILES tömböket használjuk az adatok feldolgozására. A rendszer ezekbe helyezi el a form-októl érkező adatokat. A post típusú form-ok esetén a $_POST asszociatív tömbbe, a get típusúnál a $_GET-be. A $_FILES tömbbe a file tallózó felől érkező fájl adatai kerülnek bele. Minden tömbelem az adott vezérlés nevével megegyező nevű változó értékét tartalmazza, amelyre a változó nevével megegyező címke segítségével hivatkozhatunk: $_POST['vezérlés_neve']. Igazság szerint, ezek a tömbök a weboldalunk globális változói, amelyek segítségével megoldhatjuk az adatok tárolását és átvitelét az egyes oldalak és aloldalak váltogatása közben. Minden weboldalhoz, illetve minden weboldal egy példányához létrejön egy munkamenet, más néven SESSION, amelyben szabadon tárolhatunk akármit.

Most, hogy ismerjük az adatátadás elméleti kérdéseit, nézzük meg, hogyan jut el az információ a form-tól a feldolgozást végző modulig. Emlékezzünk vissza, hogy a korábban elkészített űrlapra, ami egy fájlra hivatkozik. Ennek a fájlnak az a feladata, hogy az űrlap adatait feldolgozza. Ez valójában azt jelenti, hogy ha a felhasználó a submit gombra kattintva aktivizálja a form-ot, a böngészője odaadja a fájlban található forráskódot a webszervernek. Ez a fájl nem ír semmit a képernyőre, csak elvégzi a számára előírt feladatokat. Ha elvégezte a munkáját, visszaadja a „vezérlést” egy másik programrészhez, ami informálja a felhasználót a történtekről. Miután láttuk, hogyan hívódik meg és tér vissza a program, készítsük el azt a modult, amely az adatok felvitelére szolgál. Most folytassuk a korábban elkezdett programunkat! A könyvek adatainak felviteléhez szükségünk lesz egy űrlapra, valamint egy olyan modulra, amely a felvitt adatokat tárolja, és meg tudja jeleníteni. Később készíthetünk keresést, valamint különböző szűréseket is az adatok rendszerezéséh.

<form action="beszuras.php" method="post" enctype="multipart/form-data"> <input type="text" name="nev"><BR> <input type="file" name="kep"><BR> <input type="text" name="telefon"><BR> <textarea rows="10" cols="50" name="cim"></textarea><BR> <input type="submit" value="Hozzáadás"></form>

Most, hogy elkészült a forráskód, mentsük el az add.php nevű fájlba, majd a menükezelő modulban helyezzünk el egy hivatkozást a fájlra.

<?

... switch($_GET["d"]) { ...

case 1:include "add.php";break; case.. } ...

?>

A menüpontok között is helyezzük el a megfelelőt. Mivel statikus menüt készítettünk egyszerűen helyezzük el a forráskódba a következő linket:

...<a href=index.php?d=1>Register</a> ...

Ha mindent jól csináltunk, a menüpontra kattintva az alábbi ábrán szereplő űrlapot kell látnunk. Hozzuk létre a programot, amely a beszúrást végzi:

<?

$c = mysql_connect('localhost','username','password'); mysql_select_db("wedb");

$querystring = "insert into users(nev, kep, telefon, cim) values ('".$_POST['nev']."','" .$_FILES['kep']."','" .$_POST['telefon']."','" .$_POST['cim']."')";

mysql_query($querystring) or die('Hiba...'); mysql_close($c);

echo '<meta http-equiv="refresh" content="0; URL=index.php?d=1">';

?>

A forráskód első látásra bonyolultnak tűnik, de ha jobban megvizsgáljuk, rájövünk, hogy minden karakternek megvan a szerepe. A mysql_connect és a mysql_selectdb függvények kapcsolódnak az adatbázis kezelőhöz, és kiválasztják azt az adatbázist, amire a programnak szüksége van. A következő néhány sor, ahol a $querystring nevű változót előállítjuk, a program legfontosabb és egyben legbonyolultabb része. Ezt a stringet küldjük el az adatbázis kezelőnek, ami majd elvégzi az általunk összeállított rekord beszúrását. A rekord a form adataiból épül fel. Sorban a megadott névből, amely a $_POST['nev'] formulából kerül ki. A $_POST tömb a post típusú form-hoz létrejött asszociatív tömb, melynek a 'nev' címkével hivatkozott eleme a form $nev változóját tartalmazza.

A többi POST elemmel ugyanez a helyzet, csak ezekben nem a nevet, hanem más adatokat tárol a rendszer. Ezeket is hozzáfűzzük a beszúrandó rekordhoz, vagyis ahhoz az SQL nyelvű utasításhoz, amit a $querystring változóban készítünk el.

A $_FILES tömbben elhelyezett $kep változó valamivel bonyolultabb az előzőeknél, mivel minden eleme egy, a felhasználó által feltöltésre kiválasztott fájl adatait tartalmazza. Ez egy összetett adatszerkezet, amely a fájl neve, elérési útja, típusa és mérete mellett minden olyan információt tartalmaz, ami a fájl feldolgozásához szükséges. A fájl neve és elérési útja segítségével fel kell azt másolnunk a webszerver egy erre a célra kijelölt könyvtárába. Létre kell hoznunk az új nevét, majd az így létrejött elérési utat és fájlnevet „összeragasztva” hozzá kell fűzni azt az SQL-parancshoz.

A fájl nevének megváltoztatása nagyon fontos lépés, ha nem akarunk hibákat kapni a feltöltés során. Egyrészt azért van szükség rá, mert a feltöltött képek nevei tartalmazhatnak olyan karaktereket, amelyeket a webszerver elérési útként nem tud kezelni. Ilyen például a szóköz, ami egyes operációs rendszerek esetén az elérési út végét jelenti, és ami ezután következik azt az operációs rendszer nem veszi figyelembe. Másrészt arról is gondoskodnunk kell, hogy a feltöltött fájlok nevei ne egyezzenek meg. Ebben az esetben vagy sikertelen lenne a feltöltés, vagy a régebben feltöltött fájlokat egyszerűen felülírnánk. Ezt a problémát később megoldjuk egy rövid függvénnyel, ami eltávolítja a nemkívánatos karaktereket a névből, valamint elé helyez egy viszonylag hosszú véletlen számot.

A fájlkezeléssel még korai lenne foglalkoznunk, az adatbázis-kezelő felé küldött SQL-parancs viszont érdemel egy kis figyelmet. Ez a technika a dinamikus weboldalak programozásánál elengedhetetlen, és talán az egyik legérdekesebb dolog. Az adatbázis-kezelő számára küldött SQL-parancsokat a program futás közben, felhasználói beavatkozások hatására állítja össze. Ez a gyakorlatban azt jelenti, hogy a lekérdezéseket a form-ok adataiból létrejövő változókból, és a megfelelő SQL-nyelvi elemekből állítjuk elő. Erre a dinamizmusra azért is szükség van, mert a lekérdezéseket lehetetlen lenne előre megírni.

A forrásszövegben elkészített SQL parancs a következőképp áll össze: Az query első része tartalmazza magát az műveletet, amit el kell végezni. Tartalmazza továbbá a tábla nevét, amibe be kell szúrni az adott rekordot. A következő rész a values kulcsszó előtt, zárójelek között megadja azokat a mezőket, amelyekbe az adatok bekerülnek. Az id mező, vagyis a tábla elsődleges kulcsa automatikusan kap értéket. Ezt a mezőt ki kell hagynunk a listából. A következő zárójeles lista tartalmazza a beszúrandó értékeket. Ez a része a query-nek komplikált, mivel tele van aposztrófokkal, idézőjelekkel, vesszőkkel és zárójelekkel. Az SQL-részekhez hozzá kell fűznünk a PHP-nyelvben definiált változók tartalmát, amelyek egy munkamenet-változóban tárolódnak. Az aposztrófok és az idézőjelek ebben az esetben nagyon hasznosak, mivel ezáltal a fordító és értelmező program meg tudja különböztetni egymástól a használt nyelveket.

Ahhoz, hogy a '".$_POST['nev']."','. kódrészletet értelmezni tudjuk, nézzük meg, hogy egy statikus lekérdezés esetén hogyan nézne ki a beszúrandó elemek listája!

insert into users (cim,picture,leiras, ...) values ('Személy neve','kepe01','Személycíme', ...)

Láthatjuk, hogy a beszúrni kívánt adatokat az SQL string-ként értelmezi, ha idézőjelek közé írjuk azokat. Az egyes elemeket vesszővel kell elválasztani egymástól. A dinamikus lekérdezésben is ezért van szükség az aposztrófokra és avesszőkre: ','" . $_POST['nev'] . "','.

Az "" idézőjelek a PHP programokban a karakterláncokat kezdik és zárják le. Az SQL nyelvű darabok elején és végén is ezt a szerepet töltik be. Vegyük észre, hogy a query-k egyszerű szövegek, amelyek csak összeillesztve és az adatbázis-kezelőnek elküldve nyernek értelmet. Csak akkor válnak valódi utasítássá, ha az adatbázis-kezelő értelmezi őket. Az "" jelekkel elválasztott részek között a pontok (.) a PHP nyelvben szöveges adatok összefűzését jelentik. Az SQL-parancsban a szerepük az, hogy a PHP változóinak a tartalmát hozzáfűzzék az SQL-parancs darabjaihoz.

A forrásszöveg utolsó néhány sora azért felelős, hogy lezárja az adatbázis-kapcsolatot, valamint azért, hogy a beszúrás után visszakerüljünk arra a helyre, ahonnan elindultunk, vagyis a beszúrást kezdeményező űrlaphoz. A visszalépést egy META utasítással valósíthatjuk meg a legegyszerűbben. A META utasításban leírjuk, hogy mennyi ideig kell várni a beszúrás után (ez jelen esetben 0), és melyik oldalt kell betölteni a böngészőbe, vagyis, hogy hova kell ugrani. A REFRESH azt jelenti, hogy frissíteni kell a böngészőt, az URL pedig definiálja az oldalt, amit be kell tölteni.

Mi azt az egyszerű megoldást választjuk, hogy azt az linket írjuk az utasítás url részéhez, amit az adatfelvitelhez használt menüpont mellé is írtunk. Ez az index.php?d=1 link. Ezzel azt érjük el, hogy a felhasználónk az adatok begépelése után, a submit gombra kattintva ráveszi a böngészőt a frissítésre. Ezután azonnal visszakapja a felviteli form-ot. Látszólag csak ennyi történik, de közben az adatai bekerülnek az adatbázisba, és ha elkészítjük a kiírást megvalósító modult, akkor ezt az új bejegyzés láthatóvá is válik a számára.

Amennyiben a táblánk rekordjai között megjelenik az utoljára bevitt adatsor, a program jól működik, és hozzáláthatunk az adatokból felépülő lista elkészítéséhez. Az adatbázis-kezelő modul erre a feladatra is kínál lehetőséget. A query2 függvény paraméterként egy SQL-parancsot vár, és eredményként visszaadja a rekordokat egy listában. A dolgunk csak annyi, hogy ezt a listát feldolgozzuk, és HTML kódba ágyazva megjelenítsük. Az eredménylista hosszát nem tudjuk konstansként kezelni, mivel az a rekordok számától függ. Kézenfekvő, hogy ciklusutasítással dolgozzunk. A ciklust akkor állítjuk meg, ha elfogytak a rekordok, vagyis ha már minden adatot megjelenítettünk a kliens számítógép böngésző programjában. A kérdés az, hogyan vesszük észre, hogy a lista végére értünk? A PHP nyelv tartalmaz egy mysql_fetch_row nevű függvényt, mely a segítségünkre lehet az ismétlés megállításához.

<?

$c = mysql_connect('localhost','username','password'); mysql_select_db("webdb");

$querystring = "select * from users";

$result = mysql_query($querystring);

echo "<table width=100% border=1>"; while (list($id, $nev, $kep, $cim) = mysql_fetch_rows($result)) { echo "<tr><td>$id</td><td>$nev</td></tr> <tr><td colspan=2>$kep</td></tr> <tr><td>$cim</td></tr>..."; }

echo "</table>";

mysql_close($c);

?>

A PHP program kimenetét HTML formátumban jelenítettük meg. Az első néhány sorban kapcsolódunk az adatbázis-kezelőhöz, előállítjuk a lekérdezést, generáljuk az eredményből a HTML-kimenetet, majd lezárjuk a kapcsolatot. Miután elmentettük (a mentéshez használhatjuk a kiiras.php nevet), ezt a programrészt is integrálnunk kell a könyvtáralkalmazásunkba. Ezt megtehetjük úgy, hogy a beviteli form forráskódjába elhelyezzük a következő sort:

include "kiiras.php";

Ha a beviteli űrlapot leíró rész elé helyezzük el a hivatkozást, akkor előtte, ha utána helyezzük el, akkor utána jelenik meg a lista. Amennyiben több rekorddal dolgoztunk, akkor azok egymás alatt jelennek meg a felvitel sorrendjében. Ez a megjelenési forma hosszú listák esetén nem túl praktikus, mivel a lista hosszának növekedésével az oldalunk egyre áttekinthetetlenebbé válik. Hogy ezt a problémát orvosoljuk, elég annyit tennünk, hogy a kiírást kicsit megváltoztatjuk. Sokkal átláthatóbb lesz a lista, ha a képek méretétől függően két, vagy három elemet helyezünk el egy sorban. Az esztétikusabb külső kialakításához természetesen használhatunk stílus fájlt (CSS), vagy formázhatjuk közvetlenül a HTML kódot.

Adatbázis kezelő modul készítése

Amennyiben azt szeretnénk, hogy az adatbázis-kezelő függvények egy helyen legyenek könyvtári modult készíthetünk a használatukhoz. Így az alacsony szintű adatbázis kezelő műveleteket ki tudjuk cserélni úgy, hogy a függvényeink interface részét nem alakítjuk át, csak a függvények blokkjában szereplő utasításokat. Az, hogy a programjainkat platform függetlenre készítjük el egy alapvető, és nagyon hatékony programozási technológia. Ezt technológiát köztes middleware névvel illetjük.

A függvények csoportosítást érdemes a különböző funkciók mentén elvégezni. Kell egy csoport a kapcsolat létrehozásához, egy a query-k elküldéséhez, és egy a platform függetlenség megtartása érdekében a kapcsolat bontásához. Készítsük el az adatbázis kezelő modulunkat és ezt is helyezzük el a megfelelő könyvtárba, az index.php fájl mellett. A korábban megírt tábla létrehozás rutint nem kell ebbe a modulba integrálni, mert annak minden funkcióját kiváltjuk a modul függvényeivel.

<? #====DB module==================================== # Author : Szerző # Date : 2010.12.11 #=================================================

function connect() { $ID = mysql_connect($HOST, $USER, $PWD); id (!isset($ID)) { return "error : ".mysql_error(); } return $ID }

function select_db($DBNAME) { mysql_select_db($DBNAME); }

function query1($querySTR) { mysql_query($querySTR) or die ("error".mysql_error()); }

function query2($querySTR) { $result = mysql_query($querySTR) or die ("error".mysql_error()); return $result;

}

function close($ID) { mysql_close($ID); } ?>

Vegyük sorra, hogy milyen elemeket tartalmaz a könyvtári modulunk. Rögtön az elején található a modulra vonatkozó minden fontos információ. Ez a rész 'comment', és nem tartalmaz semmi olyat, ami a program futását befolyásolná, de ennek ellenére mégis nagyon fontos szerepe van. A fejlesztők az itt leírt információk segítségével tájékozódhatnak a forráskód életciklusát érintő minden fontosabb információról.

A connect, a select_db és a close függvények a korábban megismert funkciókat látják el. A két különböző query függvény feladata viszont eltérő, ezért is van belőlük kettő. A query1 a beszúrás, módosítás és törlés típus lekérdezéseket hajtja végre, míg a query2 azokat, melyek adatokat szolgáltatnak a programunk felé további feldolgozásra. Mivel a PHP nem készít tárgykódot, a kész modult elég az alkalmazás többi fájlja mellé másolni, majd minden olyan helyen láthatóvá tenni, ahol használni szeretnénk. Ez a gyakorlatban azt jelenti, hogy azokban a programokban, melyekben a modul függvényeit használni akarjuk, el kell helyezni egy include, vagy egy require függvényt a modul nevével paraméterezve.

<?

#felhasználási helyen require "dbmodule.php"; #vagy require_once "dbmodule.php"; #így nem duplikálhatjuk a linkelést, #ha esetleg nem figyelnénk oda

?>

Platform-független adatbázis kezelő készítéséhez a fenti query2 függvény nem elegendő. A függvény hívási helyén sajnos szükség van mysql specifikus függvényekre ahhoz, hogy a DBMS felől érkező adatokat feldolgozzuk.

<?

... while(list($v1, $v2, ..., $vn) = mysql_fetch_row($result)) { ... } ...

?>

A probléma a mysql_fetch_row függvénnyel van, mivel a főprogram minden olyan részén meg kell hívnunk, ahol az adatokat fel szeretnénk dolgozni. Megoldásként átalakíthatjuk a query2 függvényt úgy, hogy a fetch_row funkcióit valósítsa meg, vagyis bontsa sorokra a rekordlistát, majd helyezze egy asszociatív tömbbe az eredményt.

<? ... function query2($querySTR) { $lista = array(); $result = mysql_query($querySTR) or die ("error".mysql_error()); while ($line = mysql_fetch_assoc($result)) { $lista[] = $line; } return $lista; } …?>

A módosított query2 függvény első sora definiál egy tömböt az array() függvény meghívásával. Az SQL lekérdezés eredményét egy while ciklusban soronként belerakja a $line tömbbe. A kapott tömböt a főprogram a következőképp tudja feldolgozni: két foreach egymásba ágyazásával minden hasznos információ kinyerhető az eredmény listából. A külső ismétlés a sorokat adja, a belső pedig egy mintaillesztés segítségével kiválasztja az adott sorból a mezőneveket, és a mezők tartalmát.

<? ... $lista = query2('select * from tablename'); foreach ($lista as $line) { foreach ($line as $k => $v) { echo "$v a kulcs, $k az adat<br>"; } } ... ?>

Az adatfeldolgozásnak ez a módja elég általános ahhoz, hogy a főprogram bármely részén, vagy akár más programokban is fel tudjuk használni az adatbázis kezelő modulját. A forrásszövegben már csak egy olyan rész van, melyről eddig nem beszéltünk, a mintaillesztés a belső foreach-ben.

foreach ($line as $k => $v)...

A $line változó tartalma - ami egyébként egy asszociatív tömb egy elemének felel meg - egy key => value formájú adat. Az első része a tömb adott elemének a kulcsa (neve), a második pedig a kulcshoz tartozó adat (érték). A mintaillesztés során a $k változóba bekerül a kulcs, a $v változóba pedig a kulcshoz tartozó, ezért van szükség a formulában a => szelektor használatára. A modult ezzel a kis módosítással általános felhasználásúvá alakítottuk, mivel ügyeltünk arra, hogy a függvények paraméterezéstől függően minél több programban fel lehessen azokat használni.

Az adatbázis kezelést ”átlátszóvá” tettük a platformfüggetlen interface elkészítésével, így az adatbázis kezelő rendszer cseréje során a főprogramot nem kell megváltoztatni. Minden olyan módosítás, ami az adatkezelést érinti elvégezhető a modul függvényeinek átalakításával, vagy az inteface megtartása mellett a modul teljes cseréjével.

Fájlkezelés, és jelszavak használata

Az űrlapnak és a hozzá kapcsolódó programnak már csak egy hiányossága van: a képek felvitelét végző programkódot még nem írtuk meg. A feltöltés során az adatbázisba bekerülnek a képekhez tartozó elérési utak, de a képek nem kerülnek fel a szerverre, így megjeleníteni sem lehet őket. Sajnos a fájlok feltöltése sokkal bonyolultabb művelet, mint az egyszerű szövegek bevitele, mivel a feltöltéshez igénybe kell vennünk az FTP (File Transfer Protocol) szolgáltatásait. A PHP-nyelv erre a problémára is kínál megoldást.

Amennyiben szép programot szeretnénk írni, akkor érdemes a fájl feltöltéséhez egy függvényt készíteni, melyet más modulokból is meghívhatunk. Mi az egyszerűség kedvéért az adatbevitel programját egészítjük ki a megfelelő programrészekkel.

<? $safe_filename = str_replace(" ","",$_FILES['kep']['name']); $safe_filename = rand().$safe_filename; move_uploaded_file ($_FILES['kep']['tmp_name'],"images/". $safe_filename);

$c = mysql_connect('localhost','username','passwd');

mysql_select_db("webdb");

$querystring = "insert into users (cim,picture,leiras) values ('".$_POST['nev']."','"."images/". $safe_filename."','" .$_POST['cim']."')...";

mysql_query($querystring) or die('Hiba'); mysql_close($c);

echo '<meta http-equiv="refresh" content="0; URL=index.php?d=1">';

?>

Ahogy a kibővített program forráskódjában láthatjuk, a fájl feltöltése az adatbázis-műveletek elé került. Ennek az az oka, hogy a fájl nevét a másolási művelet után be kell szúrnunk az users tábla megfelelő mezőjébe. Erre azért van szükség, hogy a feltöltött képet a kiírást végző program be tudja tölteni a kliens böngészőjébe. A feltöltés előtt illik megvizsgálni a kép méretét, típusát, és meg kell változtatni a nevét úgy, hogy minden kritériumnak megfeleljen. Egy reguláris kifejezés segítségével kivesszük a nemkívánatos karaktereket, szóközöket és egy véletlenszám-generátor segítségével egyedivé tesszük a fájlnevet. Miután előállítottuk a megfelelő fájlnevet, a fájlt a move_uploaded_file függvény alkalmazásával felmásoljuk a szerver images könyvtárába. Erre a könyvtárra már korábban érvényesítettük a megfelelő jogosultságokat.

Mivel a biztonságra sem nagyon ügyeltünk, ezt a programot még ne tárjuk a nyilvánosság elé, ugyanis még a legegyszerűbb feltörési kísérleten fennakadna a beviteli űrlap. Próbáljuk megoldani a lista hosszának a gondját, vagyis azt, hogy egy erre a szerepre kijelölt felhasználó tudjon törölni adatokat a listából. Ezt a programot nem kell az alapjaitól megírnunk, mivel az adatok kiírását segítő listánk már készen van. Elég ezt a forráskódot átalakítani úgy, hogy minden kiírt rekord köré készítünk egy form-ot, amely tartalmazza a rekord egyedi azonosítóját, vagyis az id mező értékét, illetve egy submit gombot a rekordtörlés kezdeményezésére. Készíthetünk egy form-ot is, és a submit gombok nevével azonosíthatjuk, hogy melyik rekordot kell törölni, de ez a megoldás sokkal bonyolultabb és nehezen lehet továbbfejleszteni.

A feladat tehát az, hogy nyissuk meg a kiiras.php fájlt, majd mentsük le admin.php néven. Ezt a fájlt, vagyis a tartalmát ne integráljuk a főoldalunkba, mert az adminisztrációs oldalt úgyis csak néhány felhasználó látja, és így sok feltörést célzó kísérlettől megóvjuk magunkat. Később ezt a fájlt jelszóval is megvédjük, hogy jogosulatlan személyek ne férjenek hozzá és ne töröljenek adatokat az adatbázisból. Ha lementettük a programot, át kell alakítanunk a kiírást végző ciklust a következő programlista alapján.

<?

$c = mysql_connect('localhost','username','passwd');

mysql_select_db("webdb");

$querystring = "select * from users order by cime"; $result = mysql_query($querystring); echo "<table width=100% border=1>";

while (list($id, $nev, $kep, $cim, ...) = mysql_fetch_rows($result)) { echo "<form action=torles.php method=post> <input type=hidden name=id value=$id>"; echo "<tr>><td><input type=submit value=X></td> <td>$id</td><td>$nev</td></tr> <tr><td colspan=3>$kep</td></tr>"; echo "</form>";}

echo "</table>"; mysql_close($c);

?>

Ahogyan láthatjuk, a korábbi program módosításával elértük, hogy törölni is lehessen a listából, viszont még elő kell állítanunk azt a programrészt, amely az adott rekordot ki is törli az adatbázisból. Ezzel a programmal sem kell sokat bajlódnunk, mivel a programot némi átalakítás árán alkalmassá tehetjük a törlés lebonyolítására. Ha

megvizsgáljuk a kódot, hamar rájöhetünk az átalakítás lépéseire. A program csak az SQL-parancs paramétereiben fog eltérni, és abban, hogy hová kell visszatérnünk a művelet elvégzése után.

Helyezzünk el a menüpontjaink között egy olyat, ami a törlés listáját tölti be a böngészőbe. A törlés hasonlóan működik, mint a beszúrás, mindössze az SQL-szintű műveletben tér el attól. A ciklussal generált listában tároljuk a rekordok azonosítóját a hidden mezőben, amit a submit gomb lenyomása után a törlésre elkészített program megkap a form-tól. A submit lenyomását követően már csak annyi dolgunk marad, hogy az id változóban tárolt azonosító alapján töröljük a rekordot az adatbázisból. A META utasítás segítségével visszakerülünk a listához, ami természetesen frissül. A bemutatott műveletsort a felhasználó úgy érzékeli, mintha a gombra való kattintás után a törlésre szánt rekord egyszerűen eltűnne a listából.

Weboldalak védelme

Az utolsó lépés az adminisztrációs felület elkészítéséhez a jelszavas beléptetés megírása. A beléptetéshez egy nagyon egyszerű megoldást választunk, ami nem teljesen biztonságos, de számunkra bizonyosan megfelelő lesz. A bejelentkezést egy speciális elem, a header küldésével oldjuk meg. Így a név, és a jelszó begépeléséhez szükséges beviteli mezőket, és a hozzájuk tartozó nyomógombot nem nekünk kell előállítanunk. A header küldésével viszont van egy kis probléma: a korábban elküldött header blokkolja a miénket. Ahelyett, hogy elindulna a beléptetés, a „header alredy sent” üzenetet kapjuk a böngészőben, ami értesít bennünket a problémáról. Ez egy nagyon szerencsétlen helyzet, mivel a beléptetéshez szükséges ablak nem jelenik meg, így a felhasználónak nem marad semmi esélye a további munkára.

<?if( !isset($_SERVER['PHP_AUTH_USER']) ){ header("WWW-Authenticate:Basic realm=\"Type your login\""); header("HTTP/1.0 401 Unauthorized"); exit;}else{ if (($_SERVER['PHP_AUTH_USER']=='usernev') & ($_SERVER['PHP_AUTH_PW']=='jelszo')) { #Védett rész... }}?>

A program több felhasználós változata sem teljesen biztonságos, de már nem csak egy nevünk és jelszavunk van, amit cserélgetünk egymás között...

<? if( !isset($_SERVER['PHP_AUTH_USER']) ) { header("WWW-Authenticate: Basic realm= \"Jelszobevitel...\""); header("HTTP/1.0 401"); exit; } else { // config.php // require_once("config.php"); // $listam = array('username' => 'passwd', ...); // a config fájlban feltételezünk egy tömböt a

// nevekkel és a jelszavakkal...

if ($listam[$_SERVER['PHP_AUTH_USER']] == $_SERVER['PHP_AUTH_PWD]) {

//védett program helye... } }

?>

Az üzembe helyezéshez a dolgunk annyi, hogy elhelyezzük a fenti kódrészletet a torles.php fájlban található kiírás elé, valamint a feltételes elágazásokat lezáró }jeleket a lista végére. A bemutatott beléptető rendszer egyszerű adminisztrációs felületek készítése esetén alkalmas arra, hogy az alapvető biztonságot megteremtse, de használata mellett nem lehet nyomon követni, hogy melyik felhasználónk van bejelentkezve, ki mit csinálhat és mikor. Bonyolultabb rendszerek esetén alkalmazhatjuk a session-kezelést, ahol az oldalhoz tartozó „munkamenet”-változókban tároljuk el a felhasználók nyomkövetéséhez elengedhetetlen, de minimális mennyiségű információt. Minél kevesebb adatot tárolunk, annál biztonságosabb lesz a rendszer. Soha ne helyezzük el a felhasználó nevét, vagy jelszavát a munkamenetbe, és csak olyan alapvető információkat tartsunk benne, melyek a program számára minimálisan elegendőek.

Ha a session-kezelést választjuk, és nem akarunk bajlódni a header küldözgetésével, érdemes elkészítenünk a saját beléptető űrlapunkat a már megismert form kontrollok alkalmazásával. A jelszavakat – mivel most nem adminisztrátori jogköröket kezelünk – elhelyezhetjük a felhasználók táblájában, ahol a neveiket és a személyes adataikat tároljuk, de tehetjük őket külön táblába is. Ekkor a két táblát egy külső kulcs segítségével összeköthetjük, biztonságosabbá téve ezzel az adatok kezelését.

A beléptető űrlap, és a SESSION, vagyis munkamenet változó segítségével már azt is tudjuk kezelni, hogy ki milyen adatokat tud módosítani és törölni. Minden felhasználó a sajátját, az adminisztrátor felhasználók pedig az összes rekordot. Most készítsük el a beléptetést, valamint a tábla módosításához, és a törléshez szükséges programot. A törlési listánk ezután működhet úgy, hogy a felhasználó látja az összes rekordot a táblából, de csak a sajátja(i) mellett jelenik meg a törlés gomb. Elkészíthetjük a listát úgy is, hogy a felhasználó csak az általa felvitt rekordokat látja, és törölheti is azokat.

Hogy mindezt megvalósítsuk, el kell egészítenünk a users táblát három új mezővel. Az egyik a bejelentkezéshez szükséges nevet, a másik a kódolt jelszót tárolja. A kódoláshoz md5 titkosítást használunk, ami manapság igen biztonságosnak számít, mivel a feltörése annyi időt vesz igénybe, ami józan emberi számítás mellett egyszerűen nem éri meg. Olyan hosszú ideig tart, hogy nem kezd bele senki, aki ismeri a kulcs működését. A következő programlistában láthatjuk, hogyan lehet hozzáadni a táblához új mezőket. Ha közvetlenül az adatbázis kezelőben szeretnénk dolgozni, akkor jelentkezzünk be a szerverre terminálkapcsolattal, majd a már ismert

módon jelentkezzünk be a MySql-rendszerbe: mysql -u usernev -p. A tábla kiválasztása után használjuk az use 'adatbázisneve' parancsot, és már írhatjuk is a megfelelő sql parancsokat.

alter table users add loginnev varchar(50), passwd varchar(50)

A korábban felvitt rekordok számára sajnos neveket, és jelszavakat kell bevinnünk a megfelelő mezőkbe, az újak számára pedig biztosítani kell ehhez a művelethez az infrastruktúrát az alábbi program alapján.

<form action="beszuras.php" method="post" enctype="multipart/form-data"> <input type="text" name="nev"><br> <input type="text" name="loginnev"><br> <input type="password" name="passwd"><br> <input type="file" name="kep"><br> <textarea rows="10" cols="50" name="cim"></textarea> <input type="submit" value="Felvitel"></form>

Formázott listák készítése

Listák és táblázatok készítésekor ügyelnünk kell arra, hogy a megjelenítés ne csak látványos, de használható is legyen. Első lépésként készítsünk a könyvek adatait tartalmazó listához egy újabb form-ot néhány submit gombbal, vagy tetszés szerint néhány linket. Az új programrész feladata az lesz, hogy a gombok megnyomása után cím, vagy felviteli idő szerint rendezze a rekordokat.

Ezt a műveletet néhány apró módosítással megoldhatjuk. El kell érnünk, hogy a form frissítse a listát, vagyis meghívja az index.php fájlt azzal a d értékkel, amely a listát tölti be. Ez a szám a lista menüpontjának a „d” értéke. A betöltés közben módosítanunk kell az SQL-parancs végét, pontosabban az order by záradék utáni mező nevét. Mindig azt a mezőt kell választani, ami szerint a felhasználó rendezni kívánja a listát. Ezzel azt a hatást érjük el, hogy az oldal frissül és a lista rendezettsége megváltozik aszerint, hogy melyik gombra kattintott a felhasználó.

A frissítést linkek segítségével is megoldhatjuk. Nem kell feltétlenül form-ot választanunk a rendezéshez. Készíthetünk linkeket is, ami egyszerűbbé teszi a program szerkezetét. A linkekhez csatolt d változó mellé elhelyezhetünk egy másikat, ami a rendezettség állapotát adja meg. A mező nevét ne adjuk át a linkben, mert ezzel a tábla szerkezetére lehet következtetni, és ezzel a megoldással sebezhetővé válik a programunk. A lista kiírásánál az így átadott változó értékét kell figyelnünk, és ennek függvényében megváltoztatni a select parancsot.

<?

$c = mysql_connect('localhost','username','passwd');

mysql_select_db("users"); $querystring = "select * from konyvek"; if (!isset($_GET['order'])) { $_GET['order']=0; }

if ($_GET['order'] == 1) { $querystring .= " order by id"; } else { $querystring .= " order by name"; } $result = mysql_query($querystring);

echo "<table width=100% border=1>"; echo "<tr><td><a href=index.php?d=1&order=1> név szerinti rendezettség</a> <a href=index.php?d=1&order=0> felvitel szerinti rendezettség</a> </td></tr>"; $i = 1; echo "<tr>";

while (list($id,$nev,$kep,$cv)=mysql_fetch_rows($result)) { echo "<table><tr><td>$id</td><td>$nev</td></tr> <tr><td colspan=2>$kep</td></tr></table>";

}

echo "</tr></table>";

mysql_close($c);

?>

A kiírást végző ciklusban elhelyeztünk egy feltételes elágazást, amely azt vizsgálja, hogy a kiírás előtt elhelyezett $i változó az aktuális lefutás során páros, vagy páratlan értéket tartalmaz. Páros érték esetén a táblázatos kiírást új sorba helyezzük, míg páratlan értéknél egymás mellé rakjuk a képeket tartalmazó táblákat. Ezzel egy olyan kiírási formához jutunk, ami egymás mellé, kettesével helyezi el a felhasználók képeit és adatait. Ha a feltételes elágazásban a 2 konstans 3-ra változtatjuk, egymás mellett 3 elemet fogunk látni. Hosszú listák esetén biztosíthatunk lehetőséget a felhasználóknak arra is, hogy keressenek az adatbázisunkban. Ezt a feladatot már érdemes űrlappal megvalósítani. Az űrlapon el kell helyeznünk egy beviteli mezőt, ahová a keresendő szöveget lehet begépelni, és kell egy nyomógomb, amely elindítja a keresést. Az űrlap a keres.php fájlt fogja elindítani, amely megkeresi az adatbázisban a begépelt szöveget tartalmazó rekordokat, és kiírja őket az oldalra.

<form action="keres.php" method="post"> <input type="text" name="keresett"> <input type="submit" value="keresés"></form>

Hogy ne kelljen a tábla összes mezőjéhez beviteli mezőt készítenünk, alkalmazzunk egy egyszerű trükköt. A megoldás lényege az, hogy a begépelt szöveget minden olyan mezőben keressük, ahol az előfordulhat. Ez azt jelenti, hogy a lekérdezést or operátorok segítségével építjük fel és minden mezőre megvizsgáljuk az egyezést, vagy a hasonlóságot. Az SQL-parancsban tehát el kell helyeznünk azt a where záradékot, ahol a mezők tartalmát a like kulcsszó segítségével megvizsgálhatjuk.

select * from users where nev like ".$_POST['keresett']." or

picture like ".$_POST['keresett']." or ... order by name

Ha a keresés eredményét is a weboldalba integrálva szeretnénk látni, a megfelelő d értékkel frissíteni az index.php fájlt és a menükezelő switch-ben a keres.php fájlt betölteni az include függvény használatával.

<? $c = mysql_connect('localhost','username','passwd'); mysql_select_db("webdb");

$querystring = "select * from users where cim like ".$_POST['keresett']." or kep like ".$_POST['keresett']." or leiras like ".$_POST['keresett']." or lognev like ".$_POST['keresett']." order by name";

$result = mysql_query($querystring); echo "<table width=100% border=1>"; while (list($id,$nev,$kep,$cim)=mysql_fetch_rows($result)) { echo "<tr><td>$id</td><td>$nev</td></tr> <tr><td colspan=2>$kep</td></tr>"; } echo "</table>"; mysql_close($c);

?>

A létező kiírást ki kell egészíteni az eredménytelen keresés feldolgozásával. Meg kell vizsgálni azt, hogy a lekérdezés szolgáltatott 0-tól különböző eredményt, vagy nem. Ha igen, akkor ki kell írni a találatokat, máskülönben jelezni kell a hibát a felhasználónak. Ha nem akarunk interaktív kereső programot készíteni, ezt a rész ki lehet hagyni, mert az üres képernyőt látva a felhasználó úgyis rájön, hogy az általa keresett szöveg nem található meg az adatbázisban. Előállíthatunk, és tárolhatunk különböző indexeket, amelyek gyorsítják, vagy esetleg befolyásolják a keresés eredményét. Bizonyos adatokat előnyben részesíthetünk, másokat meg elhelyezhetünk a listák végén, ahogy ezt néhány közismert keresőmotor is teszi. Mindegy, hogyan járunk el, a működését tekintve a keresés ugyanazon az elven fog működni, mint a bemutatott kereső program.

Captcha készítés

Ebben a leckében részben eltávolodunk a PHP-tól, és egy olyan eszközről ejtünk néhány szót, amely bármilyen (webes) programozási nyelven létrehozható. Mivel a webalkalmazások fejlesztésénél nagyon fontos szempont a biztonság is, lehetőség szerint be kell csuknunk minden olyan kiskaput, amelyen keresztül az oldalunkat támadás érheti. Ha az oldalunk űrlapot is tartalmaz, akkor nagyon fontos az ebben a leckében bemutatott eszköz ismerete, mivel az űrlapokat programok (robotok) is ki tudják tölteni. Ha egy űrlapot megtalál egy robot, és elkezd róla üzeneteket küldeni, azzal elronthatja az adatbázisunkat, vagy még rosszabb esetben akár kódokat is futtathat az űrlapjaink segítségével. A captcha egy olyan módszer, amelynek segítségével korlátozható, hogy az oldalainkra, vagy regisztrációs űrlapokra robot programok írjanak. A módszer lényege, hogy az üzenet vagy az űrlapok adatai mellett a felhasználónak egy ábrát is fel kell ismernie. Ez egy szó vagy értelmetlen karaktersorozat, melyben a karaktereket eltorzítják és hátteret is rajzolnak felismerendő szöveg mögé. Az így kapott ábrát az emberi felismeri, de a robot nem.

Az interneten számos ingyenes forráskódú, vagy ingyenesen belinkelhető captcha elérhető. Használjuk ezeket minden olyan esetben, amikor a weboldalunkat megtekintő felhasználótól bármilyen űrlapon keresztül adatokra várunk! Ha egyéni ötletünk van, akkor annak megvalósítása sem feltétlenül jelent nagyon bonyolult feladatot. A legáltalánosabb captchák betűkből és számjegyekből állnak. Az egyszerűbbek csak a betűméretet, -színt, -típust vagy ezek kombinációját vátoztatják meg az egyes karaktereken, többnyire úgy, hogy a betűk a rajzon rendezetlenül helyezkednek el. Ez megnehezíti a karakterek különválogatását, és így a felismerést is. Ha a képre hátteret is helyeznek, amely szakaszokat, íveket, vonalakat tartalmaz, a gépi felismerés bonyolulttá válik. Hasonló eredményt ad különféle textúrák alkalmazása is.

A captchák sem nyújtanak 100%-os biztonságot a robotokkal szemben. A captcha megjelenése után viszonylag rövid időn belül kialakult az új illegális iparág: a captchafejtés. A gép számára felismerhetetlen captcha gépi megfejtésével nem is kísérleteznek, ehelyett azokat embereknek adják oda megfejtésre. Egy-egy captcha filléreket jelent a megfejtő számára, vagy esetleg nem is pénzt kap, hanem hozzáférést illegális weboldalakhoz.

Egy egyszerű PHP-forráskódok captcha előállításához:

• http://www.white-hat-web-design.co.uk/articles/php-captcha.php • http:// www.google.com/recaptcha • http://www.phpclasses.org/package/4544-PHP-CAPTCHA-validation-using-

ASCII-art-text.html

Felhasználók nyomkövetése

Ahogy korábban említettük, bonyolult beléptető rendszerek esetén alkalmazhatjuk a SESSION kezelést, ahol az oldalhoz tartozó munkamenet változókban tároljuk el a felhasználók nyomkövetéséhez elengedhetetlen, de minimális mennyiségű információt. Minél kevesebb adatot tárolunk, annál biztonságosabb lesz a rendszer. Soha ne helyezzük el a felhasználó nevét, vagy jelszavát a munkamenetbe, és csak olyan alapvető információkat tartsunk benne, melyek a program számára minimálisan elegendőek.

A jelszavakat - mivel most nem adminisztrátori jogköröket kezelünk - elhelyezhetjük a felhasználók táblájában, ahol a neveiket és a személyes adataikat tároljuk, de tehetjük őket külön táblába is. Ekkor a két táblát egy külső kulcs segítségével összeköthetjük, biztonságosabbá téve ezzel az adatok kezelését. A jelszavak külön táblában való tárolása jobb megoldás lehet, mivel így az olyan moduloknál, ahol a személyek képeit és egyéb adatait jelenítjük csak meg, nem kell a biztonságra annyira odafigyelni, mint a jelszavak kezelésénél. A beléptető űrlap, és a SESSION segítségével már azt is tudjuk kezelni, hogy ki milyen adatokat tud módosítani és törölni. Minden felhasználó a sajátját, az adminisztrátor felhasználók pedig az összes rekordot.

<? require_once "dbmodule.php" $c = connect(); selectdb("webdb"); $querystring = "insert into users (name,picture,cv, loginname, password) values ('".$_POST['nev']."', '".$_FILES['kep']."', ... '".$_POST['loginnev']."', '".md5($_POST['passwd'],"kulcs")."',)";

query1($querystring); close($c); echo "<meta http-equiv... >

?>

A beviteli mezőket ha mástól nem is, legalább attól meg kell védeni, hogy a felhasználók, és az Interneten egyre inkább elterjedni látszó robot programok ne tudják ezeken keresztül feltörni a programjainkat.

Ehhez a feladathoz helyezzük el a capcha egy magunk készítette változatát. Az programban előállított szöveget kell majd a felhasználónak leolvasni a képről, majd

begépelnie egy erre a célra kialakított beviteli mezőbe. A capcha használata abban is megakadályoz bennünket, hogy az enter billentyűn felejtett kézzel számtalan üres űrlap mezőből származó adatot vigyünk be az adatbázisba, és a robotokat is megállítja, így azok nem tudják telerakni reklámokkal az adatbázisunkat.

A chapcha elkészítése mellett, a biztonság további növelése érdekében kérhetünk a felhasználóktól egy email-címet, amire elküldjük a jelszavukat, vagy akár megerősítést is kérhetünk tőlük a regisztrációra. Erre azért lehet szükség, mert gyakran előfordul, hogy mások nevében regisztrálnak felhasználót jogosulatlan haszonszerzési, vagy egyéb nem túl erkölcsös szándékból. A levelek küldése PHP programokból a mail() függvény segítségével történik, melynek paraméterei alapesetben az email-cím, a levél tárgya és szövege. Természetesen a levél számos más adattal is kiegészíthető. Miután elküldtük a levelet a szövegben elhelyezett linkkel, a felhasználó rákattint a linkre, a programunk meg aktivizálja az ő rekordját.

Az felhasználó aktiválást megoldhatjuk egy adatbázisban tárolt mező segítségével, melybe beszúráskor egy alapértelmezett értéket, az egyszerűség kedvéért egy nullát helyezünk el. Aktiváláskor a linkre kattintva elindítunk egy programot, ami ezt a mezőt 1-re állítja, ami a felhasználó aktív státuszát jelenti. Azokat a rekordokat, amelyeket nem aktiválnak, egy kis idő elteltével automatikusan törölhetjük az adatbázisból. Az aktiválás és a regisztráció programjának elkészítését a kedves olvasóra bízzuk, mivel a program megírásával nagyon sokat tanulhat, és rengeteg tapasztalatot szerezhet magának.

Az általunk készített beléptető rendszer feladata tehát az lesz, hogy véletlenszerűen előállított szövegrészekből készítsen egy olyan képet, mely az emberi elme számára felismerhető, de a különböző szövegfelismerő és körbejáró algoritmusok számára nagyon nehezen, vagy csak nagyon hosszú idő alatt megfejthető. Első lépésként készítsük el azt az algoritmust, mai előállítja a szöveget, majd képet készít belőle, amit kissé ``össze is firkál'', vagyis véletlenszerűen vonalakat helyez el a felületén, hogy megnehezítse az elolvasását. A begépelt szöveget kell majd összehasonlítani a képre írttal. Ha a kettő egyezik, a program jóváhagyja a regisztrációt és továbbengedi a felhasználót.

<? session_start(); function code($chars) { $chars0 = '01233456789abcdefghijklmnoprstxyvwz'; $result = ''; for ($i < $chars) { $result.= substr($chars0, mt_rand(0, strlen($chars0)-1), 1); } return $result; }

a szöveg generálása után elő kell állítanunk azt a képet, amit a felhasználó a beviteli

űrlapon lát majd.

function Image($width='100',$height='40',$chrs='6') { $code = code($chrs); $fontsize = $height * 0.75; $image = imagecreate($width, $height); #Kép előkészítése és inicializálása $background = imagecolorallocate($image, 255, 255, 255); #háttérszín beállítása $text = imagecolorallocate($image, 20, 40, 100); #Szöveg színénekbeállítása $noise = imagecolorallocate($image, 100, 120, 180); #A "titkosító" szín beállítása #Véletlenszerű vonalak elhelyezése a képen #az olvasás nehezítésére... for( $i=0; $i<($width*$height)/150; $i++ ) { imageline($image, mt_rand(0,$width), mt_rand(0,$height), mt_rand(0,$width), mt_rand(0, $height), $noise); }...

A függvény további része felírja a generált szöveget a kép felületére, majd megszünteti az erőforrások lefoglalását. Ez a folyamat úgy működik, hogy a kép előállítását végző függvényt meghívja a beviteli form, ami kirajzolja a képet a weboldalra. Ezután az image-et törölhetjük, hogy ne lehessen ellopni, és ne foglalja fölöslegesen a memóriát.

... $textbox = imagettfbbox($font_size, 0, 'monofont.ttf', $code); #szöveg mező előállítása $x = ($width - $textbox[4])/2; $y = ($height - $textbox[5])/2; imagettftext($image, $font_size, 0, $x, $y, $text_color, 'monofont.ttf' , $code) #szöveg kiírása a szövegmezőbe header('Content-Type: image/jpeg'); #iamge/jpeg header küldése a kép számára imagejpeg($image); #jpeg kép előállítása az image-ből imagedestroy($image); #image erőforrás felszabadítása

$_SESSION['security_code'] = $code; #SESSION változó beállítása az ellenőrzéshez } $captcha = image($_GET['wth'], $_GET['hgt'], $_GET['chars']); ...

A begépelt szöveget és a tároltat, vagyis amit a program előállít a kép felületén szintén védeni kell, mert a robot szoftver ezen a ponton is ellophatja. Ha egy globális változóban helyezzük el, vagy az URL-hez kötjük, akkor az egész képkészítés fölöslegessé válik. Mindegy, hogy a képet, és a hozzá tartozó beviteli mezőt a többi mező előtt, vagy után helyezzük el, a lényeg az, hogy ne lehessen kikerülni a regisztráció során.

<img src='chp2.php?wth=100&hgt=30&chars=5'> <input id=chpcode name=chpcode type=text></br>

Az <img src=...> kezdetű sorban elhelyeztük a titkos képet előállító PHP program nevét, melynek kimenete egy kép, amit az img HTML tag megjelenít. Itt definiáltuk a kép méreteit (szélesség, magasság, karakterszám). Ezeket az adatokat kapja meg a a képet előállító program. A szöveges beviteli mezőt elneveztük chpcode-ra. Ebből a mezőből, és a belőle létrejövő változóból derül ki, hogy a felhasználó helyes szöveget gépelt be, vagy kezdheti újra a kép megfejtését.

Miután a beviteli űrlap tartalmazza a belépéshez szükséges titkos képet, valamint a beviteli mezőt a megfejtéshez, már csak annyi dolgunk marad, hogy az adatbevitel előtt ellenőrizzük a begépelt szöveg helyességét. Ha nem megfelelő szöveget adtak meg, vissza kell térnünk az adatbeviteli form-hoz, és jelezni a felhasználó felé a hibát. Ha jó a szöveg, akkor el kell végezni az adatbevitelt.

Hogy mindez működjön is, elég egy feltételes elágazást készítenünk, ami vagy egy 0, vagy egy 1 közötti értéket helyez el egy változóba, amit visszaadunk a beviteli űrlapnak. Egy esetén a program átugorhatja beszúrást és hibajelzést adhat, nulla esetén beszúrja az adatokat a táblába és gratulál a sikeres adatbevitelhez.

<? require_once "dbmodule.php" session_start();

if( $_SESSION['security_code'] == $_POST['security_code'] && !empty($_SESSION['security_code'] ) ) { unset($_SESSION['security_code']); $c = connect();

selectdb("webbook"); $querystring = "insert into users (name,picture,cv, loginname, password) values ('".$_POST['nev']."', '".$_FILES['kep']."', '".$_POST['cim']."', '".$_POST['loginnev']."', '".md5($_POST['passwd'],'kulcs')."',)"; query1($querystring); close($c); } else { echo "<meta http-equiv... >; }

?>

Az átalakítás után a beviteli űrlapot is egészítsük ki a capcha előállítás mellett az ellenőrzés után adott hibaüzenet kiírásával.

<?

if (!isset($_GET['error'])){$_GET['error'] = 0;} if ($_GET['error']==1) { echo "Sikeres regisztráció. Köszönjük!"; } else { echo "Hibás titkos a szöveg. Próbálja újra!"; }

?>

<form action=beszuras.php method=post enctype=multipart/form-data> <input type=text name=nev><br> <input type=text name=loginnev><br> <input type=password name=passwd><br> <input type=file name=kep><br> <textarea rows=10 cols=50 name=cv></textarea> <input type=submit value="Hozzáadás"></form>

A regisztrált felhasználóink a lista törlését is elvégezhetik, ezért vegyünk fel a számukra egy menüpontot, ami a programban látható, módosított listát generálja. Az új menüpont létrehozása a beléptetős módszer alkalmazása mellet elengedhetetlen, mivel a regisztrált felhasználóktól nem várhatjuk el, hogy URL-eket gépeljenek a böngészőbe az egyes funkciók eléréséhez. A beléptetéshez használható űrlap kivitelezése nagyon egyszerű. Kell hozzá egy form, mely két beviteli mezőt, és egy nyomógombot tartalmaz.

<form action=belep.php method=post> <input type=text name=nev><br> <input type=password name=passwd> <input type=submit value=Belépés></form>

A beléptető form egy belep.php nevű fájlra hivatkozik. Ebben a fájlban kell megoldani a SESSION elindítását, és a jelszó ellenőrzését. Ha adminisztrátori jogkörrel rendelkező felhasználóról van szó, akkor minden adathoz hozzáférhet és törölheti azokat, ha egyszerű felhasználó, akkor azokat a rekordokat törölheti. amelyeket Ő vitt fel az adatbázisba. Természetesen az adminisztrátori jogköröket nem a regisztráció során adjuk hozzá a táblához, hanem készítünk hozzá egy erre a célra alkalmas modult, vagy SQL parancsok segítségével szúrjuk be a táblába a megfelelő mezők értékeit.

<? require_once "dbmodule.php"; $c = connect(); selectdb("webbook"); if ($_SESSION['prioritas'] == 1024) { $querystring = "select * from users where id=".$_SESSION['uid']." order by id"; } else { $querystring = "select * from users order by id"; } $result = query1($querystring); echo "<table width=100% border=1>"; while (list($id,$nev,$kep,$cim) = mysql_fetch_rows($result)) { echo "<form action=torles.php method=post> <input type=hidden name=id value=$id>"; echo "<tr>><td><input type=submit value=X></td> <td>$id</td><td>$nev</td></tr> <tr><td colspan=3>$kep</td></tr>"; echo "</form>"; } echo "</table>"; close($c);

?>

Ezzel az átalakítással elkészült a regisztrációs form. Most már nyugodtan koncentrálhatunk a weboldal többi részérére. Elkészíthetjük a különböző szűréseket, és a keresést a felhasználók munkájának a megkönnyítésére, vagy formázhatjuk az oldalainkat a HTML kódban CSS felhasználásával.

CSS alapok

A HTML formátum leíró nyelv segítségével weblapokat hozhatunk létre, melyeket a böngészőprogramok értelmezni tudnak. A HTML-ben megadhatjuk a tartalom elemeit, annak struktúráját és a formátumát.

<BODY> <H1>Személy neve</H1> <H2>Adatai</H2>

<IMG src="arckep1.jpg" /> <BR /> <P> Személy címe, és egyéb adatai...</P></BODY>

A HTML kód tartalmazza a szöveges részeket, melyek ahogy láthattuk, származhatnak adatbázisok rekordjaiból, illetve a képek hivatkozásait, amelyek segítségével a böngésző „össze tudja rakni” a megjelenítendő tartalmat. A teljes tartalom felépítése az előzőek alapján tehát az alábbi sémának felel meg:

főcím alcím 1. kép 1. szöveg (bekezdés) 1. alcím 2. kép 2. szöveg (bekezdés) 2. ...

A formátum nem a HTML kódban van elhelyezve. Minden elem jelenik meg, ahogyan az adott böngésző az alapértelmezett beállítások alapján megjeleníti. Azonos lesz a <H2>-vel jelölt alcímek, a <P>-vel jelölt szövegrészek formátuma.

A Word Wide Web platformfüggetlen protokoll, a fenti rövid HTML-fájl minden mai számítógépen megtekinthető, függetlenül a gépen futtatott operációs rendszertől és böngészőprogramtól. A minimális elvárás ezzel kapcsolatban az, hogy a weboldalak lehetőség szerint ugyanúgy nézzenek ki minden böngészőben.

Sajnos ez nem garantálható még a legegyszerűbb formátumú fájlok esetén sem., de a HTML lehetőséget ad a formátum meghatározására.

<BODY> <H1><FONT FACE="Arial" SIZE="7"> <B>Home Location Register</B></FONT></H1>

<H2><FONT FACE="Arial" SIZE="4"> <B>

<I>Személy 1</I></B></FONT></H2> <IMG src="kep1.jpg" BORDER="1" ALIGN="left" />

<P ALIGN="justify"> <FONT FACE="Arial" SIZE="3" COLOR="gray"> 3300, Eger, ... </FONT> </P> ...</BODY>

A stílust a HTML oldalak <head></head> tegek által határolt részében is leírhatjuk, így azok a teljes dokumentum területére érvényesek lesznek, de más dokumentumokban nem. Amennyiben egy stílust - ekkor már stíluslapot - bármely dokumentumban használni kívánunk, azt fájlba kell helyezni, és az adott felhasználási helyen elérhetővé kell tenni.

<HEAD> <META HTTP-EQUIV="content-type" CONTENT="text/html; charset=utf-8"><STYLE TYPE="text/css"> BODY { margin: 10px 2em 0 25pt; padding: 0; background-color: #FFFFCC; }

A:LINK { text-decoration: none; color: navy; }</STYLE></HEAD>

Stílusok közvetlenül HTML-elemekhez is rendelhetők.

<H1 STYLE="color:blue;">Megjelenítendő adat</H1><P STYLE="font-family: verdana; font-size: 10pt;">Paragrafus szövege</P>...

A HTML-ben a nem címsor bekezdéseket rendszerint <P>…</P> tegek közé írjuk. Ha a CSS-ben a <P> elemhez rendelünk beállításokat, akkor az összes bekezdésünk azonos formátumot kap.

Ahhoz, hogy az egyes bekezdéseket külön stílussal láthassunk el, osztályokat kell definiálnunk, majd az adott HTML elemet össze kell rendelnünk a hozzá tartozó stílus-osztállyal.

.szoveg, .megjegyzes { text-align: justify;

font-family: arial, helvetica, verdana; color: black;

padding-left: 2em; border-left: 3px solid black;

margin: 1em 2em 1em 2em; font-style: ;}

.szoveg { font-size: 12pt;}

A CSS fájlok osztályait a . vezeti be, majd a név, vagy nevek felsorolása következik, és ezután állhatnak {} között a különböző attribútumok. Az ilyen módon kialakított stílus osztályokat ezután tetszés szerint hozzá rendelhetjük a HTML elemekhez.

<P CLASS="normal">Szöveg</P><P CLASS="megjegyzes”> Megjegyzés</P>

Egy elemhez a kezd tegben leírt CLASS kulcsszóval rendelhetünk osztályt. Az egyes elemekhez a fenti attribútumok mellett külön hátteret is rendelhetünk.

BODY { background-color: black;}

.szurkehatter{ background-color: gray;}

.szoveg { background-color: white;}

<H1>Cím</H1><TABLE COLS=1 BORDER=0 CELLPADDING=0 CELLSPACING=0><TR> <TD CLASS="tablazat"> <P>szoveg 1</P><P CLASS="szoveg">szoveg 2</P></TD></TR>

A formázást különböző szintekre oszthatjuk. Az első az oldalra, a következő szint pedig a bekezdésekre vonatkozó beállításokat tartalmazza. Ebbe a kategóriába tartoznak a sorközök, betűközök. A legbelső szint a szövegelem, külső és belső margóit, szegélyét, körvonalát és egyéb attribútumait határozza meg, de ide tartoznak a háttérre vonatkozó beállítások is.

Tulajdonság Felvehető értékek Hatás

color szín neve | hexa-érték | rgb(vörös, zöld, kék)

Beállítja a szöveg színét. (Tulajdonképpen kerülhetett volna a karaktertulajdonságok közé is.)

line-height normal | <méret> | %

Beállítja a sorközt.

letter-spacing normal | <méret> Beállítja a betűközt.

text-align left | right | center | justify

Beállítja a bekezdés sorainak igazítását rendre a következőkre: balra zárt, jobbra zárt, középre zárt, sorkizárt.

text-decoration

none | underline | overline | line-through | blink

„Dekorációt" rendel az adott szövegre, amelyek rendre a következők lehetnek: nincs, aláhúzás, vonal a szöveg fölé, áthúzott, villogás.

text-indent méret | % A bekezdés első sorának behúzása.

text-transform none | capitalize | uppercase | lowercase

Az adott elem szövegét változtatja meg rendre a következőkre: nincs változtatás, nagy kezdőbetűk, nagybetűs, kisbetűs.

word-spacing normal | <méret> Beállítja a szavak közötti távolságot (a szóközt). Balra zárt, jobbra zárt és középre zárt igazításnál pontos értéket kapunk, a sorkizárás azonban elronthatja.

Karakterre vonatkozó beállítások

Tulajdonság Felvehető értékek Hatás

font-family

betütípus | általános típus*

Beállítja az adott elem betűtípusát. Több értéket is beállíthatunk vesszővel elválasztva, ekkor az első, a kliensgépen megtalálható betűtípus lesz az elem betűtípusa. Pl.: font-family: arial, helvetica, sans-serif;

font-size

xx-small | x-small | small |

medium | large | x-large |

Betűméret. xx-small és xx-large között különböző fix méreteket jelöl. A smaller és a larger a szülőelem méretéhez képest eggyel kisebb, illetve eggyel nagyobb méretet jelöl.

xx-large | smaller | larger |

<méret> | %

font-style

normal | italic | oblique

Betűváltozat. Az italic a kurzív, az oblique a döntött változatot jelenti, bár a legtöbb betűtípusnál nincs a számítógépkre külön kurzív és döntött változat telepítve. Így hatásuk többnyire ugyanaz a dőlt (ferde) betű.

font-variant normal | small-caps Kiskapitális betűt állít be.

font-weight normal | bold | bolder | lighter | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900

Betűvastagság. A konkrét értékek csak azoknál a betűtípusoknál működnek, amelyeknél léteznek a különböző vastagságok.

A böngészőkről általában

A CSS tulajdonságait szabvány definiálja. A sajnos a különböző böngészők eltérő módon támogatják a szabványt. Az acid tesztek a World Wide Web Consortium (W3C) és Az Internet Engineering Task Force által kidolgozott web-szabványok követését mérik a különböző böngészőkben. Az Acid2 teszt vizsgálja kifejezetten a CSS szabvány követését. Mikor az Acid2 teszt elkészült, egyetlen böngésző sem ment át rajta. Az első szoftver, amely teljesítette a tesztet (vagyis 100%-ban követte a W3C és az IETF által definiált CSS-szabványt) a Safari 2.0.2, amely 2005. október 31-én jelent meg. Ezt a böngészőt követte később az Opera, a Konqueror és a Firefox is. A teszten a Microsoft Internet Explorer a többi böngészőhöz képest is nagyon gyenge eredményt produkált. Az inkompatibilitás nagyon megnehezíti a webfejlesztők munkáját, hiszen az elvárható cél az, hogy egy weblap minden böngészőben azonos módon jelenjen meg. Ez elvárás a designnal szemben, de talán még fontosabb a funkcionalitás tekintetében.

Mivel a felhasználók jelentős része ragaszkodik régi böngészőjéhez, az abban a programban fel nem tárt hibák sebezhetővé teszik a számítógépet a vírusokkal, trójai programokkal, illetve a hekkerek támadásaival szemben.

Border-color (border-top-color, border-right-color) tulajdonság Az Internet Explorer 6 és régebbi böngészők nem támogatják a transparent értéket az adott elem (valamely) szegélyének átlátszóvá tételéhez.

Unicode-bidi tulajdonság A tulajdonsággal a szövegírás irányát adhatjuk meg. Ennek elsősorban olyan többnyelvű webhelyek esetében van nélkülözhtetlen szerepe, amelyeken jobbról balra író nyelvek (pl. arab) szövegei is olvashatók. A tulajdonságot a régebbi böngészők nem támogatják. A támogató böngészők a következők: IE 8+, FireFox 1+, Safari 1.3+, Opera 9.2+, Chrome 2.0+.

Border-style (border-top-style, border-right-style) Az Internet Explorer 9-es verziójától támogatja a tulajdonság által felvehető (a szabványban szereplő) hidden értéket.

Text-shadow A tulajdonság a megadott szöveges elemen állít be különböző árnyékeffektusokat. A tulajdonságot nem támogatja az Internet Explorer, és a Firefox a 3.0 verzióig (a 3.5 verzió igen). A Safari és a Chrome 2.0 részlegesen támogatja, míg az Opera a 9.5 verziótól teljesen támogatja, a korábbi verziókban viszont egyáltalán nem.

Visibility tulajdonság Az elemek láthatóságát szabályozó tulajdonság.

JavaScriptek beépítése a kódba

A JavaScript nyelvet a Netscape cég fejlesztett ki, eredetileg LiveScript néven. Az első változatot a Netscape 2.0-ban implementálták. A nyelv objektumalapú. A nyelvben olyan objektumokon keresztül férünk hozzá a különböző erőforrásokhoz és eszközökhöz, amelyek rendelkeznek tulajdonságokkal. Mivel objektum alapúak, metódusokat, különböző eseményeket használhatunk rajtuk keresztül. Sajnos az öröklődés hiányzik a nyelv eszközrendszeréből, megnehezítve ezzel az osztályok, objektumok továbbfejlesztését.

A JavaScript programokat írhatjuk a HTML kódba, hozzárendelhetjük CSS elemekhez, de lehetőségünk van a szkripteket tartalmazó külső forrásállományok csatolására is. Az oldal letöltése során a böngésző program letölti a webszerverről a HTML-kódot, és ezzel együtt a JavaScript programokat is. Ezeket azután bármikor le tudja futtatni, amennyiben rendelkezik a JavaScript futtatásáról szóló engedéllyel, és beépülő futtató környezettel.

A böngésző programok a JavaScript futtatásában sem képviselnek egységes álláspontot. Vannak olyan funkciók, amelyek igen eltérően módon működnek a különböző böngészőkben. Vannak funkciók, melyek el sem érhetőek némely programban. Ahogy említettük, a JavaScript kódokat elhelyezhetjük a HTML fájlban, vagy csatolhatunk külső fájlokat a dokumentum <HEAD> részében. Bárhová is írjuk, a <SCRIPT TYPE="text/javascript"> tegekkel kell bevezetnünk, és a </SCRIPT> teggel lezárnunk.

<HTML> <HEAD> <SCRIPT TYPE="text/javascript"> alert("Hello Világ"); </SCRIPT> </HEAD>

<BODY> <SCRIPT TYPE="text/javascript"> alert("Helleo Világ"); </SCRIPT> </BODY> </HTML>

JavaScript kód azonnal lefut, amint az azt tartalmazó HTML-fájl letöltődik. Akkor, mikor egy JavaScript programját valamilyen esemény bekövetkeztekor akarjuk futtatni, JavaScript-függvényeket hozunk létre, melyek futását HTML elemek eseményeihez kötjük.

<HTML><HEAD> <SCRIPT TYPE="text/javascript"> function alert_()

{ alert("Hello Világ!"); }</SCRIPT></HEAD> <BODY ONLOAD="alert_()"></BODY></HTML>

Amint az oldal betöltődik, megjelenik egy üzenetablak mind a korábbi, mind az onload eseményt használó program esetén. A fenti két példa nem definiálta, hogy mikor hajtsa végre a szkriptet a böngésző, míg a harmadik igen. Esemény bekövetkeztéhez kötötte az üzenetablak megjelenítését. Ezzel azt értük el, hogy az üzenetablak csak akkor jelenik meg, amikor ez az esemény bekövetkezik. Ezzel a módszerrel bármilyen eseményhez köthető JavaScript lefutása.

Amennyiben a JavaScriptet külső fájlban tároljuk, a HTML állományhoz a következő módon csatolhatjuk:

<script type="text/javascript" src="CsatoltPRGM.js"></script>

A külső fájlokra hivatkozó csatolásokat az esetek többségében a <HEAD> szakaszban érdemes elhelyezni.

Események a szkriptekbenTulajdonság neve (eseménykezelő) Az esemény akkor következik be, ha...

onblur Egy elemről elvesszük a fókuszt. (Pl. űrlapon az egyik szövegbeviteli mezőről a másikra váltunk.)

onchange Megváltozik egy mező értéke (pl. szövegbeviteli mezőé)

onclick Rákattintunk egy elemre az egérrel. (Lenyomtuk a gombot, azután felengedtük.)

ondblclick Duplán kattintunk az elemen az egérrel.

onerror Egy dokumentum vagy egy kép letöltésekor hiba keletkezett.

onfocus Amikor egy elem fókuszt kap (pl. egy űrlapon egy szövegbeviteli mezőre kattintunk vagy váltunk TAB-bal).

onkeydown Lenyomtunk egy billentyűt a billentyűzeten.

onkeypress Lenyomtunk vagy nyomva tartunk egy billentyűt a billentyűzeten.

onkeyup Felengedtünk egy lenyomott gombot a billentyűzeten.

onmousedown Lenyomtuk az egér gombját.

onmousemove Mozgattuk az egeret.

onmouseout Az egérkurzort lemozgattuk egy elemről (eddig fölötte állt, most már nem áll fölötte).

onmouseover Az egérkurzort egy elem fölé húztuk.

onmouseup Elengedtük a lenyomott egérgombot.

onresize Egy ablakot vagy egy frame-et átméreteztünk.

onselect Egy szövegrészt kijelöltünk.

onunload A felhasználó elhagyta az oldalt (pl. linkre kattintott).

Szinte az egyik leggyakoribb JavaScript elem a document.write("szöveg");, tetszőleges kifejezést írhatunk a HTML lapra. A szöveg típusa bármilyen ojektum lehet, és weboldalak esetén általában valamilyen HTML kód kiírására használjuk. Ha a függvénynek több paramétert adunk meg, vesszővel elválasztva, akkor ezeket a felírás sorrendjében helyezi el az adott helyre. A document objektum nagyon fontos, ha nem a legfontosabb objektuma a JavaScriptnek, mivel minden HTML-fájl document objektummá válik, miután a böngésző betöltötte azt, és ha a betöltődés után szeretnénk a HTML tartalmán változtatni, akkor ezt is a document objektumon keresztül tehetjük meg.

Az alábbi példaprogram hatására a böngészőben látható kép megváltozik, ha fölé húzzuk az egeret. Ezzel a technikával képek, vagy egyéb HTML elemeket emelhetünk kis, vagy használhatunk akár fogyelemfelkeltésre. A HTML elemnek nevet adunk (kep), amely ezután a document objektum kep nevű objektumaként szerepel a programban. Így lehetőségünk nyílik arra, hogy JavaScripttel megváltoztassuk a forrását.

<HTML><BODY> <IMG NAME="kep" src="1.png" ONMOUSEOVER="document.kep.src='2.png'" ONMOUSEOUT="document.kep.src='1.png'"></BODY></HTML>

Változók a JavaScript programokban

A Javascript programokban a deklarációt a var kulcsszóval kell bevezetni. A deklaráció során a változók kezdőértéket kaphatnak, így konstansként tekinthetünk rájuk.

var a, b, c;

var szoveg = "ABC123";

Az azonosítók betűvel vagy aláhúzásjellel kezdődnek és betűket, számjegyeket, illetve aláhúzásjeleket tartalmazhatnak. A JavaScript a PHP nyelvhez hasonlóan igen gyengén típusos nyelv. A különböző típusok között megengedett az explicit és az implicit típus konverzió is.

A JavaScript egyik skalár adattípusa a szám, vagy a Number. A Number típus a számokon kívül felvehet három speciális értéket, mint az Infinity (végtelen), -Infinity (mínusz végtelen) és a NaN (not-a-number, nem szám). Egy másik fontos típus a String, amely nem meglepő módon karakterláncok tárolására alkalmazható. A nyelv tartalmaz logikai típust is Boolean néven. Ennek a típusnak az értéke true vagy false lehet. Van még két különleges adattípus. Az egyik a Null, amely típus, és érték is egyben, a másik az Undefined, amelynek egyetlen értéke lehet, az Undefined. Object. Az Object típus mellett a JavaScript számos beépített objektumtípust ismer. Ezek egy része a fenti primitív típusoknak megfelelő objektumtípusok. Ezeken kívül használhatók a Date(), a Math(), az Array(), a RegExp() és egyéb objektumok. Bár a JavaScriptnek nem részei, ezek közé az objektumok közé sorolhatók a DOM objektumai is, amelyek segítségével a HTML-fájl elemeit érhetjük el. A tömbök is objektumok a JavaScriptben, ezért a new kulcsszóval hozzuk őket létre: var napok = new Array(); Ekkor az elemek indexeivel adhatjuk meg az egyes elemeket:

napok[0] = "hétfő";napok[1] = "kedd";napok[2] = "szerda";

A deklaráció tömörebben is írható: var napok = new Array("hétfő, kedd, szerda");

Az Array objektumok számos metódusa segíti a programozó munkáját. Ezek segítségével sorba rendezhetjük a tömbelemeket.

Vezérlő szerkezetek JavaScript programokban Az egyes ismétlő szerkezetek szinte azonos szintaxissal írhatók le a JavaScript programokban, mint más C alapú nyelvekben egy kivételével, a foreach, mely mindenhol másképpen működik...

for (változó in objektum){ végrehajtandó utasítások}

<html><body> <script type="text/javascript"> var napok = new Array("hétfő, kedd, szerda"); var i; for (x in napok) { document.write(mycars[x] + "<br />"); } </script>

</body></html>

A böngésző tulajdonságainak lekérdezése

A JavaScript Navigator objektuma segítségével lehetőségünk van a használt böngésző pontos felismerésére. Ez azért is fontos, mert ahogy korábban már említettük, koránt sem mindegy, hogy milyen böngésző programot használ az ember. Sajnos néhány böngésző nem elég pontos választ ad erre a kérdésre, mivel a Navigator objektum nem része a szabványnak. A következő példa a JavaScript Navigator objektumának fontosabb tulajdonságait mutatja be.

<HTML><BODY>

<SCRIPT TYPE="text/javascript"> document.write("<B>A böngésző</B> " + navigator.appCodeName); document.write("<B>Neve:</B> " + navigator.appName); document.write("<B>Verziószám:</B> " + navigator.appVersion); document.write("<B>Ver2:</B> " + navigator.appMinorVersion); document.write("<B>Cookie:</B> " + navigator.cookieEnabled); document.write("<B>Kapcsolat típusa</B> " + navigator.onLine); document.write("<B>Platform:</B> " + navigator.platform); document.write("<B>Default nyelv:</B> " + navigator.systemLanguage); document.write("<B>Beállított nyelv:</B> " + navigator.userLanguage); document.write("<B>Header:</B> " + navigator.userAgent);</SCRIPT>

</BODY></HTML>

A JavaScript és a CSS

Gyakori eset a weboldalak használata közben, hogy egy elem stílusát módosítjuk az oldalon egy tetszőleges esemény bekövetkeztének hatására.

object.style.Neve = "newstyleNeve";

Az object az adott elemre hivatkozó objektum. A Neve pedig a kívánt CSS-tulajdonság elnevezése, pl.:

div.style.background = "#ffc0d9";

Ha a CSS-tulajdonság többszavas, mert egy tulajdonságcsoport valamely konkrét elemére vonatkozik, akkor a Neve a többszavas tulajdonságnév karaktereit tartalmazza kötőjel(ek) nélkül, kisbetűvel írva pl.:

szoveg.style.fontFamily = "Verdana";div.style.borderLeftStyle = "dotted";

A getElementByID() metódus az egyes HTML-elemek CSS-tulajdonságait JavaScripten keresztül módosítja. Az elemekhez JavaScript-objektumokat kell rendelnünk úgy, hogy a JavaScript document objektumának a getElementByID metódusát használjuk.

<P ID="megjegyzes"> Megjegyzés szövege</P><SCRIPT TYPE="text/javascript"> var pM = document.getElementByID("megjegyzes"); pM.style.fontStyle = "italic";</SCRIPT>

A getElementByID() metódus a megadott ID vel ellátott elemek közül az elsőt adja vissza, míg a getElementsByName() metódus a megadott nevű objektumok mindegyikét tartalmazó kollekciót. A getElementsByName() metódus működéséhez hasonló a getElementsByTagname(), amely egy megadott tagnév összes előfordulását adja vissza.

<P NAME="megjegyzes">megjegyzés 1.</P><P NAME="megjegyzes">megjegyzés 2.</P><P NAME="megjegyzes">megjegyzés 3.</P><P NAME="szoveg">Szöveg...</P>

<SCRIPT TYPE="text/javascript"> var x = document.getElementsByTagName("p"); var i; for (i=0; i<x.length; ++i) { x[i].style.fontStyle = "italic";

}</SCRIPT>

Az alert() parancs, ahogy azt a korábbi példákban már láthattuk, figyelmeztető ablakot jelenít meg. Sokszor a programozók arra használják az alert függvényt, hogy a hibakeresés során a változók tartalmát megjelenítsék.

<HTML><HEAD> <SCRIPT TYPE="text/javascript"> function uzenet() { alert("Hahó!!!"); } </SCRIPT></HEAD><BODY>

<INPUT TYPE="button" ONCLICK="figyelmeztet()" VALUE="Üzenet" /></BODY></HTML>

A megerősítést kérő (confirm) ablak két gombot, egy OK és egy Mégse (Cancel) gombot jelenít meg. A felhasználó válaszát (vagyis hogy melyik gombot nyomta meg) a confirm() visszatérési értéke adja meg, amely true vagy false lehet.

<HTML><HEAD> <SCRIPT TYPE="text/javascript"> function jovahagyas() { var valasz = confirm("Ez egy figyelmeztető ablak."); if (valasz) { alert("Az Ok gombot választotta."); } else { alert("A Mégse gombot választotta."); }}</SCRIPT></HEAD> <BODY> <INPUT TYPE="button" ONCLICK="jovahagyas()" VALUE="Üzenet" /> </BODY></HTML>

A prompt() ablak hasonló a más nyelvekben használatos input-boxhoz. Adatbevitelre használhatjuk. A visszatérési értéke ez a szövegmezőbe írott karakterlánc lesz. A visszatérési érték "", ha a felhasználó üresen hagyta a szövegmezőt, de az Ok gombot nyomta meg, és null lesz, ha nem az Ok gombbal zárta be az ablakot.

<HTML><HEAD> <SCRIPT TYPE="text/javascript"> function nev () {

var nev=prompt("Név:","(név)"); if (nev != null && nev != "") { alert("Hello, " + nev + "!"); } } </SCRIPT></HEAD><BODY> <INPUT TYPE="button" ONCLICK="nev()" VALUE="Név" /></BODY></HTML>

Új böngészőablakot a window objektum open() metódusával nyithatunk, amelynek szintaxisa a következő:

window.open(URL, név, beállítások, csere)

• _blank (alapértelmezett): a megadott oldal új ablakban nyílik meg,• _parent: a megadott URL az adott frame szülőablakában jelenik meg,• _self: a megadott URL az aktuális böngészőablak tartalmát írja felül,• _top: a megadott URL az összes frameset fölé töltődik be.

A String objektum segítségével karakterláncokon végezhetünk műveleteket. Karakterlánc típusú változókat így hozhatunk létre:

var szoveg = new String("szöveg");var szoveg = "szöveg";

Egy karakterlánc hosszát a String objektum length tulajdonságával kérdezhetjük le.

var szoveg = "Alma a fa alatt.";document.write(szoveg.length);

Szövegkezelők

• charAt(n) – megadja egy szöveg n. karakterét. Az indexelés 0-tól kezdődik.charCodeAt(n) – megadja a szöveg n. karakterének Unicode-kódját.

• concat(s1, s2, ...) – Összefűz két vagy több sztringet és az így keletkező sztringet adja vissza.

• fromCharCode(n1, n2, ...) – A megadott Unicode karakterkódokból állítja elő a szöveget. n1, n2 stb. érvényes Unicode kódok (0–65535).

• indexOf(szöveg, kezdőPoz) – megadja egy karakterlánc-objektumban a szöveg a kezdőPoz utáni első előfordulásának helyét.

• lastIndexOf(szöveg, kezdőpoz) – megadja egy karakterlánc-objektumban a szöveg a kezdőPoz előtti utolsó előfordulásának helyét. Ha nem adunk meg kezdőPoz-t, akkor az objektum karaktereinek száma (a szöveg hossza) helyettesítődik be.

• match(regEx) – a megadott reguláris kifejezésre illeszkedő karaktersorozatokat keres az objektumban és megadja azokat.

• replace(regEx, újSztring) – az objektumban megkeresi a regEx-re illeszkedő karakterláncokat és kicseréli azokat az újSztring-re.

• search(regEx) – megkeres egy a megadott reguláris kifejezésre illeszkedő karakterláncot a szövegben és visszaadja annak pozícióját. Ha nincs ilyen, akkor -1-et ad vissza.

• substr(kezdőPoz, hossz) – Visszaadja az eredeti szövegnek a kezdőPoz pozíción kezdődő, hossz hosszúságú darabját.

• substring(kezet, vég) – Visszaadja az eredeti szövegnek a kezdet és vég közötti részét.

• toLowerCase() – Nincs paramétere, az objektum szövegének kisbetűs alakját adja vissza.

• toUpperCase() – Nincs paramétere, az objektum szövegének nagybetűs alakját adja vissza.

A Date objektum segítségével dátumot és időt tudunk kezelni. Dátum típusú objektumokat a következő módokon hozhatunk létre:

var d1 = new Date();

var d2 = new Date(ezredmásodpercek);

A Date objektumnak számos metódusa van, lássunk ezek közül néhányat!

• getDate() – megadja a dátumból a nap sorszámát (0–31).

• getDay() – megadja, hogy az adott dátum a hét melyik napjára esik (0–6, 0 = vasárnap, 1 = hétfő, stb.).

• getFullYear() – megadja a dátumból az évszámot, négyjegyű számként.

• getHours() – megadja a dátumban található időpont értékéből az órát (0–23).

• getMilliseconds() – megadja a dátumban található időpont értékéből az erzedmásodpercek értékét (0–999).

• getMinutes() – megadja a dátumban található időpont értékéből a perc értékét (0–59).

• getMonth() – megadja a dátumból a hónap sorszámát (0–11).

• getSeconds() – megadja a dátumban található időpont értékéből a másodperc értékét (0–59).

• getTime() – megadja az adott dátum és 1970. január 1. 00:00 között eltelt időt ezredmásodpercben. Ugyanezeket az értékeket be is állíthatjuk, ha a fenti metódusok nevében a get szót set-re cseréljük és megadjuk a kívánt értéket. Pl. datum.setHours(11);

• parse(sztring) – megadja a dátumsztring által megadott dátum és 1970. január 1. 00:00 között eltelt időt ezredásodpercben.toString() – a dátum- és időértéket sztringgé konvertálja.toTimeString() – a dátumobjektumban tárolt időértéket konvertálja sztringgé.

Az Array kulcsszó segítségével tömböket kezelhetünk. Amikor a megadott tömbelemek számok vagy logikai értékek, akkor numerikus vagy logikai tömb jön létre, minden egyéb esetben string típusú. A tömb objektum elemszámát a length tulajdonsággal kérdezhetünk le:

var tomb = new Array("hétfő", "kedd", "szerda"); var i; for (i = 0; i < tomb.length; ++i)

{ document.write(tomb[i])); }

Az Array objektum metódusai

• concat(t1, t2, ...) – Összefűz két vagy több tömböt (a felsorolt tömbök elemeit egy tömbbe másolja a tömbök sorrendjének megfelelően), és az így keletkező új tömböt adja vissza.

• join(elválasztó) – A tömb összes elemét egy sztringbe másolja, az elemek közé az elválasztó jelet teszi, és visszaadja az így keletkezett tömböt.

• pop() – törli egy tömb utolsó elemét és visszaadja ezt az elemet.

• push(elem1, elem2, ...) – felveszi a tömb végére új elemként a megadott elemeket és visszaadja a tömb új elemszámát.

• reverse() – megfordítja a tömbben az elemek sorrendjét. Nincs visszatérési értéke.

• shift() – törli egy tömb első elemét és visszaadja ezt az elemet.

• sort() – Sorba rendezi egy tömb elemeit.

• toString() – Összemásolja egy tömb elemeit egy sztringbe és visszaadja ezt a sztringet. Az elemek között vessző szerepel a sztringben.

Lenyíló divek használata

A diveknek a felugró ablakokkal szemben az az előnye, hogy a megnyíló DIV animált lehet, megnyitáskor folyamatosan változhat a mérete, vagy az átlátszósága.

A következő példa bemutatja, hogyan használhatjuk együtt a DIV-eket a JavaScript függvényeket, valamint a HTML elemeket arra, hogy animált, előugró ablakokat jelenítsünk meg a felhasználók böngésző programjában.

<style type="text/css"> .lenyiloDiv2{width:800px; position:absolute; height:0px; width:50%; left:25%; color:#FFF; background:#666666; overflow:auto;}</style> <style type="text/css"> .lenyiloDivkep{width:800px; position:absolute; height:0px; width:50%; left:25%; color:#FFF; background:#666666; overflow:auto;} </style> <script src="jquery-1.4.1.js" type="text/javascript"></script> </script>

<script type="text/JavaScript"> $(document).ready(function () { $('.nyit2').click(function(){ if($('.lenyiloDiv2').height()==0) $ ('.lenyiloDiv2').animate({height: '100'},800); else $('.lenyiloDiv2').animate({height: '0'},800); }); }); </script> </head><body bgcolor=black>

<div class="nyit2"> <p align=center> </form><button href="#" class="nyit2">Bezárás</button> </p> </div>

<input type=submit value="Keresés"> </form><button href="#" class="nyit2">Bezárás</button>

Event objektum. Az Event objektum a dokumentumon bekövetkezett eseményekről ad tájékoztatást. Az alábbi példában azt állapítjuk meg, hogy melyik gombbal kattintott a felhasználó a dokumentumban elhelyezett dobozra. <HTML><HEAD><SCRIPT TYPE="text/javascript"> function melyikGomb(event) { if (event.button==2) { alert("A jobb gombbal kattintott!"); } else { alert("A bal gombbal kattintott!"); } }</SCRIPT></HEAD>

<BODY><DIV ONMOUSEDOWN="melyikGomb(event)" STYLE="border: red solid 1px; background-color: yellow; color: red; width: 100px; text-align: center;"><P> Klikk a dobozra valamelyik gombbal!</P></BODY></HTML>

Ahogy láthattuk, a CSS, a JavaScript, és az egyéb beépülő modulok mind fontos részei a weboldalak programjának. Talán ezektől annyira összetett és nehéz komoly webalkalmazásokat készíteni. A programozónak ismernie kell a HTML alapjait, az adatbázis kezelést, rendelkeznie kell hálózati ismeretekkel, valamint tudnia kell JavaScriptet írni, CSS osztályokat készíteni. Mindezek mellett szüksége van némi művészi vénára is az esztétikus külső megteremtéséhez, vagy ha ezzel nem rendelkezik, legalábbis fogékonynak kell lennie az esztétikum iránt.

Kód-újrahasznosítás

A kód-újrahasznosítás, hasonlóan más típusú programokhoz, a weboldalak programjánál is hasznos és hosszú távon kifizetődő technológia. Sokan nem értik, hogy miért kell bonyolult objektumokat készíteni, és definiálni a köztük lévő kapcsolatokat. Miért nem elég a funkciókat leírni függvények segítségével, majd ezeket a függvényeket meghívni a program megfelelő pontjain? Mindez nem is érthető addig, amíg nem ismerjük az objektumok és az osztályok működését, valamint a használatukból származó előnyöket. Az Objektum Orientált Programozás (OOP) három alapelven nyugszik.

1. Az első az egységbezárás (encapsulation) elve, amely elv azt írja le, hogy az adatok, és a hozzájuk tartozó eljárások, függvények egységet alkotnak, amely egység védett a külvilágtól. A védettség azt jelenti, hogy az objektum belső világába csak ellenőrzött módon kerülhet be bármilyen adat. Ha a másik irányból közelítjük a problémát, azt mondhatjuk, hogy az objektum mezői csak olyan értéket kaphatnak, amilyent a programozó megenged.

2. A második alapelv az öröklés (inheritance), amely az objektumok egymáshoz való viszonyát írja le. Az öröklés valójában azt jelenti, hogy egy meglévő, már mezőkkel és metódusokkal rendelkező osztályból létrehozhatunk egy másikat, ami az ősének minden tulajdonságát tartalmazza, vagyis örökli annak mezőit és metódusait.

Megjegyzés: Ez az elv talán az egyik leghasznosabb tulajdonságát írja le az OOP-nek. Egy jól megírt weboldal kódját fel tudjuk használni egy másik elkészítésénél egyszerűen az öröklés révén. Az leszármazott osztályban új mezőket és metódusokat definiálhatunk ezzel bővítve az eredeti funkcionalitást.

3. A harmadik alapelv a sokalakúság (polymorhism), ami azt jelenti, hogy a származtatás során az örökölt metódusokat meg tudjuk változtatni úgy, hogy a típusukat, nevüket és a paraméterlistájukat változatlanul hagyjuk, a törzsüket viszont tetszés szerint átalakítjuk. Ezáltal a leszármazott osztályt, amit egy létező osztály forráskódjából kaptunk, tetszés szerint át tudjuk alakítani, ezzel is rugalmasabbá téve a programozás folyamatát. Ettől a három alapelvtől válik tehát hasznossá az OOP, valamint lehetővé teszi számunkra a kód újrahasznosítását új programok írásakor.

Mielőtt belekezdünk az objektumorientált paradigma használatába és átírjuk a weboldalt erre a formára, tisztáznunk kell néhány fogalmat. Az OOP alapja az osztály, ami valójában egy típus. Egy olyan adatszerkezet, ami leírja az összetartozó mezőket, metódusokat, és egyéb információt, mint a mezők védelmét megvalósító tulajdonságok. Az megfelelő módon elkészített osztályt példányosítani kell. A példány az az objektum, amit az osztály konstruktorával hozunk létre a memóriában. A konstruktor egy speciális metódus, ami alaphelyzetbe állítja a mezőket, valamint a memóriában elhelyezi a példányt.

Az objektumot használat után meg kell semmisíteni, vagyis törölni kell a memóriából. Ezt a feladatot a destruktor nevű metódus látja el. Az osztály nem használható, amíg nem példányosítottuk a new kulcsszó segítségével. Az példányra való hivatkozás a PHP programokban a -> operátor használatával lehetséges. Hasonló ez a rekordok

kezeléséhez, ahol a rekord egy mezőjét a rekord és a mező nevéből képzett kifejezéssel érhetjük el. Ezt az osztály, vagy a rekord szelektoraként is felfoghatjuk. Az osztályt a class kulcsszó vezeti be, hasonlósan a C++ és a C# nyelvekhez. Fontos még a this kulcsszó, ami az osztály aktuális példányára mutat. Az osztályban megírt függvényeket, és eljárásokat metódusnak hívjuk, az osztály változóit mezőknek. Fontos, hogy ezeket a szavakat használjuk a mezőkre és a függvényekre, mert így mindenki számára érthető lesz, hogy OOP, vagy hagyományos, csak szekvenciát, szelekciót, és iterációt használó programozási környezetről beszélünk.

Ez a néhány mondat, ami az OO alapelvekről szól, nélkülözhetetlen tudásanyagot tartalmaz ahhoz, hogy OOP programokat tudjunk készíteni, de nem elegendőek ahhoz, hogy teljesen elsajátíthassuk az OOP használatát. Jelenleg viszont nagyon hasznos, mert a következő részben bemutatjuk egy objektum alapú webhely elkészítésének a lépéseit. Kevés munkával az eddig bemutatott modulok átültethetők az objektumalapú környezetbe.

<?

class webhely { var $databasename; var $ID0;

/* Konstruktor */ function site($ID0) { $name = $SiteName; } ...

?>

Láthatjuk, hogy a konstruktor neve megegyezik az osztály nevével. Az egyetlen patamétere a $ID0, amit elhelyez az osztály hasonló nevű mezőjébe, így biztosítva a menükezelés működését. A paraméterre azért van szükség, mert az osztály példánya az index fájl minden frissítésekor újra létrejön, a menükezelőnek viszont szüksége van arra az információra, hogy melyik menüpontot kell betöltenie.

<? /* Fejléc */ function header($felirat , $kep , $css_stilus) { /* Fejléc szövege és a hozzá tartozó kép */ }

/* Menü generálása */ function menu($felirat, $css_stilus, $MenuLista, $LinkLista, $szoveg) { /* A menüpontokat leíró rész */ }

/* Tartalom */ function content($ID, $Felirat, $css_stilus, $Feliratok, $FileList) { /* Az oldal tartalma */ }

function footer($szoveg) { /* A webhely lábléce */ }

/* További funkciókat, például adatbázis-kapcsolatokat leíró metódusok */}?>

A header nevű metódus a paraméterként kapott képet helyezi el arra a helyre, ahol meghívták. Elkészít egy táblázatot, majd a baloldali cellájába betölti a képet, ha az létezik, majd mellé írja a $felirat paraméterben megkapott szöveget.

<? ... function header($felirat, $kep , $css_stilus) { echo "<TABLE CLASS=$css_stilus WIDTH="100%"> <TR> <TD> <IMG src=$kep> </TD> <TD> $felirat </TD> </TR> </TABLE>"; } ...

?>

A menu nevű metódus a menüt állítja elő az aktuális paraméterek alapján. Készít egy táblázatot, amelynek az első sorába a $felirat változó tartalmát írja, majd egy ciklus segítségével előállítja a menüpontokat a nevek és a hozzájuk tartozó linkeket tartalmazó listákból. Ezeket szintén paraméterként adjuk meg.

A $szoveg változó tartalmazhat olyan szöveget, amelyet a menüpontok alá írunk ki. Ha nem akarunk ilyet, akkor a változót üres stringgel töltjük fel: "". A menüpontokat tetszés szerint, a weboldal jobb, vagy bal oldalán is elhelyezhetjük.

<?

... /* Menü generálása */ function menu( $felirat, $css_stilus, $MenuLista, $LinkLista, $szoveg) { echo "<TABLE CLASS=$css_stilus WIDTH=100%> <TR><TD>$felirat</TD></TR>"; $db = count($MenuLista) ;

for ($i=0 ; $i<$db ; $i++) { echo "<TR><TD><A href=" . $LinkLista[$i ].">" .$MenuLista[$i ]."</A> </TD></TR>" ; } echo "<TR><TD>$szoveg</TD></TR> </TABLE>" ; } ...

?>

A menükhöz kapcsolódik, de külön metódusban kapott helyet a tartalmat kezelő, és betöltő programrész, amely az oldal id-je, vagyis a menühöz rendelt változó értéke alapján betölti a megfelelő oldalt. A fájlok neveit egy listából kapja meg, amely lista a főprogramban kapja meg az értékeit. A menüket, a hozzájuk tartozó linkeket és a betöltendő fájlok listáját tekinthetjük az oldal konfigurációjának. A konfigurációt elhelyezhetjük egy fájlban, vagy tárolhatjuk adatbázisban, így az OO webprogram nemcsak újra hasznosíthatóvá, de testre szabhatóvá is válik.

<? ... function content($ID, $Felirat, $css_stilus, $Feliratok, $FileList) { echo "<TABLE CLASS=$css_stilus WIDTH="100%"> <TR><TD>" . $Feliratok[$ID]."</TD></TR>" ; echo "<TR><TD>" ;

include $FileList[$ID]; echo "</TD></TR></TABLE>" ; } ...?>

Miután elkészítettük az oldalt megvalósító osztályt, példányosítanunk kell, hogy fel tudjuk használni a mezőit és metódusait.

<? include "website.php";

if (!isset($_GET["d"])) { $_GET['d ']=0; }

$menu = array('menu1' , 'menu2');

$link=array('index.php?d=1' , 'index.php?d=2');

$ASite = new site($_GET['d ']) ; $ASite -> header('Fejléc szövege', 600, 'center', 'Fejléc szövege'); $ASite -> menu('Főmenü' , 'style1', $menu, $link, "Text" ); $ASite -> _webhely();

?>

Ez a módszer, ahol a PHP program generálja a HTML kimenetet, és a weboldal OOP alapú, hosszú távon megkönnyíti a munkánkat azzal, hogy a korábban elkészített, programrészeket minden új weboldal forráskódjához fel tudjuk használni. Az új könyvtárba másoljuk az osztályt tartalmazó fájlt, hozzáadjuk a fájlt a többi kódhoz, majd példányosítjuk az osztályt. A metódusok paramétereit megváltoztatva testre szabhatjuk a weboldal külsejét, valamint újabb metódusokat adhatunk az eredeti osztályunkhoz, ha újabb funkciókra van szükség. Amennyiben a weboldal külső megjelenését, valamint a funkcionalitását külön szeretnénk választani, a forráskódot sablonokkal is kiegészíthetjük. A sablon alapú webhelyek készítése jelenleg elterjedt technológia, mivel a használata mellett külön lehet választani a programozók és a grafikusok munkáját.

Amíg a programozó a weboldal forráskódjával, az adatbázis kapcsolatok programozásával, és egyéb bonyolult dolgokkal bajlódik, addig a designer elkészítheti az oldal HTML kódját, kiszínezheti azt, és a helyükre illesztheti az oldalhoz készített képeket és animációkat. Elég annyit tennie, hogy a forrásba definiálja azokat a pontokat, ahova a PHP kódot el kell helyezni, vagy betölteni. Miután mindkét munkafolyamat befejeződött, a program két részét össze lehet illeszteni. Ez sokszor csak annyit jelent, hogy a fájlokat a megfelelő helyre másoljuk, majd elindítjuk a programot. Mivel a két rész teljesen független egymástól, mindkettőt ki lehet cserélni. Ha elavult a külső, vagy épp a programkód funkcionalitása szorul frissítésre, elég a megfelelő kódrészletet újraírni és cserélni a fájlokat.

Ellenőrző kérdések

Az alábbi 99 kérdés segíti a kedves olvasót abban, hogy felmérje tudását, és amennyiben hiányosságokat talál, újabb nekifutásokkal és még több szorgalommal csiszolja tovább ismereteit. A kérdések nem csak a jegyzet lapjairól merítenek, hanem egy átlagos web-progamozó munkája során felmerülő problémából is. Abban az esetben, ha nem található meg a válasz a fejezetekben, az oktatási folyamatot segítő személy, vagy az ”Internet” biztosan tudja a választ.

1. Hogyan kell modulokat, fájlokat PHP programokba linkelni?

2. Milyen webszerver beállítások teszik szükségessé a $_GET, $_SET és a

$_FILES tömbök használatát?

3. Hogyan kezeljük a dinamikus weboldalak esetén a globális adatokat?

4. Milyen protokollok segítségével érhető el a webszerver könyvtára?

5. Milyen következményekkel jár a REGISTER_GLOBALS paraméter OFF

6. értékre állítása?

7. Mit azonosítanak az URL-ek különböző részei?

8. Lehet-e adatokat, fájlokat mozgatni a kliens és a szerver számítógép

9. között?

10.Hogyan érhetjük el az előre kidolgozott PHP függvényeket tartalmazó

11.modulokat?

12.Miért érdemes a weboldalak egyes funkcióit külön fájlokban elhelyezni?

13.Mivel jelezzük a webszerver számára, hogy a HTML kódban PHP

14.szkript következik?

15.Lehet-e indexek segítségével elérni az asszociatív tömbök elemeit?

16.Hova kerül a PHP program kimenete?

17.Milyen lépések hajtódnak végre a PHP alapú weboldalak böngészőben való

futtatása esetén?

18.Mit jelent az URL rövidítés?

19.Milyen ismert programozási nyelveken tudjuk megszólítani a MYSQL

adatbázis kezelő rendszert?

20.Hogyan kell a PHP forrásszövegeket a HTML kódba ágyazni?

21.Mi a weboldalak fő fájljának a neve (alapbeállítás esetén)?

22.Milyen kiterjesztéssel rendelkeznek a PHP programokat tároló fájlok?

23.Milyen sorrendben veszi a következő kiterjesztéseket a webszerver? .htm,

.html, .php

24.Fordít-e a PHP tárgykódot?

10.Alapértelmezés szerint hol tárolódik a weboldalak programja?

11.Hogyan kell változót deklarálni PHP programban?

12.Milyen típusú tömbök léteznek a PHP nyelvben?

13.Hogyan lehet tömböket hatékonyan feldolgozni a PHP programokban?

14.Hogyan tudunk PHP forrásszövegből HTML kódot generálni?

15.Hogyan kell függvényeket deniálni PHP programokban?

16.Hogyan lehet egy PHP függvényben elérni a globális változókat?

17.Milyen összetett adatszerkezetek deniálhatóak a PHP nyelvben?

18.Hogyan hivatkozunk a skalár változókra PHP-ban?

19.Hogyan működik a foreach utasítás PHP-ban?

20.Milyen vezérlőszerkezeteket tartalmaz a PHP nyelv?

21.Milyen ciklusutasítások használhatóak PHP-ban?

22.Mivel jelöljük a PHP programokban a változókat?

23.Milyen lehetőségeket kínál a PHP nyelv az adatok megjelenítésére, kiírására?

24.Mit jelent az asszociatív tömb fogalma?

25.Milyen típusokat deniálhatunk PHP-ban?

16.Hogyan hivatkozhatunk asszociatív tömbök elemeire?

17.Milyen lépésekből áll az adatbázis kapcsolat felépítése?

18.Hogyan ellenőrizhető le az adatbázis kapcsolat felépítésének sikere?

19.Hogyan készíthetünk SQL táblákat PHP programokban?

20.Hogyan kell feldolgozni a több rekorddal visszatérő SQL lekérdezés

eredményét?

21.Milyen előnyökkel jár az adatbázis függvények modulokba sorolása?

22.Hogyan hozhatunk létre SQL táblákat.

23.Hogyan adhatunk parancsokat a DBMS számára.

24.Milyen eszközöket biztosít a PHP nyelv az adatbázis kezeléshez?

25.Hogyan kell lezárni az adatbázis kapcsolatot:

26.Hogyan kerülhető el a többszörös include, vagy require függvények

használata esetén a többszörös fájl linkelés?

27.Hogyan kell karakterláncokat összefűzni PHP programokban?

28.Mi a hiba oka, ha a Forbidden kezdetű hibaüzenet jelenik meg böngészőben?

29.Mit tegyünk, ha a Forbidden kezdetű hibaüzenet látjuk?

30.Hogyan kell adatokat beolvasni PHP programokban?

31.Hogyan oldható meg az weboldalak közti paraméterátadás?

32.Hogyan keressünk hibát PHP programok esetén?

33.Milyen kliens oldali nyelveket használhatunk weboldalak progranjának a

kiegészítésére?

34.Hogyan tudjuk frissíteni az oldalakat a böngészőben?

35.Milyen tömbök segítségével érhetjük el a globális változókat?

36.Hogyan készülnek a dinamikus lekérdezések?

37.Milyen vezérlő szerkezet segítségével dolgozhatunk fel listákat?

38.Hogyan állítsuk meg az adatfeldolgozó ciklusokat?

39.Milyen parancsok segítségével érhető el a DBMS konzolja?

40.Milyen parancsokkal módosíthatjuk az SQL táblákat?

41.Hogyan kapcsolódunk MySql szerverhez?

42.Hogyan lehet a listálkat tördelni a kiírás során?

43.Hogyan térhetünk vissza más URL-hez?

44.Mire használjuk a META utasításokat a weboldalak programjában?

45.Miként olvassuk ki a lekérdezés eredményéből a mezőket?

46.Hogy tehetjük használhatóvá a hosszú listákat?

47.Jellemezze az UNIX rendszerek jogosultsági rendszerét!

48.Hogyan kell a fájlok jogosultságát beállítani a webszerveren történő

futtatáshoz?

49.Milyen jogosultsági rendszert használnak WINDOWS rendszerekben?

50.Hogyan védhetjük meg a weboldalak beviteli mezőit?

51.Mit jelent az SQL Injection és hogyan kell védekezni ellene?

52.Milyen támadási formák segítségével lehet feltörni weboldalakat?

53.Milyen protokollok segítségével másolhatunk fájlokat szerverekre?

54.Milyen protokoll segítségével adhatunk távoli parancsokat a szerver

számítógépnek?

55.Melyik PHP függvénnyel másolhatunk fájlokat a webszerverre?

56.Milyen jogosultsággal kell ellátni a szerver könyvtárát, ha fájlokat szeretnénk

oda másolni?

57.Mi az oka annak, hogy a weboldal adminisztrációját különválasztják a

felhasználói felülettől?

58.Milyen hibák adódhatnak a header indítások során?

59. Hogyan használhatunk előre deniált beléptető form-ot?

60.Milyen helyszókódolási eljárásokat ismerünk?

61.Miért kell a jelszavakat titkosítva tárolni?

62.Hogyan ellenőrizhető a titkosan tárolt jelszó helyessége a beléptetés során?

63.Miért ne linkeljük az adminisztrációs modult a főoldalra?

64.Milyen lépésekből állhat a regisztráció?

65.Milyen módon védhető meg a beviteli mező a robot programoktól?

66.Hogyan készíthetünk képeket PHP programokban?

67.Mik a chapcha készítés lépései?

68.hogyan generálunk képet szövegből PHP programokban?

69.Mi a munkamenet változók hatékonyságának az oka?

70.Hogyan indítsunk munkamenetet?

71.Melyik PHP függvény segítségével regisztrálhatjuk a munkamenetet?

72.Miért kell az adminisztrációs felületet védeni?

73.Hogyan készíthetünk saját beléptető rendszert?

74.Hogyan léptessünk be felhasználókat?

75.Miért kell tördelni a listákat?

76.Hogyan oldható meg a weboldalak listáinak lapozása?

77.Hogyan kereshetünk adatbázisokban?

78.Hogyan kereshetünk adatbázisokban weboldalak felületéről?

79.Milyen SQL nyelvi elem teszi lehetővé a keresést?

80.Mivel lehet gyorsítani a keresők működését?

81.Milyen keresőprogramokat ismer?

82.Hogyan lehet a lapozáshoz szükséges információt átadni az oldalak közöt?

83.Milyen HTML elemek segítségével készíthetünk lapozható listákat?

84.Mik a kód újrahasznosítás előnyei?

85.Milyen OOP alapelveket ismerünk?

86.Hogyan kell osztályt deniálni?

87.Hogyan nevezzük az osztályokban deniált változókat?

88.Hogyan hívjuk az osztályok függvényeit és eljárásait?

89.Mi a típus és a példány között a különbség?

90.Mi a konstruktor?

91.Mit jelent az adatrejtés elve?

92.Hogyan érhetjük el a példányok metódusait?

93.Hogyan kell osztályt példányosítani?

94. Hogyan ágyazhatunk JavaScript alapú kódokat a forrásszövegekbe.

95.Mi a CSS szerepe a HTL oldalak kódjában?

96.Hogyan csatolhatunk CSS alapú stílus lapokat a HTML forrásokhoz?

97.Hogyan különítjük el a HTML kódot a Java Script és a PHP programrészektől?

98.Milyen feltételei vannak a JavaScript-ek futtatásának?

99.Elégséges-e a JavaScirp technológia dinamikus, adatbázis alapú weboldalak

készítéséhez?

Irodalomjegyzék

• Andrew S. Tanenbaum Számítógép-hálózatok ISBN: 9789635453849PANEM kiadó Kft.

• Kozma László, Varga László A szoftvertechnológia elméleti kérdéseiISBN: 9789634636489., ELTE Eötvös Kiadó Kft. 2007

• Michael J. Hernandez, John L. Viescas SQL-lekérdezések földihalandóknak Gyakorlati útmutató az SQL nyelvű adatkezeléshez ISBN:9789639637528., Kiskapu Kft. 2009.

• Benczúr A. szerkesztő: Adatbázis-rendszerek (Alapvetés) Panem Kiadó,

• Budapest, 2008. Eredeti könyv: J.F.Ullman - J. Widom: A First Coursein Database Systems, 3rd edition, Prentice Hall, pp. 1-600

• Bagoly Zsolt. Balsai Péter, Dr. Dudás Ágnes, Dr. Iványi Péter, KósaAttila, Pandur Béla, Dr. Pázmándi Kinga, Szegfű László, TomkaGergely, Dr. Várady Géza, Wéninger Ágnes, A nyílt forráskódúszoftverek közigazgatási alkalmazhatóságának vizsgálata ODF AllianceMagyarország Egyesület, Szabad Szoftver Intézet Kht.

• Csörnyei Zoltán, Kása Zoltán Formális nyelvek és fordítóprogramokISBN: 9736105059., Kolozsvári Egyetemi Kiadó, 2007.

• Csörnyei Zoltán Fordítóprogramok Typotex, 2006., ISBN 963 9548 83 9• Az informatika alkalmazásai sorozat 3. kötete, ISSN 1787-6044

• Simon Singh Kódkönyv - A rejtjelezés és rejtjelfejtés története ISBN:9789635307982., Park Könyvkiadó. 2007

• Mike Andrews, James A. Whittaker Hogyan törjünk fel webhelyeket - Webalkalmazások és webes szolgáltatások biztonsági vizsgálata ISBN:9789639637245., Kiskapu Kft. 2007.

• Király Roland – Dinamikus weboldalak fejlesztése EKF jegyzet 2010

• Király Roland – Funkcionális nyelvek EKF jegyzet 2010