A PHP programozási nyelv részletes bemutatása-példákkal együtt!
A cikkünkben a PHP nyelvvel foglalkozik. Mit érdemes tudni róla, mire használják? Mik a legfőbb elemei? Ezeket részletes példákkal igyekszünk bemutatni. Lesz szó elágazásokról, függvényekről, Cookikról, Sessionokről, és még sok minden másról.
Manapság nagyon elterjedtnek minősül a PHP nyelv, ez annak köszönhető, hogy a legtöbb weboldal, webáruház, és webes portál PHP programozási nyelvet használ szerveroldalon.
Egy kifejezetten praktikus, és könnyen tanulható scriptnyelvről lenne szó, és a népszerűsége töretlennek látszik az évek alatt. A mai napig rengeteg olyan PHP-ra épülő keretrendszer, és CMS is van melyek hatalmas támogatottsággal bírnak-gondoljunk csak a WordPressre, ami az interneten található összes weboldal 33%-át szolgálja ki. Viszont, ha úgy vesszük, gyakorlatilag az összes CMS PHP-ra épül, márpedig a kisebb weboldalak nagy részét ma már CMS-ekkel készítik el.
Ezen felül, számtalan olyan keretrendszer létezik, ami szintén PHP alapú, ilyenek például a Laravel, és a Symfony, amiket előszeretettel használnak komplexebb webshopok, ügyviteli rendszerek fejlesztésére is.
Viszont, ha úgy vesszük, még arra is látni sokszor példát, hogy 1-1 weboldalt natív PHP-val készítenek el, tehát egyáltalán nem kiveszett a nyelv önmagában vett használata sem.
Annak érdekében, hogy picit átláthassuk a PHP nyelv megfelelő működését, szerettük volna ezt a kisebb cikket elkészíteni. Ez egyrészt egy általános áttekintőt igyekszik nyújtani, másrészt példákon szeretné bemutatni a PHP nyelv megfelelő használatát.
Mi az a PHP programozási nyelv?
A PHP egy nagyon széles körben elterjedt szerveroldali scriptnyelv. Alapvetően webes célokra lett létrehozva, és habár alapvetően nem objektumorientált nyelvként lett megalkotva, ma már támogatja az OOP alapvető elemeit.
Számos verziója volt ezidáig, jelenleg a 7.4-es verziónál tart, emellett a legtöbb platformon könnyedén elfut.
Véleményem szerint kifejezetten ajánlott lehet olyan embereknek a PHP-t megtanulni, akik talán még soha nem programoztak ez idáig, vagy nem volt ilyen téren sikerélményük. Egy kifejezetten szimpla, és egyszerű nyelv, és néhány óra gyakorlás után már képesek lehetünk vele kisebb működő applikációkat elkészíteni.
Hogyan állítsuk elő a megfelelő környezetet?
Ahhoz, hogy el tudjunk kezdeni kódolni, szükség lehet egy webszerverre a számítógépünkön. A legtöbben ilyen célra az úgynevezett XAMPP-ot használják, töltsük le a számítógépünkre a platformunk számára megfelelő verziót. Ez tulajdonképpen egy Apache disztribúciót fog telepíteni.
Ezek után, a PHP-t, valamint a MySQL-t lehet érdemes installálnunk. Mindezt a PHP.NET-ről tehetjük meg, töltsük le ezeket, és ezzel gyakorlatilag mindent elő is készítettünk, amire szükségünk lenne a PHP futtatásához.
Ahhoz, hogy magát a kódot meg tudjuk írni, szükségünk lehet még egy szövegszerkesztőre is. A legtöbben a NotePad++-ot szokták javasolni erre a célra, kezdőknek igazából nem rossz választás, én mégis a VS Code-t javaslom. Semmivel nem nehezebb a használata, és a fájlstruktúra sokkal jobban látható benne.
Töltsük le a VS Code-t. Habár számtalan jó kiegészítő létezik a PHP-hoz ezen belül, ne installáljuk őket: kezdőként fontos, hogy ne használjunk semmilyen formázót, korrektort, hisz jól meg szeretnénk tanulni a nyelv alapjait.
Hogyan hozhatunk létre PHP kódot?
A PHP kód létrehozásához menjünk a telepítés során létrejövő xampp/htdocs mappába. Itt hozzunk létre egy index.php nevű fájlt, és annak a tartalmát VS Code-ban adjuk meg a következőnek:
Ezek után nyissuk meg az XAMPP Control Panelt dupla kattintással (érdemes a tálcára kitűzni az ikonját, ha gyakran szeretnénk programozni). Kattintsunk az „Apache” melletti gombra, majd ezek után írjuk be az URL címsorba, hogy „localhost”. Amennyiben index.php-nak neveztük el a fájlunkat, az alábbi látvány fog fogadni minket:
Ezzel létre is hoztuk az első PHP scriptünket, ami meg is jelent a böngészőben. Jobb kattintással nézzük meg az oldal forrását, és meglepve konstatálhatjuk majd, hogy az egy szimpla felépítésű HTML oldalt kaptunk-a PHP nyelv a megfelelő HTML tartalom előállítását szolgálhatja, de maga a PHP nyelv nem fedezhető fel egy oldal forrásában.
PHP szintaxis
Ahogy azt az előző példában is láthattuk, a PHP kódunkat a jelek közé kell írnunk. Amennyiben csupán PHP kódot helyeznénk el egy PHP fájlon belül, nem szükséges a záró tag-et, tehát a ?> jelet kiírni.
Ebből már azt is sejthetjük, hogy egy PHP fájlban nem csupán PHP kódot helyezhetünk el: akár HTML, CSS, vagy JavaScript kódot is, mindez nem fogja befolyásolni a PHP működését. Az alábbi fájl például ugyanúgy érvényes PHP kódot tartalmaz:
Ez egy cím.
A PHP statementeket ; jellel kell elválasztani egymástól. Nem feltétlenül szükséges azokat külön sorba írni, de nagyon ajánlott az áttekinthetőség miatt.
// egy lehetséges opció echo "Ez egy statement"; echo "Ez egy másik statement"; // egy jobb opció echo "Ez egy statement"; echo "Ez egy másik statement";
A PHP nyelvben bizonyos kulcsszavak nem számítanak kis-és nagybetű érzékenynek. Például, az echo, if, else, switch, a beépített függvénynevek, mint például az str_replace, ugyanúgy működöni fog kis-és nagybetűs változatban is, ahogy a saját függvényeink is. Ezek nem case-sensitive állítások. Érdemes szem előtt tartanunk, hogy ez nem igaz például változók esetén.
echo "Hello World!"; ECHO "Hello World!"; Echo "Hello World!";
Kommentelés
A kommentelés nagyon fontos része lehet minden egyes programozási nyelvnek. Abban az esetben, ha lenne egy kódrészletünk, amit meg szeretnénk tartani, mert később még esetleg szükségünk lenne rá, vagy magyarázatokat szeretnénk fűzni a kódunk bizonyos részeihez, ezt kell használnunk.
A kommentelés tulajdonképpen a kódunkon belül létrehozott tetszőleges karaktersorozat, ami a futáskor nem lesz figyelembe véve.
Egysoros kommentelést a //, valamint a # jelekkel hozhatunk létre. Ezeket alapvetően írhatjuk a sor elejére, vagy egy érvényes kód mögé is.
// ez egy soros komment # ez szintén egy egysoros kommenet
Többsoros kommentelést hozhatunk létre a /*, és a */ jelek között. Amennyiben a zárórészt lefelejtjük, az egész kódunkon belül addig fog tartani a kommentelés, amíg egy zárórészt nem bukkan fel a kódunkban.
/* Ez egy többsoros komment Ez szintén a többsoros komment része */
A PHP kommentelés nem egyenlő a HTML-ből ismert kommenteléssel, csak és kizárólag a PHP kódunkat tudjuk vele befolyásolni.
Változók
Mint ahogy minden nyelvben így szokott ez lenni, a PHP-ban is hozhatunk létre változókat, amikben különféle értékeket tárolhatunk el. A $ jellel kezdődnek, és a változó nevét kell közvetlenül utána írni. Az erősen típusos nyelvekkel ellentétben nem kell megadni a változók típusát deklaráláskor.
Ha egy állat nevű változót szeretnénk definiálni, akkor az így tehető meg:
// ez egy definiált változó. $allat="zsiráf"; //ez már egy másik változó $Allat="medve"; // ez a harmadik változó $ALLAT = "borz"; //újra deklarálás $allat="zsiráf"; $allat="papagáj";
Ahogy már korábban említettük, a változók case-sensitivenak minősülnek a PHP nyelven belül, tehát különböző változókról lesz szó kis-és nagybetűk eltérése esetén. Amennyiben viszont pontosan ugyanolyan névvel definiálunk egy új változót, akkor annak az értéke felülíródik majd.
A PHP változók nem tartalmazhatnak kötőjeleket, és nem kezdődhetnek számokkal. Ide vehetjük még a konstansok meghatározását: nagyon hasonló egy változóhoz, azzal a különbséggel, hogy az értéke nem változhat meg a későbbiek során. Definiálásuk a define() szóval történik, vagy pedig a const szóval: mindkettő ugyanazt jelenti lényegében.
const ember_1 = "Józsi";
define("ember_2", "Laci");
Adattípusok
A PHP-n belül megtalálható a legtöbb szokásos adattípus. A String egy egymás után fűzött karaktersorozatként fogható fel, az Integer egész számként. A float, és double egy szám, melyben található decimális rész.
Az array tömbként értelmezhető, hasonló értékek rendezett halmazát szokták tárolni benne egy változóban. Az objektumokat mindig osztályokból hozhatjuk létre, gyakorlati alkalmazását tekintve általában komplexebb „valós” dolgokat modellezünk vele: például nagyon hasonló tárgyakat (autók), azok specifikus tulajdonságaival (hány ajtaja van, milyen a színe).
- String
- Integer
- Float (double)
- Boolean
- Array
- Object
- NULL
Sokszor előfordulhat, hogy egy konkrét változó típusára lennénk kíváncsiak a kódunkon belül. Ekkor a var_dump() függvény lehet a segítségünkre, ami kiírja a változó típusát, és annak értékét.
$ember = "Józsi"; var_dump($ember);
Kiíratás
Természetesen, amennyiben vannak változóink, azokat igény szerint meg is szeretnénk jeleníttetni valamilyen formában a felhasználóink részére. A legegyszerűbb módja egy változó kiíratásának az echo, valamint print parancs lenne, ha szeretnénk, akkor használhatunk zárójeleket is.
// papagáj jelenik meg a böngészőben echo $allat; echo ($allat); //borz jelenik meg a böngészőben print $ALLAT; print($ALLAT);
Sokszor előfordul az is, hogy igény lenne arra, hogy a változóinkat valamilyen HTML kóddal együtt írjuk ki, például mert sortörést szeretnénk eszközölni. Ekkor erre egy lehetséges mód az úgynevezett string konkatináció, a HTML tartalmat a . jellel lehet a változónkhoz fűzni idézőjelek között.
echo $allat . " "; echo ($allat) . " "; //borz print $ALLAT . " "; print ($ALLAT) . " ";
Operátorok
Alapvetően sokféle különböző operátor létezik: például aritmetikai, összehasonlító, logikai, értékadó operátor.
Az aritmetikai operátorok a matematikai műveletekre vonatkoznak vonatkoznak: például összeadás, kivonás, szorzás, osztás.
$a = 3; $b = 4; $c = 8; // 7 echo $a + $b; // -1 echo $a - $b; // 32 echo $b * $c; // 2 echo $c / $b;
Az értékadó operátorok arra jók, hogy a különféle változóink értékeit tudjuk modifikálni. Ezek tulajdonképpen nem lennének szükségesek, csupán a kódolási technikánkat teszik egyszerűbbé.
// a bal oldali változó megkapja az értékét a jobb oldalinak. b=2 lesz. $a = 2; $a = $b; // eggyel növeli az a értékét. a=3 lesz. $a += 1; // eggyel csökkenti az a értékét. a=1 lesz. $a -= 1; // kettővel szorozza az a értékét. a=4 lesz. $a *= 2;
Az összehasonlító operátorok arra használhatók, hogy a különböző változók egyezőségét vizsgálják. Ilyen lehet például a ==, ===, !==,!=, >, >=.
$a = 4; $b = "4"; $c = true; //true $a == $b; //false $a !== $b; //false $a === $b; //true $a >= $b; //false $a > $b;
A logikai operátoroknak akkor van hatalmas jelentősége, mikor esetvizsgálatokat végzünk bizonyos feltételek alapján. Legismertebb az és (and, &&), valamint a vagy (or, ||) operátor: az előbbi akkor ad igazat vissza, ha a feltétel minden egyes eleme igaz, a második akkor, ha legalább az egyik.
$x = 10;
$y = 30;
$z = true;
// "lefutottam!
if ($y == 30 && $z) {
echo "Lefutottam!";
}
// Nem történik semmi
if ($y == 15 && $z) {
echo " Lefutottam!";
}
// Nem történik semmi
if ($x == 50 || $z == false) {
echo "Lefutottam!";
}
Elágazások
Sokszor előfordulhat, hogy mikor a kódunk futása egy bizonyos ponthoz ér, el szeretnénk dönteni, hogy bizonyos feltételektől függően mi történjen. Erre szolgálhat remek eszközként a különféle elágazások használata.
Az if blokkban levő elemek akkor futnak le, ha a feltétel teljesül. Ha további feltétleket szeretnénk szabni, amikor akkor fussanak le, ha az if nem teljesült, akkor ezt az else if, és else elágazások segítségével tehetjük meg. A feltételsor végét, amit mindenképp le szeretnénk futtatni, amennyiben egyik állítás sem teljesült, azt az else blokkba kell írnunk.
Mindig az a kódrészlet fog lefutni, ami először teljesült a sorban, ha egyik sem, akkor az else részlet.
$a = 6;
if ($a == 9) {
echo "A megadott érték 9";
} elseif ($a == 2) {
echo "A megadott érték 2";
} else {
echo "A megadott érték nem 2, és nem is 9";
}
Van egy szebb, és egyszerűbb, átláthatóbb módja is az esetvizsgálatnak a PHP nyelven belül, ezek az úgynevezett switch elágazások. Itt is különböző eseteket definiálhatunk a case blokkokon belül, és a default fog lejátszódni, amennyiben egyik sem megfelelő.
switch ($a) {
case 9:
echo "A megadott érték 9";
break;
case 2:
echo "A megadott érték 2";
break;
default:
echo "A megadott érték nem 2, és nem is 9";
}
PHP ciklusok
A szokásos ciklusfélék ugyanúgy megtalálhatók a PHP nyelven belül is, ahogy a legtöbb programozási nyelvben. A működésük lényegében azonos.
A for ciklusban mindig három definíció van: az első a ciklusváltozó kezdeti értékének definiálása, a második a feltétel: amennyiben az éppeni ciklusváltozó teljesíti az adott feltételt, a ciklus tovább halad. A harmadik pedig arra való, hogy a ciklusváltozó értékét módosíthassuk valahogy-így szabjuk meg, hogy annak mikor legyen vége.
for ($x = 0; $x <= 5; $x++) {
echo "A kiírt szám: $x
";
}
A while ciklusban egyetlen feltételt definiálunk, és a kódblokk addig fog futni, ameddig az a bizonyos feltétel igaznek minősül, tovább nem. A Do-while ciklus abban különbözik a whiletól, hogy itt mindig le fog futni legalább egyszer a meghatározott kódblokk. A második ciklus, a do-white csak egyszer fut le, mert a feltétel nem teljesül.
$x = 1;
while ($x <= 5) {
echo "A szám: $x
";
$x++;
}
$x = 1;
do {
echo "A szám: $x
";
$x++;
} while ($x > 100);
A foreach ciklus csupán tömbökön alkalmazható. Ennek az a lényege, hogy a tömbben levő elemek értékét, vagy a kulcs-érték párokat kiírathassuk a segítségével.
$elements = ['Sajt', 'Alma', 'Szalámi'];
foreach ($elements as $element) {
echo $element;
}
$elements = ["elso" => "Leves", "masodik" => "desszert"];
foreach ($elements as $key => $value) {
echo $key . $value . "
";
}
Függvények
A PHP nyelven belül van lehetőség arra, hogy a függvényeket egyénileg definiáljuk, illetve, rengeteg beépített függvény is létezik, amelyeket alapból használhatunk, amennyiben szeretnénk.
String függvények
Egy kisebb seregnyit össze lehetne szedni azokból, amelyek kifejezetten stingek kezelésére találtak ki, ennek megfelelően érdemes lehet a legfontosabbakat bemutatni.
Az strlen segítségével egy string hosszát, karakterszámát kaphatjuk meg.
Az explode arra való, hogy egy stringet bontsunk szét bizonyos karakterek mentén egy tömbbé.
A trim segítségével bizonyos karaktereket vághatunk ki az adott string végéről, elejéről. Amennyiben nem adunk meg neki argumentumot, akkor a kifejezés elejéről, és végéről szedi ki a whitespacekat, ellenkező esetben a második argumentum minden egyes karakterét el fogja távolítani a határról.
Az ucwords segítségével minden egyes szavunk első betűjét nagybetűre változtathatjuk.
Az str_replace arra való, hogy egy stringen belül próbáljunk meg egy bizonyos karaktersorozatot helyettesíteni egy másikkal.
$str = "alma körte barack cseresznye";
echo strlen($str) . " a string hossza:
";
echo (print_r(explode(" ", $str)) . "
");
echo trim($str, "a") . "
";
echo ucwords("alma körte barack cseresznye") . "
";
echo str_replace("alma", "eper", $str) . "
";
Matematikai függvények
A PHP-ban alapból rengeteg beépített matematikai függvény található. Ezeknek a segítségével a legtöbb matematikai művelet könnyedén elvégezhető.
A pi() függvény a matematikából ismert PI értékét adja vissza, a min(), és max() függvények ezzel szemben egy argumentum között megadott számsorozatok minimum, és maximum értékeit. Az abs() az abszolút érték meghatározására szolgál, a round() a kerekítésre. A rand() függvénnyel egy tetszőleges random számot generálhatunk.
echo pi() . " "; echo min(1, -10, 100) . " "; echo max(1, -10, 100) . " "; echo abs(-30) . " "; echo round(3.4) . " "; echo rand() . " ";
Egyénileg definiált függvények
Természetesen nagyon sok mindenre használhatók a PHP beépített függvényei, de majdnem minden applikációban szükség van arra, hogy egyénileg definiált függvényeket hozzunk létre. Ennek oka az azonos funkcionalitás igény, valamint a megfelelő strukturáltság.
A függvények deklarálása mindig a function kulcsszóval történik. Ezek után a függvény neve, a () zárójelpár, és a {} jelek következnek, ahová a logikai tartalom fog kerülni. A függvények meghívása a függvény nevével, valamint a mögötte kiírandó zárójelpárral történhet. A függvények nevei nem kicsi-és nagybetű érzékenyek.
function sayOk()
{
echo "Minden oké!";
}
// Minden oké!
sayOk();
// Minden oké!
SAYOK();
Amennyiben szeretnénk, természetesen lenne lehetőség arra is, hogy a függvényeknek argumentumokat adjunk.
function saySomething($arg)
{
echo "Az argumentum: " . $arg;
}
// Az argumentum:körte
saySomething("körte");
Amennyiben szeretnénk, definiálhatunk alapértelmezett értékeket is argumentumoknak a függvényeken belül.
function sayAnother($arg = null)
{
if ($arg) {
echo "Az argumentum: " . $arg . "
";
} else {
echo "Nem adtál meg argumentumot!".
";
}
}
// Az argumentum:alma
sayAnother("alma");
// Nem adtál meg argumentumot!
sayAnother();
Superglobalok
A superglobalok tulajdonképpen előre definiált változóknak minősülnek a PHP-ban: ha rájuk nézünk, akkor láthatóan változók, $ jellel kezdődnek. Ezek olyan téren speciálisnak tektinthetők, hogy bárhonnan elérhetők: bármilyen függvényből, vagy osztályból is anélkül, hogy bármilyen speciális dolgot művelnénk.
A legfontosabb superglobalok, melyeket szeretnénk is bemutatni:
- $_GET
- $_POST
- $_SESSION
- $_COOKIE
$_GET
A $_GET arra való, hogy az URL-ünkben megjelenő paramétereket kaphassuk meg a segítségével. Sokszor előfordulhat, hogy egy másik fájlra szeretnénk naviálgni, és ekkor az adatok továbbításának egyik módja lenne, hogy az URL-ben elhelyezünk egy paramétert. Tegyük a fájlunkba az alábbi kódot, és az URL végére írjuk azt, hogy ?param=22. Az eredmény:
echo "A paraméter: " . $_GET['param'];
Alapvető, hogy privát információkat, például jelszavakat soha ne továbbítsunk ilyen módon. Ezek felül, van egy meghatározott maximum hossza is. A leggyakoribb alkalmazása az lenne, mikor az URL-ben megjelenik egy paraméter, és az alapján szeretnénk egy adatbázisból egy értéket kinyerni, ami azonosítja az adott elemet. Például mikor erre a blogcikkre mentél, akkor az applikáció az URL alapján találta meg az adatbázisban a megfelelő cikket.
$_POST
A $_POST a legjobb módja annak, hogy adatokat küldjünk el a szerverre feldolgozásra, például egy űrlap kitöltése esetén. Amikor egy úrlapot kitöltünk, és rákattintunk a submit gombra, akkor az űrlap értékeinek neve alapján létrejön egy tömb, melynek elemei az űrlapon megadott értékek. Egy példa lehet erre:
Név:
?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$name = $_POST['name'];
if (empty($name)) {
echo "A név nem lett megadva.";
} else {
echo "A név: " . $name;
}
}
$_SESSION
A Sessionok arra használhatók, hogy az applikációnkon belül változókat tárolhassunk el, melyeket bármelyik oldalon felhasználhatunk, vagy akkor is, ha az oldalunk újra töltött. Gyakori alkalmazás erre, amikor egy felhasználót bejelentkeztetünk a rendszerbe, és megjegyezzük az adatait, ezzel ellenőrizzük, hogy mihez legyen annak joga hozzáférni. Ahhoz, hogy használni tudjuk, a session_start() szükséges, amit a dokumentumunk leges legtetejére kell tennünk, még a HTML elemek fölé.
?php
session_start();
if (!isset($_SESSION["counter"])) {
$_SESSION["counter"] = 1;
echo "Létrejött a session számláló.";
} else {
$_SESSION["counter"] += 1;
echo $_SESSION["counter"] . " Az értéke.";
}
?
$_COOKIE
A PHP nyelven belül a Cookiek arra valók, hogy a kliens számítógépén egy miniatűr fájlt helyezzünk el, amelyet a böngésző újbóli megnyitásakor felhasználhatunk.
Gyakori alkalmazás erre, mikor egy felhasználó meg szeretné jegyeztetni a jelszavát a következő belépés alkalmával.
setcookie('username', "Kiss Tamás", time() + (86400 * 30), "/"); // 86400 = 1 nap másodpercben
if (!isset($_COOKIE['username'])) {
echo "A Cookie nincs létrehozva!";
} else {
echo "A Cookie értéke: " . $_COOKIE['username'];
}
MySQL, és PHP
Abban az esetben, ha szeretnénk a PHP nyelvet használnunk, jó eséllyel meg kell majd ismerkednünk az SQL-lel is, ugyanis a legtöbb esetben szükség lesz valamilyen adatbázissal való interakcióra a munka során.
Egy egyszerű példán keresztül bemutatva, hogy hogyan kell a PHP-t, és a MYSQL-t együtt használni: hozzunk létre egy adatbázist a kettő segítségével.
$servername = "localhost";
$username = "root";
$password = "";
// csatlakozás létrehozása
$conn = new mysqli($servername, $username, $password);
// Csatlakozás ellenőrzése
if ($conn->connect_error) {
die("Csatlakozás nem sikerült: " . $conn->connect_error);
}
// Adatbázis létrehozása
$query = "CREATE DATABASE a_pelda_adatbazis";
if ($conn->query(
$query
) === TRUE) {
echo "Az adatbázis sikeresen létrehozva.";
} else {
echo "Valamiért nem sikerült létrehozni: " . $conn->error;
}
$conn->close();
Osztályok, és objektumok
Az osztályok definiálása a class szóval történik, és ezeken belül hozhatunk létre különféle láthatóságokat a tulajdonságok számára, melyek a public, private, és protected. Ezek közül példányosításkor mindig csak a public elemeinket tudjuk elérni közvetlenül.
class Auto
{
public $kerekek = 4;
}
$element = new Auto();
echo $element->kerekek . " a kerekek száma";
Ily módon lehet hasonló tulajdonságokat definiálni az egyes objektumoknak. Írtunk egy sokkal részletesebb cikket a PHP OOP témakörben, ha valaki érdekel, érdemes lehet olvasni.
Hogyan tovább?
Felmerülhet bennünk a kérdés: mit kellene még megtanulnunk, amennyiben már sok mindennel tisztában vagyunk? Ismerjük a PHP nyelv alapjait. Tudjuk, hogy hogyan kell mondjuk egy adatbázishoz kapcsolódni, és tisztában vagyunk azzal is, hogy mik azok a függvények, Sessionok, és a többi.
Ekkor érdemes lehet valamilyen jó PHP oldali keretrendszert elsajátítanunk. A mai legtöbb PHP programozói állásnál elvárás, hogy egy jelentkező tisztában legyen azzal, hogy egy mai, modern PHP oldali keretrendszer hogyan működik.
Egyáltalán, mit is takar ez a fogalom? A keretrendszer nem más, mint előre megírt függvények, és könyvtárak egy nagy halmaza, amit azonnal használhatunk a munkához, ezzel jóval megkönnyítve a dolgunkat, és lerövidítve a fejlesztési időt. Általában barátságos dokumentációval rendelkeznek, és rendkívül jó biztonsági szintjük van.
Talán elsőre kicsit soknak tűnik ez, de látni fogjuk: a keretrendszereket könnyebb használni, mint magát a PHP nyelvet, ha ugyanazt az applikációt szeretnénk elkészíteni.
Kezdőknek kifejezetten ajánlott lehet a Laravel megtanulása, ez a legkeresettebb, és legkönnyebben megtanulható PHP oldali keretrendszer.