3. Menjen a fájlhoz megment_
felhasználó.
phpés adja hozzá a következő kódot, miután eltávolította a szóközöket a bejelentkezési névből és a jelszóból:
if (!empty($_POST["fupload"])) //ellenőrizze, hogy a felhasználó elküldte-e a képet
{
$fupload=$_POST["feltöltés"]; $feltöltés = trim($feltöltés);
if ($fupload =="" vagy üres($fupload)) (
unset($fupload);// ha a $fupload változó üres, akkor törölje
}
}
if (!isset($fupload) vagy üres($fupload) vagy $fupload =="")
{
//ha a változó nem létezik (a felhasználó nem küldött képet), akkor rendeljen hozzá egy előre elkészített képet „nincs avatar” felirattal
$avatar = "avatars/net-avatara.jpg"; //lerajzolhatod a net-avatara.jpg-t, vagy átveheted a forrásból
}
más
{
//egyébként - a felhasználó képének betöltése
$path_to_90_directory = "avatars/";//mappa, ahova a kezdeti kép és annak tömörített másolata betöltődik
If(preg_match("/[.](JPG)|(jpg)|(gif)|(GIF)|(png)|(PNG)$/",$_FILES["feltöltés"]["név"])) //a forrás képformátum ellenőrzése
{
$fájlnév = $_FILES["feltöltés"]["név"];
$forrás = $_FILES["feltöltés"]["tmp_name"];
$cél = $útvonal a_90_könyvtárhoz . $fájlnév;
move_uploaded_file($source, $target);//az eredeti feltöltése a $path_to_90_directory mappába
if(preg_match("/[.](GIF)|(gif)$/", $fájlnév)) (
$im = imagecreatefromgif($elérési_út_90_könyvtárba.$fájlnév) ; //ha az eredeti gif formátumú volt, akkor hozzon létre egy képet ugyanabban a formátumban. Szükséges a későbbi tömörítéshez
}
if(preg_match("/[.](PNG)|(png)$/", $fájlnév)) (
$im = imagecreatefrompng($útvonal a_90_könyvtárhoz.$fájlnév) ;//ha az eredeti a következőben volt png formátumban, akkor létrehozunk egy képet ugyanabban a formátumban. Szükséges a későbbi tömörítéshez
}
4. Ugyanahhoz az adatbázishoz hozzá kell adni egy táblát. Eltárolja azokat az IP-címeket, amelyek a bejelentkezéskor hibáztak. Így nagyjából 15 percre korlátozhatjuk a hozzáférést azokra, akik egymás után háromnál többször hibáztak.Szerintem a jelszavakat választó programoknak még sokáig trükközniük kell.
Menjünk a phpmyadmin oldalra, és hozzunk létre egy új táblázatot 3 mezővel:
$result = mysql_query("SELECT * FROM felhasználók WHERE login="$bejelentkezés" ÉS jelszó="$jelszó",$db); //lekéri az adatbázisból az összes adatot a megadott bejelentkezési névvel és jelszóval rendelkező felhasználóról
$myrow = mysql_fetch_array($eredmény);
if (üres($myrow["id"]))
{
//ha a megadott bejelentkezési névvel és jelszóval rendelkező felhasználó nem létezik
//Rögzítjük, hogy ez az ip nem tudott bejelentkezni.
$select = mysql_query("SELECT ip FROM oshibka WHERE ip="$ip"");
$tmp = mysql_fetch_row($select);
if ($ip == $tmp) (//ellenőrizze, hogy a felhasználó az "oshibka" táblában van-e
$result52 = mysql_query("SELECT col FROM oshibka WHERE ip="$ip"",$db);
$myrow52 = mysql_fetch_array($eredmény52);
$col = $myrow52 + 1;//egy újabb sikertelen bejelentkezési kísérlet hozzáadása
mysql_query("UPDATE error SET col=$col,date=NOW() WHERE ip="$ip"");
}
más(
mysql_query("INSERT INTO oshibka (ip,date,col) VALUES ("$ip",NOW(),"1")");
//ha nem volt hiba az elmúlt 15 percben, akkor illessze be új bejegyzés az „oshibka” asztalhoz
}
//Ezután az adatokat cookie-kba mentjük a későbbi bejelentkezéshez.
//FIGYELEM!!! EZT SAJÁT BESZÉLÉSE SZÁMÁRA TEGYE, MIVEL AZ ADATOK TITKOSÍTÁS NÉLKÜL SÜTISÜK-BEN TÁROLNAK.
if ($_POST["mentés"] == 1) (
//Ha a felhasználó azt szeretné, hogy adatai mentésre kerüljenek a későbbi bejelentkezéshez, akkor azokat a böngésző cookie-jaiba mentjük.
setcookie("bejelentkezés", $_POST["bejelentkezés"], time()+9999999);
setcookie("jelszó", $_POST["jelszó"], time()+9999999);
}}
visszhang"
5. Teljesen megváltoztatjuk a főoldalt. Meg kell jeleníteni rajta a felhasználó avatárját, meg kell jeleníteni egy linket a fiókból való kijelentkezéshez, és be kell jelölni egy jelölőnégyzetet, hogy bejelentkezéskor emlékezzen a jelszóra.
Index.php
// az egész eljárás munkamenetekben működik. Ez az a hely, ahol a felhasználó adatait tárolják, amíg az oldalon tartózkodik. Nagyon fontos az oldal legelején elindítani őket!!!
session_start();
include("bd.php");// a bd.php fájlnak ugyanabban a mappában kell lennie, mint az összes többinek, ha nem, akkor csak módosítsa az elérési utat
if (!empty($_SESSION["bejelentkezés"]) és !empty($_SESSION["jelszó"]))
{
//ha van bejelentkezési név és jelszó a munkamenetekben, akkor ellenőrizze őket, és kérje le az avatart
$bejelentkezés = $_SESSION["bejelentkezés"];
$jelszó = $_SESSION["jelszó"];
$result = mysql_query("SELECT id,avatar FROM userek WHERE login="$bejelentkezés" ÉS jelszó="$jelszó",$db);
$myrow = mysql_fetch_array($eredmény);
//kivonja a szükséges felhasználói adatokat
}
?>
//************************************************************************************
//ha a bejelentkezés sikeres, a felhasználó megkapja mindazt, ami a csillagok között FÖLTT található.
}
?>
6. Lehetővé kell tenni a bejelentkezett felhasználók számára a kijelentkezést. Tovább kezdőlap Már volt link a kijárathoz. De ez a fájl még nem létezik. Tehát alkossunk új fájl kilépés.php kóddal:
Néha szeretne egy kis szünetet tartani a jelenlegi kódolási rutintól és az apró problémáktól, amelyek a „részletekről” szóló cikkekben a helynek vannak szentelve. Vessen egy pillantást arra, amit már régóta csinál. Tehát az én elképzelésem a PHP programozás fő feladatának – weboldalak generálásának – megközelítéseiről. Részben már érintettem ezt a témát részben - a sablon osztályról és az XML-ről szóló cikkek az archívumban találhatók. Most szeretném az egészet összehozni, és valami monumentálisat csinálni. Első rész.
1. A php eredete
Hol kezdődött a legtöbbünk számára a php? Egy szkript beszúrásától HTML oldalakba. Például a saját linkkönyvtárát. Egy adott kategória linkjeit tartalmazó oldal:
". mysql_result($eredmény, 0). ""; mysql_free_result($eredmény); $eredmény = mysql_query("SELECT azonosító, cím, arány, leírás, site_date FROM site WHERE rubrika=". intval($id). " ORDER BY arány DESC, site_date DESC, title"); if (mysql_error()) echo mysql_error(); else while ($row = mysql_fetch_assoc($eredmény)) echo " ($sor)
($sor)
Felvétel: ($sor), Értékelés: ($sor)
Egyszerű és szerény, de a lényeg az, hogy ez a kód működjön. A nehézségek akkor kezdődnek, ha megpróbálja beírni a kategória nevét az oldal címébe. Ehhez létre kell hoznia egy php betétet a címkén belül
, helyezze oda az első kérést végrehajtó kódot (a kategória nevének lekérése), a kérés eredményét mentse el egy változóba, amely ezután megjelenik az oldal törzsében.
A következő bonyodalom a cookie-kkal való munkavégzés és a cookie-k kiadása attól függően, hogy a felhasználó mely szakaszokat látogatja meg. Hogy jobban elképzeljük: döntsük el, hogy látogatók tömegei jöjjenek a honlapunkra, és a potenciális hirdetők számára készítsünk célzott bannermotort. Tegyük fel, hogy egy felhasználó, aki felkeresi a rockzene és a hangszerek rovatát, a következő oldalon egy elektromos gitárboltot hirdető szalaghirdetést fog látni.
Ebben az esetben a PHP kódot a fájl elejére kell beszúrnunk, és oda kell áthelyeznünk a kategória meglétére vonatkozó ellenőrzést, mert a cookie-k csak a dokumentum első bájtjának kiadása előtt adhatók ki.
Természetesen azt fogja mondani, hogy ez könnyen megtehető a felhasználói munkamenet-mechanizmussal, amely egyszerűbb a tartalom kiadása szempontjából és biztonságosabb, mivel a felhasználó manuálisan módosíthatja a cookie tartalmát. Igen, ez igaz, de egyrészt ez egy kezdő programozó saját honlapot készítő víziója, másrészt a távoli múltról beszélünk - gyakorlatilag 1998-ban járunk.
Nem könnyíti meg sokkal az életet azzal, hogy azonos HTML- és PHP-kódblokkokat ír ki a mellékelt fájlokba. A fent leírt feladat - egy egyszerű hivatkozási katalógus felépítése kategóriákkal - talán ennek a megközelítésnek a képességeinek felső határa. Bonyolultabb feladatok elvégzése esetén nagyon nagy a kockázata annak, hogy nagyobb munkaerőköltségekkel kell találkozni.
2. A kód bonyolítása
Az előző megközelítés logikus továbbfejlesztése a PHP-re való teljes átállás abban az értelemben, hogy minden oldal PHP kód - a fájl elején van egy nyitó tag "
class="club_article_small_caption">Hírek ügyfeleknek
"); $result = mysql_query("SELECT azonosító, cím, bejelentés, hír_dátum FROM news ORDER BY news_date DESC LIMIT 10"); if (mysql_error()) print(mysql_error()); else while ($row = mysql_fetch_assoc($) eredmény)) print(" ($sor)"); if ($sor["hírdátum"] > dátum("Y-h-d", time() - 3600*24*14)) print(" új!"); print(" |
($sor)
($sor) |
"); print("
"); tartalmazza a "page-footer.inc"; ?>
De ez egyáltalán nem egyszerűsíti le a munkát, és mindenképpen eljön a számonkérés órája: szükség lesz az oldalterv újrakészítésére. A tervező egyszerűen megtagadja ennek szerkesztését. Csak az tudja megérteni, aki ilyen kódot írt, és lecserélheti a régi HTML-t az újra. Ha ez a személy már nem dolgozik a projekten, akkor a projektet szinte a nulláról kell átírni, különben meghal, és az emberi rövidlátás emlékművévé válik.
Egy másik lehetőség a vegyes HTML és PHP megközelítés fejlesztésére. A PHP rendelkezik egy advanced-escaping tulajdonsággal. Lehetővé teszi normál HTML kód megjelenítését a nyelvi konstrukciókban:
Hírek az ügyfeleknek
=$row["news_date"]?>dátum("Y-h-d", time() - 3600*24*14)) ( ?> új! | ">
=$row["title"]?>
=$row["announce"]?> |
Az elrendezéstervező vagy tervező, ha megnyitja ezt a fájlt a HomeSite-on, látni fogja a HTML-jelölést kiemeléssel, és szerkesztheti az oldalak tervét. Egyszerű oldalakhoz ez a módszer meglehetősen megfelelő. Bonyolult helyzetekben ez egyáltalán nem jó.
3. Puccs
A PHP 3.0 megjelenésével... Egyébként nem ártana visszaállítani a kronológiát, hiszen átfogó történelemről beszélünk. Tehát itt van a kronológia, amelyet a php bejelentési levelezőlista archívumával és a webarchívum egy oldalával állítottak vissza:
1997.08. PHP 3.0 Béta1 1998.06.06 PHP 3.0 Kiadás 1999.07.19 PHP 4.0 Béta1 2000.05.22 PHP 4.0 Kiadás 2001.10.12. PHP 4.1 2001.06.20 PHP 4.1 20.204.20. PHP 4.3.0pre1 (a pre1 nem béta, de még mindig nem Felszabadítási jelölt)
Így a PHP 3.0 megjelenésével megjelentek az eszközök a PHP programozás új megközelítésének – az oldalpufferelésnek a szkriptekben történő – alkalmazására. (Fontos megjegyezni, hogy ez nem ugyanaz a pufferelés, mint most.)
Az idő múlásával a honlapkészítés feladatai összetettebbé váltak, a PHP-t egyre szélesebb körben használták, a weboldalak pedig egyre dinamikusabbak lettek. Minél nagyobb a webhely, annál problémásabb mindent megtenni a PHP és HTML vegyes fájljaival. Teljesen logikus, hogy a PHP kiterjesztés következő lépése az volt, hogy a szkript memóriájában lévő HTML oldalt feldolgozzuk, és részben vagy egészben bemutatjuk a felhasználónak.
Ennek a megközelítésnek a megvalósítását legalábbis a PHP3-ban megvalósított objektum-orientált programozás támogatása (na jó, emulációja) segítette. Létre lett hozva sablon osztályok, ami megkönnyítette az oldalsablonnal való kezelést és az abba beírandó adatokat.
Ez kibővítette a programok lehetőségeit, ugyanakkor több rendszererőforrást igényelt. Ma már elmondhatjuk, hogy ennek a megközelítésnek az előnyei meghaladták a rendszererőforrások költségeit, de alig két-három évvel ezelőtt sokan azt hitték, hogy a teljes dokumentum memóriában tartása megfizethetetlen luxus a webes programozás számára.
Képletesen szólva tehát forradalom történt a technológiában: ha korábban a PHP belebújt a HTML kódba, és bátortalanul adta hozzá az információit, akkor most előkerült, és az összes HTML-t a mancsában tartja.
4. Miért rosszak a házi sablonórák?
Hat hónappal később úgy döntöttem, változtatok valamit a terveimen. Nem lesz moralizálva a saját készítésű órák rosszasága. Ők jók. Használja őket, és amire szüksége van, az magával fog jönni! Ne feledje, hogy bizonyos körülmények zavarják Önt.
Első. Ha az osztályt kifejezetten írták, ez azt jelenti, hogy kissé elvált az élettől. Annak ellenére, hogy az osztály nagy fejlesztési tapasztalattal rendelkezik, mégis melegházi körülmények között készült. Az így létrejövő technológiának meglesznek a maga sajátos használati feltételei, amelyekhez a jövőbeni fejlesztéseket kell igazítani, vagy az osztályt át kell alakítani.
Második. A különböző projektek fejlesztéseiből szintetizált osztály szintén változtatásokat igényel – minél globálisabb, annál inkább.
Tehát készíthet saját osztályokat (sablon osztályokat, ha jól tudom, sokan használják a sajátjukat). Ha deduktív módon megy, és egy osztályt épít fel a szükséges becslésekből, akkor kicsi az esélye, hogy valami zseniálisra készül. És nagy a valószínűsége annak, hogy az eredmény nem lesz pontosan az, amire szüksége van. Használhatja az indukciót - majd a nagy és hosszú munka garantáltan kapsz valamit, ami működik, de nem feltétlenül zseniális.
A házi készítésű termékekben az a rossz, amit az előző részekben említettem, hogy az első esetben nagyon nagy a valószínűsége annak, hogy valami borzalmasat kapunk, ami nem úgy működik, ahogy megálmodta, megkívánja. speciális megközelítésés sok kódolás. A második esetben hosszú ideig keményen dolgozhatsz, és olyasmit kaphatsz, amit valaki előtted már megtett és közzétett.
Amikor a technológiák összehasonlításáról van szó, a fő kérdés a relevancia. Nagyon egyszerű webhelyet készíthet a mellékelt fájlokkal, és nem gondol az osztályokra és a motorokra. Jobb, ha sablonok segítségével összetettebb webhelyet készít. Ha a bonyolultság növekszik, és egy oldalon sok függ a különböző feltételektől - navigációs menü az állapottól függően stb. - jobb, ha az XML&XSLT csomagra gondolsz.
Példa: phpBB fórum. Lehetetlen teljesen úgy megváltoztatni a dizájnt, ahogy akarod, mert sok tervezési elem nem a sablonokban, hanem a PHP kódban van. Mindenféle bejelentkezési űrlapok, vezérlő menük a bejelentkezett felhasználó számára, stb. - PHP kóddal beillesztve az oldalba, nem beágyazott sablonként. A legnépszerűbb megoldás nem mindig a legjobb.
Dmitrij Koterov megjegyzi a phpBB tanulással kapcsolatos tapasztalatait: miután megírtak egy sablonórát, sokan, tele lelkesedéssel, mindent ennek az osztálynak a alá helyeznek. Egy ilyen osztály ötlete a kód és a design szétválasztása, de a phpBB szerzői éppen ellenkezőleg, a lehető legjobban keverték őket.
De véleményem szerint még ennek a megközelítésnek a normál megvalósítása mellett is (template class) nehézkes lenne a kód, rengeteg fájl lenne sablonokkal. Az utóbbi időben arra a következtetésre jutottam, hogy a sablon osztályokban elvileg nem lehet igazán elkülöníteni a PHP kódot az adatoktól és a tervezéstől. Amikor egy ilyen motoron megváltoztatja egy webhely kialakítását, feltétlenül el kell mélyednie a PHP szkriptekben, és ezt nem a tervező, hanem Ön fogja megtenni.
__globális__
(rejtett és automatikusan hozzáadott) |
blokk1 |
|
A dokumentáció szerint a sablonban nem kell feltüntetni, hogy melyik blokk melyiknek a gyermeke. Ezt az osztály maga is meg fogja érteni.
Ennek az osztálynak a dokumentációja azt írja, hogy tudja, hogy az inner1 a block2 gyermeke, és erről nem kell beszélni. Adatok blokkba történő beillesztéséhez futtassa le ezt a kódot annyiszor, ahány sorra van szüksége:
setVariable(...); $tpl->parseCurrentBlock(); ?>
Ha tartalmat szeretne hozzáadni a block1-hez, a következőket kell tennie:
setCurrentBlock("belső1"); $tpl->setVariable(...); $tpl->parseCurrentBlock(); $tpl->setVariable(...); $tpl->parseCurrentBlock(); $tpl->parse("blokk1"); ?>
Ennek eredményeként a szkript kódja így néz ki:
loadTemplatefile(string fájlnév [, logikai removeUnknownVariables, logikai removeEmptyBlocks]) // "globális" változók beállítása, pl. a blokkban nem szereplő változók (gyermek blokk) $tpl->setVariable(sztring változónév, vegyes érték); // A változók megadásának másik módja egy tömb $tpl->setVariable(tömb (string varname => vegyes érték)); // Valamelyik blokkot fogunk használni, akár egy másikba mélyen beágyazottat is $tpl->setCurrentBlock(string blokknév); // Ismételje meg annyiszor, amennyire szükséges $tpl->setVariable(tömb (string varname => vegyes érték)); $tpl->parseCurrentBlock(); // megkapja az eredményt, vagy kinyomtatja a $tpl->show() $tpl->get(); ?>
A kód kényelmesebb és áttekinthetőbb, mint a FastTemplate-nél.
De sok programozó még mindig saját sablonosztályokat ír. Egyszerűbb, de olyan funkciókkal rendelkezik, amelyek nem találhatók meg a nyilvános osztályokban. Írtam egy saját osztályt, amelyben blokkokat készítettem, amelyekbe az SQL lekérdezések eredményei automatikusan bekerültek, ezen kívül volt a blokk feje és farka (pl. tagek
), amely csak akkor jelent meg az eredményben, ha az SQL lekérdezésben voltak sorok.
A PHP3 bevezetett egy modult az XML feldolgozási funkciókhoz. A modul funkcióival létrehozhatunk saját XML kódkezelőket, azonban az XML dokumentum érvényességét nem tudjuk ellenőrizni.
Rövid áttekintés az XML elméletéről, és miért van rá szükség.
Az XML a strukturált adatok rögzítésének egyik módja. A "strukturált adatok" általában olyan dolgokat jelentenek, mint a táblázatok, címjegyzékek, konfigurációs paraméterek, pénzügyi tranzakciók, műszaki rajzok stb. Az XML a fejlesztéshez szükséges szabályok halmaza (ezeket utasításoknak vagy konvencióknak is tekintheti). szöveges formátumok, amely lehetővé teszi az adatok strukturálását.
Magyarázat arról, hogy mi a szerkezet.
Hústermékek
Hal
kilogramm
100
Hús
kilogramm
200
Hulladéktermelés
Halkaviár
kilogramm
10
Növényi termékek
Napraforgó
dolog
50
Így lehet XML-ben strukturált adatokat írni egy élelmiszerboltról, amelyben a termékek kategóriákra vannak osztva, és a kategóriák egymásnak alárendelhetők. Természetesen ezek az adatok máshogy is írhatók, mondjuk tabulátorral határolóként és a szülőkategória azonosítóját jelölve (egyébként XML formátumú adatírásnál, mint fentebb is látható, nem kell megadni azt). Az XML egy kész formátum egy ilyen struktúra rögzítésére, amelyen belül csak a csomópontok (címkék) nevét és azokat a szabályokat kell kitalálni, amelyekbe a struktúrának illeszkednie kell (például, hogy egy termék ne helyezkedhessen el egy kategória, vagy hogy nem lehet több harmadik kategóriaszint). További:
Az XML nem programozási nyelv, és nem kell programozónak lenni ahhoz, hogy használni vagy megtanulni. Az XML megkönnyíti a számítógép létrehozását és adatok olvasása, miközben biztosítják szerkezetük egyértelműségét. Az XML elkerüli a gyakori nyelvi tervezés buktatóit: bővíthető, platformfüggetlen, és támogatja a nemzetköziesítést és a lokalizációt. Az XML teljes mértékben Unicode-kompatibilis.
A PHP fejlesztői az XML dokumentum egyes elemeinek feldolgozását javasolják php függvények. Példa a php kézikönyvből:
"B", "EMPHASIS" => "I", "LITERAL" => "TT"); // Címke indítására szolgáló funkció (összetett szöveget is kiadhat, de be ebben a példában// csak a megfelelő címkét adja vissza). function startElement($elemző, $név, $attrs) ( globális $térkép_tömb; if ($htmltag = $térkép_tömb[$név]) ( print "<$htmltag>"; ) ) // Függvény a tagfüggvény végéhez endElement($parser, $name) ( global $map_array; if ($htmltag = $map_array[$name]) ( print "$HTMLTAG>"; ) ) // Szöveg (szövegcsomópont) függvény karakterData($parser, $data) ( print $data; ) $xml_parser = xml_parser_create(); // használja a kis- és nagybetűk hajtogatását, hogy biztosan megtaláljuk a címkét $map_array xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, true); xml_set_element_handler($xml_parser, "startElement", "endElement"); xml_set_character_data_handler($xml_parser, "ML file (fo/Data az X) ($file, "r"))) ( die("nem sikerült megnyitni az XML bemenetet"); ) while ($data = fread($fp, 4096)) ( if (!xml_parse($xml_parser, $data, feof( $fp))) ( die(sprintf("XML hiba: %s a %d sorban", xml_error_string(xml_get_error_code($xml_parser)), xml_get_current_line_number($xml_parser))); ) ) xml_parser_free($xml_parser); ?>
Ez a példa kibővíthető a különböző módon feldolgozott címkenevek tömbjének hozzáadásával, és a megfelelő feltételekkel a startElement és az endElement függvényekben.
A kód teljesen borzasztóan néz ki. Gyakorlatilag alkalmatlan XML-ből HTML-oldalakká alakítani, bár néhol használták, például a How IT works weboldalon. Természetesen írhatsz saját automatákat, amelyek olvasnak konfigurációs fájlokés létrehozott tömböket, de a teljes munkaerőköltség szempontjából jövedelmezőbb olyan hatékony sablonosztályokat használni, mint a Smarty.
A projekt munkálatai még 1999-ben kezdődtek, amikor a fejlesztők egy csoportja elkezdte írni a sablonmotor specifikációit. Miután meghatározták, hogy mit kell tennie, a fejlesztők megpróbáltak egy modult C nyelven írni, de végül úgy döntöttek, hogy jobb, ha PHP nyelven készítenek egy olyan osztályt, amely minden webhelyfejlesztő számára elérhető és érthető.
Most a Smarty az egyik PHP projekt, weboldala a címen található PHP szerver a smarty.php.net oldalon.
Formálisan a Smarty egy sablon osztály. Valójában a funkcionalitása egy nagyságrenddel magasabb, mint a *Template készleté.
Először is, a Smarty nemcsak változókat szúr be a sablonba, hanem magában a sablonban is végrehajtja a PHP kódot. Másodszor, a Smarty sablonjait PHP szkriptekké alakítják át, és a változók szövegbe történő beszúrásával és a logikai konstrukciók végrehajtásával kapcsolatos összes piszkos munkát a beépített PHP elemző végzi. Ha a gyorsítótárazás engedélyezve van, ezek a PHP-szkriptek olyan fájlokba kerülnek mentésre, amelyeket a sablonok következő elérésekor hívnak meg. Amikor a sablonok megváltoznak, a szkriptek újra előállításra kerülnek. Ez a gyorsítótárazás jelentősen felgyorsítja a szkriptek munkáját.
A Smarty a sablonokba épített logikai logikát is képes feldolgozni. if-else konstrukciók, php kóddá alakítva őket. A változó módosítónak nevezett konstrukciók feldolgozása hasonlóan történik. Lehetővé teszik néhány funkció eltávolítását a fő szkriptből, áthelyezve azokat a sablonba és a gyorsítótárazott PHP szkriptjeikbe.
(*A címet írd nagybetűvel*)
($title|felső),
(* Rövidítse le a témát 40 karakterre úgy, hogy a végére írja a... *) Téma: ($téma|csonkítás:40:"...")Ez a szöveg a következő kódra lett konvertálva:
_run_mod_handler("felső", igaz, $this->_tpl_vars["Név"]); ?> Téma:_run_mod_handler("csonkítás", igaz, $this->_tpl_vars["Név"], 40, "..."); ?>
Egy sor beépített változó is elérhető, például a $smarty.now (jelenlegi idő). Az idilli képet egy változó értékeket tartalmazó hibakereső ablak, beágyazott sablonok meghívása, valamint egyéni bemeneti/kimeneti szűrők és bővítmények támogatása egészíti ki.
Minden rendben lenne, ha Smarty kisebb lenne. Most (2.3.1-es verzió) 144 kilobájtot nyom, és észrevehetően lassan fut AMD K6 266 MHz-en. Az okos fejlesztők a Zend Accelerator vagy a PHP Accelerator használatát javasolják.
DOM – be Ebben a pillanatban az utolsó szó a php dokumentumsablonjaiban. A modult az „XML: Specification and DOM Functions in PHP” című cikkben ismertettem.
Bőbeszédűsége és a meglehetősen egyszerű műveleteket végrehajtó nagy mennyiségű kód ellenére a DOM XML nagy ígéretekkel bír.
Az XML-dokumentum szerkesztésének szöveges megközelítésének (természetesen szkriptben történő szerkesztésének) fő hátránya az, hogy vagy figyelmesen el kell olvasni az XML-specifikációt, vagy nem lehet teljesen biztos abban, hogy végül mi történt.
Például a szöveg beszúrása egy csomópontba egyszerű feladat. Egy XML-dokumentumban azonban a szolgáltatáskaraktereket és a nem ISO-táblakaraktereket XML-entitásokká kell konvertálni (<) или в номера символов UTF-8
(&x0442;). В модуле DOM XML достаточно сконвертировать
текст в UTF-8 и вызвать метод create_text_node.
Az oldalamon még mindig egy régi motor fut, amely szöveges karakterláncot generál, és néha érdekes trükköket hajt végre nem megfelelő formájú dokumentumokkal. Ezen kívül az objektumok paraméterként adhatók át egy függvénynek, és a hívott metódus neve változóvá tehető.
Végül a DOM XML fő előnye, hogy nincs bináris modul a dokumentum szövegfeldolgozásához PHP-ben. Ez azt jelenti, hogy magának kell megírnia az elemzőt.
Ami a nagy mennyiségű kódot illeti, ez teljesen természetes. Végül is, ha egy dokumentumot szövegen keresztül szeretne szerkeszteni, akkor írjon reguláris kifejezéseket, és használjon karakterlánc-függvényeket. Ha követi az XML-konvenciókat, sok erre a kódra is szüksége van.
A dokumentummal a DOM-on keresztül végzett műveleteket saját függvényekbe kell csoportosítani, azaz fel kell építeni egy DOM sablon osztályt.
A webhelyre vagy annak szakaszaira vonatkozó közös adatokat külön sablonba helyezheti. A többit az általam leírt technikával kell beilleszteni a dokumentumba:
$root1 = $dom1->document_element(); $gyerek = $gyökér1->gyermek_csomópontok(); $gyökér2 = $dom2->dokumentum_elem(); for ($i = 0; $i< sizeof($child); $i++)
$root2->append_child($child[$i]->clone_node()); ?>
Készíthet egy egyszerű szkriptet a webhelyhez, amelyre a dokumentumkérések át lesznek irányítva. A következő a .htaccess-ben van írva:
Beállítások FollowSymLinks RewriteEngine On # ellenőrzi az azonos nevű # és phpxml kiterjesztésű fájl meglétét a RewriteCond %(DOCUMENT_ROOT)/$1/index.phpxml -f # szakasz gyökérében, ha létezik ilyen fájl, a szabály aktiválódik RewriteRule ^(+)/?$ /$1 /index.php # ez a szabály az előző szabály által # átírt címre és az összes többi # fájlra is működik, kérést küldve a composer.php szkriptnek. RewriteCond %(DOCUMENT_ROOT)/$1.phpxml -f RewriteRule ^(+)\.php$ /composer.php [L]
A composer.php szkript megnyit egy fájlt a kért névvel megegyezően, de a phpxml kiterjesztéssel. Az Apache szerver a szabályok feldolgozása során már ellenőrizte ennek a fájlnak a létezését.
6.1 A dokumentum érvényesítése
Ez egy olyan eszköz, amely felváltja vagy jelentősen kiszorítja a házi adatellenőrző eszközöket. Most divat lett az adatbázis elhagyása és az adatok fájlokban való tárolása.
Az alappal egyszerű volt: kapunk egy tömböt, és készítünk belőle egy szöveges sztringet (egy ciklus vagy egy sablon osztály segítségével, mint a php-templates), vagy kapunk egy stringet az sql2xml objektumfával (vagy ismét egy stringet). Fájlokkal nehezebb dolgozni, mert minden esetre célszerű ellenőrizni az adatok sértetlenségét.
A jelölések létrehozásának két módja van. Az első az adatközpontú jelölés, a második a dokumentumközpontú jelölés.
Példa adatorientált jelölésre:
ETCC
FIA által szervezett versenysorozat. Versenyautókat használ.
BTCC
Brit Túraautó Bajnokság
Analóg az ETCC-vel, kivéve, hogy futamokat vesznek igénybe.
http://btcc.co.uk
DTM
Deuche Tourenwagen Masters
A hierarchia két szintje - sor + mező (természetesen, ha 3 vagy 4 van belőlük, akkor minőségileg semmi sem változik), általában ugyanaz, mint egy sql2xml-lel formázott adatbázisból származó lekérdezés. Példa dokumentum-orientált jelölésre:
Az FIA körülbelül 20 versenyszervizt szervezett, köztük 2 túraautó-bajnokságot. Túraautó Európa-bajnokság
(ETCC) jelentősen tuningolt közúti autókat használ, többnyire BMW-t.
Egy másik FIA sorozat Brit túraautó
(BTCC) analóg az ETCC-vel, kivéve, hogy versenyekre van szükség. Pedig nem ezek a világ leghíresebb bajnokságai. DTM (Deuche Tourenwagen Masters), a leghíresebb Touring versenysorozat nemcsak Németországban.
Ez az opció szabad emberi nyelven van megírva, de az acro és a title elemek adatai változatlanok maradnak, ugyanazokkal az XPath vagy XQuery lekérdezésekkel érhetők el a dokumentumból: /bajnokságok/bajnokságok/cím Az első jelölési opció adatbázistáblaként ábrázolható. Bonyolíthatja például - a dokumentum töredékét:
DTM
Deuche Tourenwagen Masters
A leghíresebb német Touring versenysorozat.
Laurent Aiello
Bernd Schneider
Marcel Fassler
Jean Alesi
Christian Albers
Ez nem akadályozza meg, hogy a dokumentum adatközpontú legyen. Egy új dokumentumot 2 táblaként lehet ábrázolni, amelyeket a LEFT JOIN operátorral lekérdezve egyesíthetünk.
A második dokumentum bonyolultabb szerkezetű, és általában nem lehet táblázatba zsúfolni.
Egyébként ez a fő különbség az XML adatbázisok és a nem XML adatbázisok között. Az XML-adatbázis dokumentum-orientált jelölésekkel is működik (nem csak az eredmények XML-ben kerülnek kiadásra). Az adatközpontú jelölés egy relációs adatbázisban tárolható, a kimenet pedig formázható egy olyan segédprogrammal, mint az sql2xml.
Tehát, visszatérve a dokumentumérvényesítéshez, meg kell jegyezni, hogy a dokumentum-orientált jelölést nagyon nehéz ellenőrizni egy egyszerű karakterlánc-elemzővel, hogy megfelel-e egy DTD vagy XML séma.
Egy másik példa az űrlap jelölése a TXF osztályomban:
0"/>
Ezt egy DTD sémán keresztül tesztelem. A dokumentumséma megfelelőségének ellenőrzése az XML DOM-könyvtár szabványos szolgáltatása.
Az általánosan használt adatcsere-formátumokhoz, például az RSS-hez, vannak specifikációk és DTD-sémák (XML-sémák). A saját RSS-elemző megírásával járó gondok elkerülése érdekében egyszerűen hozzáadhat egy sémát a dokumentumhoz, és ellenőrizheti annak érvényességét. Ezután kérje le a szükséges csomópontokat a dokumentumból a get_content vagy XPath kifejezések használatával.
6.2 Lírai kitérő
Kénytelen voltam sürgősen befejezni a sorozat ezen részének megírását a Spectator legújabb cikke, amely a „PHP Templates for Dummies” címet viseli.
Az olyan szavak elfelejtésére szólít fel, mint az XML, XHTML „és egyéb X...”, miközben megérdemelt lökést ad Smartynak, és a rögtönzést kiegészítve arra szólítja fel az okos embereket, hogy borotválkodjanak Occam borotvájával.
Szegény borotva! Transzparensre emelték, mindenütt lobogtatják, piszkálják és megpróbálják megsebezni vele az ellenfelet.
A fenébe a borotva! A pokolba ezzel az ostoba szabállyal, hogy „ne termeljünk a szükségesnél nagyobb entitásokat”. Ez túlságosan elcsépelt igazság ahhoz, hogy emlékeztesse az embereket, és általában nem alkalmas mások értékelésére. Az „extra szükséges” mennyiség személyenként eltérő. A webhely vásárlója a következőket mondhatja: "Miért van szükségem a szkriptjeire? Készítse el őket egyszerű HTML-ben, hogy később a FrontPage segítségével szerkeszthessük őket! Olvasott már az Occam borotvájáról?"
Régóta úgy gondolom, hogy az új technológiák programozásban való alkalmazásának fő oka a méretgazdaságosság. Ahogy egy régi cikkhez fűzött megjegyzésekben írták nekem: „ahogy az oldal terjedelme növekszik, bele fog fulladni a sablonokba”. A cikkeimben pedig pontosan ezt hangsúlyoztam - azt mondják, játssz a trükkös belefoglalásoddal és a HTML-lel kevert kódoddal, ez akadályozni fog, ha sok programkódot kell megcsinálnod.
Valójában van egy másik oka is. Ezek minden egyes ember készségei. Aki jól ismeri az XML-t, az XSLT-t és az XPath-ot, vagy gyorsan tud megoldást találni a problémákra ebben a környezetben, az a legtöbb esetben XML-technológiák segítségével fejezi be a projektet. Ezt egyszerű és könnyű lesz megtennie, mert jól tudja, hogyan kell csinálni. Azok, akik nem tudják, vagy nem tudják jól, „közös” módokon teszik.
Már csak az a kérdés, hogy az XML technológiát használó megoldásai hatékonyabbak lesznek-e, mintha sablonosztályokkal vagy kevert PHP&HTML-lel csinálta volna? Igen ők fognak. Hadd adjak egy allegorikus összehasonlítást.
Láttad, hogyan röplabdáznak tapasztalt játékosok és „lamerek”? A „labdás” csapatok a másik oldalra dobják a labdát, horoggal vagy csavarással úgy, hogy az ellenfél magára ejti a labdát. Nem tudják, hogyan kell támadócsapást tenni, és a közmondásos borotva vezérelve egyszerűen játszanak. Egy tapasztalt játékos sokkal jobban tudja dobni a labdát, mint egy labdás. Azonban nagyobb eredményeket ér el, ha jó támadócsapást hajt végre.
Ha bármilyen más kérdése van, vagy valami nem világos, üdvözöljük oldalunkon |
|
|
február 5 ,
2017
Nem ismerek semmilyen PHP keretrendszert. Ez szomorú és szégyenletes, de még nem tiltja a törvény. De ugyanakkor szeretnék játszani a REST API-val. A probléma az, hogy a php alapértelmezés szerint csak a $_GET és a $_POST fájlokat támogatja. A RESTful szolgáltatáshoz pedig tudnia kell a PUT, DELETE és PATCH funkciókkal is dolgozni. És nem túl nyilvánvaló, hogyan kell kulturáltan feldolgozni sok ilyen kérést A http://site.ru/users beszerzése, a http://site.ru/goods/5 TÖRLÉSEés egyéb trágárságok. Hogyan lehet az összes ilyen kérést egyetlen pontba csomagolni, univerzálisan részekre bontani, és futtatni a szükséges kódot az adatok feldolgozásához?
Szinte minden PHP keretrendszer képes erre. Például a Laravel, ahol az útválasztást egyértelműen és egyszerűen hajtják végre. De mi van akkor, ha most nem egy új nagy témát kell tanulmányoznunk, hanem csak gyorsan szeretnénk elindítani egy projektet REST API támogatással? Erről a cikkben lesz szó.
Mire képes a RESTful szolgáltatásunk?
1. Támogassa mind az 5 fő kéréstípust: GET, POST, PUT, PATCH, DELETE.
2. Oldja meg a nézet különböző útvonalait
POSTÁZÁS / áru
PUT /áruk/(goodId)
Szerezze be a /users/(felhasználói azonosító)/információt
és egyéb tetszőlegesen hosszú láncok.
Figyelem: ez a cikk nem a REST API alapjairól szól
Feltételezem, hogy már ismeri a REST megközelítést, és megérti, hogyan működik. Ha nem, akkor sok nagyszerű cikk található az interneten a REST alapjairól - nem szeretném megismételni őket, az az ötletem, hogy megmutassam, hogyan kell a REST-tel dolgozni a gyakorlatban.
Milyen funkciókat fogunk támogatni?
Vegyünk két entitást – a termékeket és a felhasználókat.
A termékek esetében a következő lehetőségek állnak rendelkezésre:
- 1. GET /árut/(goodId)— Információszerzés a termékről
- 2. POSTÁZÁS / áru— Új termék hozzáadása
- 3. PUT /áruk/(goodId)— Termék szerkesztése
- 4. PATCH /áruk/(goodId)— Néhány termékparaméter szerkesztése
- 5. TÖRLÉS /áruk/(goodId)— Termék eltávolítása
A felhasználók számára a változatosság kedvéért vegyünk több lehetőséget a GET-tel
- 1. GET /felhasználók/(felhasználói azonosító)— Teljes információ a felhasználóról
- 2. Szerezze be a /users/(felhasználói azonosító)/információt— Csak általános információk a felhasználóról
- 3. Szerezze be a /felhasználók/(felhasználói azonosító)/rendeléseket— Felhasználói rendelések listája
Hogyan működik ez a natív PHP-vel?
Az első dolgunk az, hogy beállítjuk a .htaccess fájlt, hogy minden kérés átirányuljon az index.php fájlba. Ő fog adatkinyeréssel foglalkozni.
Másodszor döntsük el, milyen adatokra van szükségünk, és írjuk meg a kódot, hogy megkapjuk – az index.php-ben.
3 típusú adatra vagyunk kíváncsiak:
- 1. Kérési mód (GET, POST, PUT, PATCH vagy DELETE)
- 2. Adatok az URL-ből, például user/(userId)/info – mind a 3 paraméter szükséges
- 3. Adatok a kérelmező szervtől
Harmadszor pedig olyan kódot írunk, amely futtatja a szükséges funkciókat. A funkciók fájlokra vannak osztva, minden Feng Shui, új elérési utak és módszerek hozzáadása a RESTful szolgáltatáshoz nagyon egyszerű lesz. .htaccess
Hozzon létre egy .htaccess fájlt a projekt gyökérjében
RewriteEngine On RewriteCond %(REQUEST_FILENAME) !-f RewriteRule ^(.+)$ index.php?q=$1
Ezekkel a titokzatos sorokkal ezt parancsoljuk:
1 - küldje el az összes kérést az index.php királyfájlba
2 - tegye elérhetővé az URL-ben található karakterláncot az index.php fájlban a q get paraméterben. Vagyis egy URL-ből származó adatok, mint például /users/(felhasználói azonosító)/info$_GET["q"]-tól kapjuk.
index.php
Nézzük soronként az index.php-t. Először is nézzük meg a kérés módszerét.
// Adja meg a kérés metódusát $method = $_SERVER["REQUEST_METHOD"];
Ezután az adatokat a kérelmező szervtől
// Adatok lekérése a kérés törzséből $formData = getFormData($method);
A GET és a POST esetében könnyen lekérhető az adatok a megfelelő $_GET és $_POST tömbökből. De más módszerekhez kissé perverznek kell lenni. A kódot a streamből húzzák le php://input, a kód könnyen guglizható, most írtam egy általános wrappert - a getFormData($method) függvényt
// Adatok lekérése a kérés törzsfüggvényéből getFormData($method) ( // GET vagy POST: visszaadja az adatokat úgy, ahogy van if ($method === "GET") return $_GET; if ($method === "POST" ) return $_POST; // PUT, PATCH vagy DELETE $data = array(); $exploded = explode("&", file_get_contents("php://input")); foreach($exploded mint $pár) ( $ item = explode("=", $pair); if (count($item) == 2) ( $data = urldecode($item); ) ) return $data; )
Vagyis úgy kaptuk meg a szükséges adatokat, hogy az összes részletet elrejtettük a getFormData-ban – hát remek. Térjünk át a legérdekesebb részre - az útválasztásra.
// Az url elemzése $url = (isset($_GET["q"])) ? $_GET["q"] : ""; $url = rtrim($url, "/"); $urls = explode("/", $url);
Fentebb megtudtuk, hogy a .htaccess az URL-ből származó paramétereket a $_GET tömb q-paraméterébe helyezi. Vagyis a $_GET["q"] valami ilyesmit fog tartalmazni: felhasználók/10. Függetlenül attól, hogy melyik módszert használjuk a kérés végrehajtására.
A explode("/", $url) ezt a karakterláncot tömbbé alakítja számunkra, amivel már tudunk dolgozni. Így készítsen olyan hosszú lekérdezési láncokat, amennyit csak akar, például
GET /goods/page/2/limit/10/sort/price_asc
És biztos lehetsz benne, kapsz egy tömböt
$urls = array("áruk", "oldal", "2", "limit", "10", "rendezés", "ár növekvő");
Most már minden adatunk megvan, tennünk kell vele valami hasznosat. És mindössze 4 sornyi kód megteszi
// Az útválasztó és az url adatok meghatározása $router = $urls; $urlData = array_slice($urls, 1); // Csatlakoztassa az útválasztó fájlt, és futtassa az include_once "routers/" fő függvényt. $router. ".php"; route($method, $urlData, $formData);
Érted? Létrehozunk egy útválasztó mappát, amelyben olyan fájlokat helyezünk el, amelyek egy entitást kezelnek: termékeket vagy felhasználókat. Ugyanakkor egyetértünk abban, hogy a fájlok neve egybeesik az urlData első paraméterével – ez lesz a router, $router. És ezt az útválasztót el kell távolítani az urlData-ból; már nincs rá szükségünk, és csak a szükséges fájl csatlakoztatására szolgál. array_slice($urls, 1)és megadja nekünk a tömb összes elemét, kivéve az elsőt.
Most már csak csatlakoztatni kell a kívánt útválasztó fájlt, és három paraméterrel futtatni a route funkciót. Mi ez a funkcióútvonal? Egyezzünk meg abban, hogy minden router fájlban lesz definiálva egy függvény, amely a bemeneti paraméterek alapján meghatározza, hogy a felhasználó milyen műveletet kezdeményezett és végrehajtja a szükséges kódot. Most ez világosabb lesz. Vegyük fontolóra az első kérést - adatszerzést egy termékről.
GET /árut/(goodId)
Routers/goods.php fájl
// Router függvény route($method, $urlData, $formData) ( // Információk lekérése egy termékről // GET /goods/(goodId) if ($method === "GET" && count($urlData) == = 1) ( // Szerezze be a termékazonosítót $goodId = $urlData; // Húzza ki a terméket az adatbázisból... // A válasz kiírása az ügyfélnek echo json_encode(array("method" => "GET", "id" => $goodId, "good" => "phone", "price" => 10000)); return; ) // Hibafejléc visszaadása("HTTP/1.0 400 Bad Request"); echo json_encode(array ("hiba" => "Rossz kérés" ")); )
A fájl tartalma egyetlen nagy útvonalfüggvény, amely az átadott paraméterek függvényében elvégzi a szükséges műveleteket. Ha a GET metódus és 1 paraméter (goodId) átadásra kerül az urlData-nak, akkor ez egy termékre vonatkozó adatok beszerzésére irányuló kérés.
Figyelem: a példa nagyon leegyszerűsített
A való életben természetesen emellett ellenőriznie kell a bemeneti paramétereket, például, hogy a goodId egy szám. A kód ideírása helyett valószínűleg megadja a szükséges osztályt. És a termék fogadásához hozzon létre egy objektumot ebből az osztályból, és hívjon meg rajta valamilyen metódust.
Vagy esetleg átviheti a vezérlést valamilyen vezérlőre, amely már gondoskodik a szükséges modellek inicializálásáról. Sok lehetőség van, csak a kód általános felépítését vesszük figyelembe.
Az ügyfélnek adott válaszban megjelenítjük a szükséges adatokat: a termék nevét és árát. A termékazonosító és a módszer teljesen opcionális egy valós alkalmazásban. Csak azért mutatjuk meg őket, hogy megbizonyosodjunk arról, hogy a megfelelő metódust hívjuk meg a megfelelő paraméterekkel.
Próbáljuk meg egy példával: nyissa meg a böngésző konzolját, és futtassa a kódot
$.ajax((url: "/examples/rest/goods/10", metódus: "GET", dataType: "json", siker: function(response)(console.log("válasz:", válasz))) )
A kód kérést küld annak a kiszolgálónak, ahol hasonló alkalmazást telepítettem, és választ ad ki. Győződjön meg arról, hogy az Önt érdeklő útvonal megfelelő /áruk/10 tényleg működött. A Hálózat lapon ugyanezt a kérést láthatja.
És igen, a /examples/rest a webhelyhez vezető tesztalkalmazásunk gyökérútvonala
Ha jobban megszokta a curl használatát a konzolban, akkor futtassa ezt a terminálban - a válasz ugyanaz lesz, és még a szerver fejléceivel is.
Curl -X GET https://site/examples/rest/goods/10 -i
![](https://i0.wp.com/webdevkin.ru/media/img/rest/example_curl.jpg)
A függvény végére a következő kódot írtuk.
// Hibafejléc visszaadása("HTTP/1.0 400 Bad Request"); echo json_encode(array("hiba" => "Rossz kérés"));
Ez azt jelenti, hogy ha hibáztunk a paraméterekkel, vagy nincs megadva a kért útvonal, akkor a 400 Bad Request hibát adjuk vissza a kliensnek. Például adjon hozzá ehhez hasonlót az URL-hez: áruk/10/másik_paramés látni fogsz egy hibát a konzolban és egy 400-as választ - a ferde kérés nem ment át.
Szerverválasz http kódokkal
Nem fogunk bajlódni a különböző kódok kiadásával, bár ezt a REST szerint érdemes megtenni. Sok ügyfélhiba van. Még a mi egyszerű esetünkben is a 405-ös helyénvaló helytelenül átadott metódus esetén. Nem akarom szándékosan bonyolítani a dolgokat.
Siker esetén a szerverünk mindig 200 OK-t ad vissza. Szerencsére az erőforrás létrehozásakor a 201 Created értéket kell megadnia. De ismételten, az egyszerűsítés érdekében ezeket a finomságokat elvetjük, de egy valódi projektben könnyedén megvalósíthatja őket.
Őszintén szólva, a cikknek vége. Azt hiszem, már érted a megközelítést, hogyan történik az összes útvonal feloldása, az adatok lekérése, a tesztelés, az új kérések hozzáadása stb. De a kép teljessé tétele érdekében megadom a fennmaradó 7 lekérdezés megvalósítását, amelyet a cikk elején vázoltunk. Útközben teszek néhány érdekes megjegyzést, és a végén közzéteszek egy archívumot a forráskóddal.
POSTÁZÁS / áru
Új termék hozzáadása
// Új termék hozzáadása // POST /goods if ($method === "POST" && empty($urlData)) ( // Termék hozzáadása az adatbázishoz... // Válasz kiírása az ügyfélnek echo json_encode (array("method" => "POST", "id" => rand(1, 100), "formData" => $formData)); return; )
Az urlData most üres, de a formData használatban van – egyszerűen megjelenítjük az ügyfélnek.
Hogyan kell "jól" csinálni?
A REST kánonjai szerint a bejegyzéskérésben csak a létrehozott entitás azonosítóját vagy azt az url-t kell visszaadnia, amellyel ez az entitás elérhető. Vagyis a válasz vagy csak egy szám lesz - (goodId), vagy /goods/(goodId).
Miért írtam "helyesen" idézőjelbe? Igen, mert a REST nem szigorú szabályok halmaza, hanem ajánlások. És a megvalósítás módja az Ön preferenciáitól vagy egy adott projekttel kapcsolatos már elfogadott megállapodásaitól függ.
Ne feledje, hogy egy másik programozó, aki olvassa a kódot, és ismeri a REST megközelítést, a post-kérésre adott válaszban várja a létrehozott objektum azonosítóját vagy egy URL-t, ahonnan az objektumra vonatkozó adatok lekérhetők get kéréssel.
Tesztelés a konzolról
$.ajax((url: "/examples/rest/goods/", metódus: "POST", adat: (jó: "notebook", ár: 20000), dataType: "json", siker: function(response)( console.log("válasz:", válasz))))
Curl -X POST https://site/examples/rest/goods/ --data "good=notebook&price=20000" -i
PUT /áruk/(goodId)
Termék szerkesztése
// Az összes termékadat frissítése // PUT /goods/(goodId) if ($method === "PUT" && count($urlData) === 1) ( // A termékazonosító lekérése $goodId = $urlData; / / Frissítse az összes termékmezőt az adatbázisban... // A válasz kiírása az ügyfélnek echo json_encode(array("method" => "PUT", "id" => $goodId, "formData" => $formData)) ; Visszatérés; )
Itt már minden adatot a legteljesebb mértékben felhasználtak. A termékazonosító kihúzásra kerül az urlData-ból, a tulajdonságok pedig a formData-ból.
Tesztelés a konzolról
$.ajax((url: "/examples/rest/goods/15", metódus: "PUT", adat: (jó: "notebook", ár: 20000), dataType: "json", siker: function(response)) (console.log("válasz:", válasz))))
Curl -X PUT https://site/examples/rest/goods/15 --data "good=notebook&price=20000" -i
PATCH /áruk/(goodId)
Részleges termékfrissítés
// Termékadatok részleges frissítése // PATCH /goods/(goodId) if ($method === "PATCH" && count($urlData) === 1) ( // A termékazonosító lekérése $goodId = $urlData; // Csak a megadott termékmezőket frissítjük az adatbázisban... // A válasz kiírása az ügyfélnek echo json_encode(array("method" => "PATCH", "id" => $goodId, "formData" => $formData)); vissza;)
Tesztelés a konzolról
$.ajax((url: "/examples/rest/goods/15", metódus: "PATCH", adat: (ár: 25000), dataType: "json", siker: function(response)(console.log(" válasz:", válasz))))
Curl -X PATCH https://site/examples/rest/goods/15 --data "price=25000" -i
Miért ez az egész mutogatás a PUT és a PATCH segítségével?
Nem elég egy PUT? Nem ugyanazt a műveletet hajtják végre – frissítik az objektum adatait?
Így van – külsőleg a cselekvés egy. A különbség a továbbított adatokban van.
A PUT ezt feltételezi Minden objektum mezők, és csak PATCH – csak megváltozott. A kérelmező szervben elküldöttek. Felhívjuk figyelmét, hogy az előző PUT-ban a termék nevét és az árat is átadtuk. A PATCH-ban pedig csak az ár. Vagyis csak megváltozott adatokat küldtünk a szerverre.
Hogy szüksége van-e PATCH-re - döntse el Ön. De ne feledje a fent említett kódolvasó programozót.
TÖRLÉS /áruk/(goodId)
Termék eltávolítása
// Termék törlése // TÖRLÉS /goods/(goodId) if ($method === "DELETE" && count($urlData) === 1) ( // A termékazonosító lekérése $goodId = $urlData; // Törölje a terméket az adatbázisból... // Válasz kiírása az ügyfélnek echo json_encode(array("method" => "DELETE", "id" => $goodId)); return; )
Tesztelés a konzolról
$.ajax((url: "/examples/rest/goods/20", metódus: "DELETE", dataType: "json", siker: function(response)(console.log("válasz:", válasz))) )
Curl -X TÖRLÉS https://site/examples/rest/goods/20 -i
A DELETE kéréssel minden világos. Most nézzük meg a felhasználókkal való munkát - a felhasználók útválasztóját és ennek megfelelően a users.php fájlt
GET /felhasználók/(felhasználói azonosító)
Az összes felhasználói adat lekérése. Ha a GET kérés olyan /felhasználók/(felhasználói azonosító), akkor a felhasználóra vonatkozó összes információt visszaküldjük, ha további megadjuk /info vagy /rendel, akkor ennek megfelelően csak általános információk vagy rendelési lista.
// Router függvény route($method, $urlData, $formData) ( // Minden információ lekérése a felhasználóról // GET /users/(userId) if ($method === "GET" && count($urlData) = = = 1) ( // A termékazonosító lekérése $userId = $urlData; // A felhasználó összes adatának kinyerése az adatbázisból... // Válasz kiírása az ügyfélnek echo json_encode(array("method" => " GET", "id" = > $userId, "info" => array("email" => " [e-mail védett]", "name" => "Webdevkin"), "orders" => array(array("orderId" => 5, "summa" => 2000, "orderDate" => "01/12/2017"), tömb (" orderId" => 8, "summa" => 5000, "orderDate" => "02/03/2017")))); return; ) // A hiba fejlécének visszaadása("HTTP/1.0 400 Bad Request" ); echo json_encode( array("error" => "Rossz kérés")); )
Tesztelés a konzolról
$.ajax((url: "/examples/rest/users/5", metódus: "GET", dataType: "json", siker: function(response)(console.log("válasz:", válasz))) )
Curl -X GET https://site/examples/rest/users/5 -i
Szerezze be a /users/(felhasználói azonosító)/információt
Általános információk a felhasználóról
// Általános információk beszerzése a felhasználóról // GET /users/(userId)/info if ($method === "GET" && count($urlData) === 2 && $urlData === "info") ( / / A termék azonosítójának lekérése $userId = $urlData; // Általános adatok kinyerése a felhasználóról az adatbázisból... // Válasz kiírása az ügyfélnek echo json_encode(array("method" => "GET", "id" " => $userId, " info" => array("email" => " [e-mail védett]", "name" => "Webdevkin"))); return; )
Tesztelés a konzolról
$.ajax((url: "/examples/rest/users/5/info", metódus: "GET", dataType: "json", siker: function(response)(console.log("response:", válasz) )))
Curl -X GET https://site/examples/rest/users/5/info -i
Szerezze be a /felhasználók/(felhasználói azonosító)/rendeléseket
A felhasználói rendelések listájának lekérése
// Felhasználói rendelések fogadása // GET /users/(userId)/orders if ($method === "GET" && count($urlData) === 2 && $urlData === "rendelések") ( // Get termékazonosító $userId = $urlData; // Adatok kinyerése a felhasználó rendeléseiről az adatbázisból... // Válasz kiírása az ügyfélnek echo json_encode(array("method" => "GET", "id" => $ userId, "orders" => array(array("orderId" => 5, "summa" => 2000, "orderDate" => "01/12/2017"), array("orderId" => 8, "summa " => 5000, "orderDate " => "02/03/2017")))); return; )
Tesztelés a konzolról
$.ajax((url: "/examples/rest/users/5/orders", metódus: "GET", dataType: "json", siker: function(response)(console.log("válasz:", válasz)) )))
Curl -X GET https://site/examples/rest/users/5/orders -i
Eredmények és források
Források cikkpéldákból -
Mint látható, a REST API támogatásának megszervezése natív php-ben nem volt olyan nehéz, és teljesen legális módon. A legfontosabb az útvonalak és a nem szabványos PHP-módszerek PUT, PATCH és DELETE támogatása.
A támogatást megvalósító fő kód az index.php 3 tucat sorába illeszkedik. A többi csak egy heveder, amit tetszőleges módon meg lehet valósítani. Azt javasoltam, hogy ezt plug-in router fájlok formájában tegye, amelyek neve megegyezik a projekt entitásaival. De használhatja a fantáziáját, és találhat érdekesebb megoldást.