Ez a fejezet a PHP nyelv alapjaiban vezeti be az olvasót. Az ismertetéskor a fejezet erősen épít a JavaScriptes tapasztalatokra, amit e tananyag korábban már tárgyalt. A PHP-t erre alapozva közelíti meg, kiemelve a hasonlóságokat és az eltéréseket is.
Az előző részben a dinamikus szerveroldali webprogramozás filozófiájával ismerkedtünk meg. Láthattuk, hogy a kliens-szerver architektúrát egy harmadik komponens egészíti, egy program, amely a kliensnek leküldött tartalmat állítja elő. Megnéztük a komponensek kommunikációját biztosító protokollokat is. Végül egy C++ programon keresztül mutattuk be a szerveroldali dinamikus tartalomgenerálás működését.
Ebben a tananyagban a továbbiakban azonban nem a C++ nyelvet fogjuk használni erre a feladatra, hanem a PHP programozási nyelvet. Tesszük ezt azért, mert a PHP egy nagyon népszerű és elterjedt nyelv, amelyet kifejezetten dinamikus weboldalak előállítására találtak ki. Rengeteg beépített függvénye és opcionálisan használható moduljai segítségével sokféle művelet végezhető el viszonylag könnyedén. Főleg kis és közepes méretű projektekhez és tartalomkezelő rendszerekhez használják.
Ebben a fejezetben a PHP környezettel és nyelvvel kapcsolatos alapvető tudnivalókat tekintjük át. Egy rövid történeti bevezetőt követően áttekintjük a fejlesztéshez szükséges eszközöket, egy PHP fájl felépítését, futtatását, majd a PHP nyelvi elemeit tekintjük át.
A PHP egy személyes projektből nőtte ki magát a web egyik legelterjedtebb nyelvévé. Születése Rasmus Lerdorf nevéhez kötődik, aki pár CGI szkriptet írt személyes honlapjával kapcsolatos tipikus feladatok elvégzéséhez. Ebből fakad a PHP neve is: Personal Home Page, azaz személyes weboldal. Később ezeket a modulokat a hatékonyság miatt C nyelven írta újra, és kiegészítette űrlapok feldolgozásával és adatbázisok kezelésével kapcsolatos műveletekkel. Az így létrejött projektet 1995-ben PHP2 néven publikálta a hibák gyorsabb megtalálása érdekében.
A következő fontos lépés 1997-ben következett, amikor két izraeli fejlesztő, Zeev Suraski és Andi Gutmans újraírta az értelmezőt, így teremtve meg a PHP3 alapjait. A neve is ekkor változott meg a rekurzív PHP: Hypertext Preprocessor-ra. A PHP-mag az idők során többször került átírásra, jelentősen bővítve a PHP nyelv képességeit. 1999-ben a magot Zend Engine-nek keresztelték el, ennek első verziója szolgált a PHP 4-es verziójának alapjául 2000-ben. 2004-ben jelent meg a PHP5-ös verziója, amelyet a Zend Engine 2 hajtott meg. Ez a verzió sok újítást hozott, legszembetűnőbb az objektum-orientált programozás szélesebb körű támogatása volt. A tananyag írásának időpontjában a 6-os verzió még mindig nem jelent meg.
A PHP részletesebb történetéről a Wikipédián olvashatunk.
A PHP állományoknak a .php a tipikus kiterjesztése. Bár a PHP-t alapvetően a webes környezet ihlette, ez egy általános szkriptnyelv, melyet sokféle környezetben lehet felhasználni. Egyre gyakrabban használják parancssori feladatok elvégzésére (parancssori interfész, angolul Command Line Interface – CLI), amellyel klasszikus szkriptnyelveket, például shell szkriptet vagy a Perlt váltják ki. Ekkor a parancssorban a PHP értelmezőnek megmondjuk melyik állományt futtassa:
Népszerűsége kapcsán olyan területeken is megjelenik, amely távol áll eredeti céljától. Ilyen például grafikus asztali alkalmazások programozása, amely egy külön projekt, a PHP-GTK segítségével válik lehetővé.
Természetesen leggyakrabban dinamikus weboldalak készítéséhez használják, és tananyagunk is ilyen szempontból vizsgálja működését. Ekkor a .php kiterjesztésű állományt a webszerveren kell elhelyezni a PHP telepítésétől függően két helyre. Ha a PHP CGI módban van telepítve, akkor a cgi-bin könyvtárba szükséges a futtatandó fájlt elhelyezni. Sokkal hatékonyabb kiszolgálást kapunk azonban akkor, ha a PHP szerver modulként van feltelepítve. Ekkor ugyanis nem külön folyamat (process), hanem csak külön szálként (thread) indul el az értelmező, ami az operációs rendszer szempontjából gyorsabban megvalósítható. Ekkor a PHP állományok bárhol elhelyezkedhetnek a publikus dokumentumaink között. (A CGI és szerver modul futtatása közötti különbségről részletesebben a Weblabor cikkében olvashatunk.)
A PHP szkript meghívását kliensoldalon kell kezdeményezni, pl. a böngésző címsorába írva a PHP állomány webes elérési útvonalát. Például:
Bárhogy is van a PHP értelmező telepítve az oldalkiszolgálás lépései megegyeznek az előző részben írt folyamattal, csak éppen ebben az esetben a program, amely a tartalmat állítja elő az értelmezett PHP állomány. A webszerver a .php kiterjesztést látva előkeresi a fájlrendszerből az igényelt állományt, majd azt átadja a PHP értelmezőnek, amely végrehajtja az állományban lévő kódot, és annak kimenetét a webszerver továbbítja a kliensnek. A PHP állomány célja tehát az, hogy a megfelelő webes tartalmat (HTML dokumentum, CSS, kép, JavaScript állomány) előállítsa.
A PHP mint dinamikus tartalomgeneráló program az oldalkiszolgálás folyamatábanA szerveroldali webprogramozás eszközigénye az architektúra bonyolultsága folytán sokkal nagyobb, mint a kliensoldali webprogramozásé. A következőkre lesz szükségünk:
Amikor egy meglévő szerverhez kapunk hozzáférést, akkor a fejlesztőkörnyezet szerveroldali része, a webszerver és a PHP beállítások adottak, csak igazodni tudunk hozzájuk. Fejlesztői gépeken azonban mi magunk szoktuk ezeket a komponenseket telepíteni. Itt is két lehetőségünk van. Vagy mi magunk végezzük el az egész infrastruktúra kialakítását, vagy egy előre összeállított fejlesztői csomagot telepítünk a gépre. Az előbbi sokkal időigényesebb folyamat, ugyanakkor jó betekintést ad ezen komponensek működésébe és összeillesztésébe. Az utóbbi ugyanakkor viszonylag gyorsan teszi elérhetővé a fejlesztőkörnyezet kialakítását, ráadásul sokszor hordozható változatban teszik ezt elérhetővé. Sokféle ilyen csomag létezik, például XAMPP vagy WampServer.
Ahogy fentebb már említettük, a PHP állományok tipikus kiterjesztése a .php, de előfordul, hogy más kiterjesztésű fájlok (pl. .inc) is tartalmaznak PHP kódot. Igazából a kiterjesztés mindegy is, a PHP értelmező a fájl tartalma alapján végzi el a végrehajtást.
Egy PHP állományban a PHP kódot <?php és ?> elemek közé kell helyezni. A legegyszerűbb esetben a fájl egyetlen ilyen elempárt tartalmaz:
<?php //PHP kód ?>
Egy fájlban azonban több ilyen PHP blokk is elhelyezkedhet. A blokkon belüli rész értelmezésre, az a szövegrész pedig, ami PHP blokkon kívül helyezkedik el, automatikusan kiírásra kerül. A fájl értelmezése szekvenciálisan, felülről lefele történik.
Szöveg <?php //PHP kód ?> Szöveg <?php //PHP kód ?> Szöveg
Tananyagunk elején a JavaScript programozási nyelvet az ismertnek feltételezett C++ nyelv felől közelítettük, először hangsúlyozva a hasonlóságokat, később kitérve a lényeges különbségekre is. A PHP nyelv ismertetésénél hasonló elvet követünk. Ahelyett, hogy módszeresen felépítve, egyenként bemutatnánk a PHP nyelv elemeit, megint csak ismerős talajról közelítjük meg a nyelvet, hogy aztán a specifikumokra rátérjünk. Ezzel a módszerrel élve talán könnyebben átjut az olvasó az új nyelv megismerésének nehézségein, és jobban meg tudja érteni a különbségekből adódó lényeges pontokat. A PHP nyelv teljes tudnivalóit és módszeres bevezetését egyébként a PHP dokumentáció nyelvi referenciája tartalmazza.
A PHP egy gyengén típusos, értelmezett, általános célú szkriptnyelv. A fenti tulajdonságok alapján hasonlít a JavaScript nyelvhez, amelynél ezen tulajdonságok jelentését és következményét (pl. automatikus típuskonverzió) már kifejtettük. De nemcsak a nyelv viselkedése lesz számunkra ismerős a JavaScriptből. A PHP ugyanis ugyanúgy C szintaxisú, mint a JavaScript, így a vezérlési szerkezetek, operátorok ugyancsak nem okoznak meglepetést a PHP-t még nem ismerő számára.
A nyelv néhány további jellemzője körvonalakban:
Itt érdemes megjegyezni, hogy a PHP és JavaScript közötti hasonlóság egyedül az azonos nyelvi típusból és a C szintaxisból fakad. A PHP nyelv igazi ihletője a C mellett egyébként a Perl nyelv volt. A Perl nyelvet ismerő olvasó számára majd feltűnhet számos olyan elem, amelyet a PHP a Perlből vett át. A legszembetűnőbb a változók $ jellel való jelölése, de számos függvénynek is a Perl volt a forrása.
Megjegyzéseket ugyanúgy lehet írni PHP-ban, mint JavaScriptben vagy C++-ban. Ezen kívül a PHP támogatja a shell szkriptből vagy Perlből ismerős szintaxist is, amelynél # jelet követően lehet megadni az egysoros megjegyzést.
<?php //egysoros megjegyzés # Perl szintaktikájú egysoros megjegyzés /* többsoros megjegyzés */ ?>
PHP-ban a következő elemi adattípusok vannak:
Az összetett típusok:
Speciális típusok:
A logikai típusnak két értéke van (nem kis- és nagybetű érzékeny):
<?php true false TRUE FALSE ?>
Literálformában megadhatók binrátis, oktális, decimális és hexadecimális értékek:
<?php 12 //decimális -34 0123 //oktális 0x0F //hexadecimális 0b0101 //bináris ?>
<?php 3.1415 5.6e12 -7E-2 ?>
PHP-ban sokféleképpen lehet szöveget megadni. Legegyszerűbb esetben a szöveget aposztrófok között adjuk meg. Ekkor a PHP semmiféle további feldolgozás nem végez. Ha macskakörmök közé rakjuk a szöveget, akkor egyrészt a szokásos escape szekvenciák értelmeződnek (pl. \t, \n, stb.), másrészt a szövegben lévő változók értékei is automatikusan behelyettesítésre kerülnek. Mindkét megadási mód támogatja többsoros szövegek bevitelét.
A fenti megadási módok alternatívája a nowdoc és heredoc formátum. Ezeknél egy tetszőlegesen megadott token nyitó és zárópárja között adjuk meg a szöveget. A nyitótokent <<< előzi meg, a zárótokennek a sor elején kell lennie egyedüli szövegként a sorban. A nowdoc formátum az aposztrófos megadás, a heredoc a macskakörmös megadás viselkedését örökli.
Változó behelyettesítésekor érdemes a változót -be tenni.
<?php
$a = 12;
'alma\t{$a} alma'; //"alma\t{$a} alma"
'Több
sor is lehet benne';
"alma\t{$a} alma"; //"alma 12 alma"
"Ez egy
több soros szöveg";
<<<'EOT' //"Ez is lehet {$a}
Ez is lehet {$a} // több soros"
több soros.
EOT;
<<<EOT //"Több soros 12
Több soros {$a} // szöveg"
szöveg
EOT;
?>
A változók nevét a $ karakter vezeti be, például: $a.
Hatókört illetően a függvényen és osztályon kívül létrehozott változók globálisak lesznek, a függvényen belül létrehozottak lokálisak. A PHP ezen kívül definiál néhány szuperglobális változót, amelyek mindenhonnan elérhetőek (bővebben ld. függvények).
PHP-ban az echo és a print utasítás szolgál kiírásra. Ezek nem igazi függvények, így a kiírandó kifejezést nem kötelező zárójelbe tenni.
<?php
echo 'piros alma';
$szin = 'sárga';
echo "{$szin} körte";
echo 'Több
soros
szöveg';
echo <<<VEGE
Ez meg egy
{$szin} alma
VEGE;
?>
Egy változó kiírására, értékének nyomon követésére az alábbi utasítások szolgálhatnak:
Egy változó típusának lekérdezésére a gettype függvény, típusának eldöntésére az is_típus függvények használatosak. Teljesség igénye nélkül:
Egy változó típusának beállítására a (típus)$változó formájú típuskényszerítés vagy a settype($változó, 'típus') függvény használható.
<?php //Különböző típusú változók $l = true; $i = -23; $d = 23.65; $s = 'alma'; //Kiírások echo $l; //1 echo $i; //-23 echo $d; //23.65 echo $s; //alma var_dump($l); //bool(true) var_dump($i); //int(-23) var_dump($d); //float(23.65) var_dump($s); //string(4) "alma" print_r($l); //1 print_r($i); //-23 print_r($d); //23.65 print_r($s); //alma //Típuslekérdezés echo gettype($l); //'boolean' echo gettype($i); //'integer' echo gettype($d); //'double' echo gettype($s); //'string' //Típusbeállítás $sd1 = (string)$d; $sd2 = $d; settype($sd2, 'string'); echo gettype($sd1); //'string' echo gettype($sd2); //'string' ?>
A következő függvények a változók beállítottságát, ürességét kérdezik le:
A függvények viselkedésének megértését összehasonlító táblázatok segítik. A gyengén típusosságból fakadó automatikus típuskonverzióknak szintén külön fejezetet szentelnek a PHP hivatalos leírásában.
A használandó operátorok jelentős része megegyezik a JavaScriptben megismerttel. Egyetlen lényegi különbség, hogy a + operátor PHP-ban kizárólag számok összeadására szolgál, így két operandusát mindenféleképpen számként értelmezi. A szövegösszefűzés operátora PHP-ban a . operátor.
<?php 'piros' + ' alma'; //0 'piros' . ' alma'; //'piros alma' ?>
Vezérlési szerkezeteket illetően alig van újdonság a PHP-ban a JavaScripthez képest. Egyedül a for ciklusban van eltérés a ciklusváltozó használatában, valamint tömbök és objektumok bejárására egy új ciklus, a foreach szolgál (bővebben ld. a tömböknél).
<?php
//Különbségek a JavaScripthez képest
for ($i = 1; $i <= n; $i++) {
utasítások;
}
foreach ($tomb as $ertek) {
utasítások;
}
foreach ($tomb as $kulcs => $ertek) {
utasítások;
}
?>
Ahogy a típusoknál fentebb már írtuk, PHP-ban kétféle lehetőség van összetett adatszerkezet megvalósítására: a tömb és az objektum. Ebben a tananyagban ugyan majd foglalkozunk a PHP nyelv objektumorientált aspektusával, de csak azért, hogy lássuk működését, és továbblépést biztosítsunk azok számára, akik a kódszervezés ezen formáját szeretnék későbbiekben alkalmazni. A továbbiakban azonban ez a tananyag egyedül a tömböt használja majd mint összetett adatszerkezet. Látni fogjuk, hogy a PHP-beli tömb rugalmassága megengedi ezt számunkra.
A PHP-beli tömb egy olyan dinamikus struktúra, amelynek mérete szabadon változtatható, és amelynek elemei kulcs-érték párokból állnak. A kulcs egész szám vagy szöveg lehet, az érték bármilyen típusú lehet. A PHP-s tömb ilyen jellegű rugalmassága teszi lehetővé, hogy PHP-ban a gyűjtemények általános objektuma legyen. Segítségével gyakorlatilag az összes ismert összetett adatszerkezet leírható, megvalósítható:
A tömb létrehozására az array() kulcsszó szolgál, illetve a PHP 5.4-es verziójától kezdve a JavaScriptből ismerős literálforma ([]) is használható. Az elemek már létrehozáskor is megadhatók kulcs => érték formában vesszővel elválasztva. Az egyes elemekre [] zárójelben megadott kulccsal hivatkozhatunk. A tömb hosszát a count függvénnyel lehet lekérni, de ez nem az utolsó számmal indexelt elem indexét adja vissza, hanem a tömb számosságát. A tömb végére elemet rakni legegyszerűbben egy üres [] operátorral lehet. Ekkor egy számmal indexelt elem jön létre, méghozzá az eddigi legnagyobb számos index eggyel növelt helyén. Elem törlésére az unset függvény szolgál.
Nézzünk néhány példát a tömbök használatára:
<?php
//Üres tömb
$uresTomb = array();
//vagy PHP 5.4-től kezdve:
$uresTomb = [];
//Indexelt tömb létrehozása előre megadott elemekkel
$indTomb = array('alma', 12, true, -23.34);
print_r($indTomb);
/*
Array
(
[0] => alma
[1] => 12
[2] => 1
[3] => -23.34
)
*/
//Hivatkozás az elemekre
$indTomb[0]; //"alma"
$indTomb[1]; //12
$indTomb[2]; //true
$indTomb[3]; //-23.34
//A tömb hosszának lekérdezése
count($indTomb); // => 4
//Elemek módosítás
$indTomb[1] = 13;
$indTomb[1]; //13
//Új elem beszúrása a tömb végére
$indTomb[] = 'új';
print_r($indTomb);
/*
Array
(
[0] => alma
[1] => 13
[2] => 1
[3] => -23.34
[4] => 'új'
)
*/
//Új elem felvétele tetszőleges indexre
$indTomb[100] = 'messze';
count($indTomb); // => 5
print_r($indTomb);
/*
Array
(
[0] => alma
[1] => 13
[2] => 1
[3] => -23.34
[4] => 'új'
[100] => 'messze'
)
*/
//A köztes elemek null értékűek
is_null($indTomb[42]); // => true
//Elem törlése
unset($t[1]);
print_r($indTomb);
/*
Array
(
[0] => alma
[2] => 1
[3] => -23.34
[4] => 'új'
[100] => 'messze'
)
*/
//Asszociatív tömb
$gyumolcsok = array(
'alma' => 'piros',
'korte' => 'sárga',
'szilva' => 'kék',
);
print_r($gyumolcsok);
/*
Array
(
[alma] => piros
[korte] => sárga
[szilva] => kék
)
*/
//Hivatkozás elemekre
echo $gyumolcsok['alma']; //piros
//Bővítés új elemekkel
$gyumolcsok['barack'] = 'barackszín';
$gyumolcsok[] = 'zöld';
print_r($gyumolcsok);
/*
Array
(
[alma] => piros
[korte] => sárga
[szilva] => kék
[barack] => barackszín
[0] => zöld
)
*/
?>
Tömbök bejárása legegyszerűbben a foreach ciklussal lehetséges:
<?php
//Az előző példabeli tömb iterációja
foreach ($gyumolcsok as $gyumolcs => $szin) {
echo "{$szin} {$gyumolcs}\n";
}
/*
piros alma
sárga korte
kék szilva
barackszín barack
zöld 0
*/
?>
Egy másik lehetőség a PHP tömbkezelő függvényeinek használata (reset(), next(), prev(), current(), key(), each(), stb.)
<?php
reset($gyumolcsok);
while (list($kulcs, $ertek) = each($gyumolcsok)) {
echo "{$ertek} {$kulcs}\n";
}
?>
A tömb rugalmasságát felhasználva a legtöbb ismert és gyakran előforduló adatszerkezetet viszonylag könnyen leképezhetjük PHP-ban.
Értékek sorozatát tipikusan számokkal indexelt tömbben tároljuk. A JavaScript nyelvi elemeit bemutató fejezet példáit felhasználva, a nálunk lévő kütyük felsorolását a következőképpen valósíthatjuk meg:
<?php
$kutyuk = array(
'telefon',
'fülhallgató',
'pendrive',
'e-könyv olvasó',
);
?>
Ha rekord implementálására van szükségünk, akkor a PHP-s tömb asszociatív funkcióit használjuk ki:
<?php
$hallgato = array(
'nev' => 'Mosolygó Napsugár',
'neptun' => 'kod123',
'szak' => 'Informatika BSc'
);
?>
Gyakran előforduló feladat rekordok tömbjének a megvalósítása. Mivel PHP-ban mindkettőt tömbbel ábrázoljuk, ezért ilyenkor egymásba ágyazott tömbök jelennek meg az adatstruktúrában. A külső tömböt számokkal indexeljük, a belső rekordokat asszociatív tömbökkel valósítjuk meg:
<?php
$hallgatok = array(
array(
'nev' => 'Mosolygó Napsugár',
'neptun' => 'kod123',
'szak' => 'Informatika BSc',
),
array(
'nev' => 'Kék Ibolya',
'neptun' => 'kod456',
'szak' => 'Informatika BSc',
),
);
?>
Természetesen ezek az adatszerkezetek tetszőleges mélységben egymásba ágyazhatók a leírandó adatnak megfelelően:
<?php
$hallgatok = array(
array(
'nev' => 'Mosolygó Napsugár',
'neptun' => 'kod123',
'szak' => 'Informatika BSc',
'targyak' => array(
'Programozás',
'Webfejlesztés 2.',
'Számítógépes alapismeretek',
),
),
array(
'nev' => 'Kék Ibolya',
'neptun' => 'kod456',
'szak' => 'Informatika BSc',
'targyak' => array(
'Programozás',
'Webfejlesztés 2.',
'Diszkrét matematika',
'Testnevelés',
),
),
);
?>
JSON formátumban elmentve PHP tömböt, az asszociatív tömbből objektum, az indexelt tömbből tömb lesz. A JSON formátumba mentéssel egy későbbi fejezet foglalkozik.
A PHP-beli függvények szintaktikájukban erősen hasonlítanak a JavaScriptbeli függvényekre. A gyengén típusosságból adódóan itt sem kell meghatározni sem a paraméterek, sem a visszatérési érték típusát. Van azonban számos különbség is. Az egyik legfontosabb a változók láthatóságával kapcsolatos. A PHP függvény nagyon zárt, külön jelzés nélkül még a globális változók sem érhetők el belőle. Kétféleképpen lehet rájuk hivatkozni: vagy a $GLOBALS tömbön keresztül, vagy global kulcsszóval kell ellátni a globális változót. Egyedüli kivételt ez alól a szabály alól a szuperglobális változók képeznek. Ezek – ahogy a nevük is sejteti – mindenhonnan elérhetőek. Ilyen például a $GLOBALS tömb is, és későbbi fejezetekben ugyancsak találkozunk majd ilyenekkel.
A paramétereket illetően lehetőség van egy paraméternek alapértelmezett értéket adni, valamint az érték szerinti paraméterátadás mellett referencia szerint is átadhatjuk a paramétereket. Ekkor a formális paraméter előtt a & operátorral kell ezen szándékunkat jelölni.
<?php
//Függvény általános formája
function fvnev($par1, $par2) {
utasítások;
return visszatérési érték;
}
//Például
function negyzet($x) {
return $x * $x;
}
negyzet(3); // => 9
//Alapértelmezett érték
function udvozles($nev = 'Senki bácsi') {
return "Hello {$nev}!";
}
udvozles(); // => "Hello Senki bácsi!"
//Referencia szerinti paraméterátadás
$szam = 41;
function novel(&$szam) {
$szam += 1;
}
novel($szam);
echo $szam; // => 42
//Globális változók elérése
$globus = 'Föld';
function zartFuggveny() {
global $globus;
echo "Gyönyörű a {$globus}!"
}
//vagy
function zartFuggveny() {
echo "Gyönyörű a {$GLOBALS['globus']}!"
}
?>
Az alábbiakban felsorolásszinten megadunk néhány hasznos függvényt. Ezekről bővebben a dokumentációban lehet olvasni.
A PHP nyelv elemei, az adat- és vezérlési szerkezetek, valamint a függvények ismeretében már rendelkezünk azzal az eszköztárral, mellyel az absztrakt programozási tételek PHP-ban implementálhatók. Az összehasonlítás kedvéért nézzük meg a JavaScriptes példáinkat PHP nyelven.
Feladatunk egy számsorozat elemeinek az összegét meghatározni. A számsorozatot tömbben tároljuk, a megoldást pedig egy külön függvénnyel választjuk el a program többi részétől. A függvény bemenetén a tömb helyezkedik el, visszatérési értékként pedig a megoldás, a számsorozat összege jelenik meg. A tömbön való lépegetés legegyszerűbben a foreach ciklussal végezhető el.
<?php
function osszegzes($tomb) {
var $s = 0;
foreach ($tomb as $szam) {
$s = $s + $szam;
}
return s;
}
$x = array(1, 3, -2, 8);
echo 'Az összeg: ' . osszegzes($x);
?>
Feladatunk egy számsorozatbeli negatív szám megadása. Ebben a feladatban a kihívást a kimeneten szereplő két adat reprezentálása jelenti. Korábban láttuk, hogy ez leginkább egy rekorddal tehető meg, ami PHP-ban asszociatív tömbbel ábrázolható. A megoldás tehát a következő:
<?php
//Számokkal indexelt tömb esetén
function kereses($tomb) {
$i = 0;
while ($i < count($tomb) && !($tomb[$i] < 0)) {
$i++;
}
return array(
'vane' => $i < count($tomb),
'sorsz' => $i
);
}
//Tetszőleges tömb esetén, felsorolókkal
function kereses($tomb) {
$l = false;
reset($tomb);
while (!$l && !(current($tomb) === false)) {
$elem = current($tomb);
$l = $elem < 0;
next($tomb);
}
return array(
'vane' => $l,
'elem' => $elem
);
}
$x = array(1, 3, -2, 8);
print_r(kereses($x));
?>
Ebben a fejezetben megismerkedtünk a PHP nyelv történetével, futtatási lehetőségeivel, helyével a dinamikus szerveroldali webprogramozásban, egy PHP állomány felépítésével. Láthattuk, hogy milyen nyelvi elemekből áll a PHP nyelv. Azt tapasztaltuk, hogy szerencsére nincsen nagy eltérés sem típusában, sem szintaxisában a JavaScript nyelvtől, így viszonylag könnyedén elsajátíthatjuk a nyelv alapjait. Az adattípusokat tekintve elmondhatjuk, hogy az egyszerű típusok mellett az összetett típusoknál igazából egyetlen típust érdemes ismerni, a tömböt, amellyel szinte bármelyik komplexebb adatstruktúra leírható. A fejezet végén programozási tételek implementálására láthattunk példákat.
A JavaScript nyelvi elemeit gyakorló feladatok közül oldjunk meg néhányat PHP nyelven is!
 |
 |
 |
A tananyag az ELTE - PPKE informatika tananyagfejlesztési projekt (TÁMOP-4.1.2.A/1-11/1-2011-0052) keretében valósult meg.
A tananyag elkészítéséhez az ELTESCORM keretrendszert használtuk.