A meggondolatlanság az, amikor a szenvedély megakadályozza a gondolkodást.

Vicces aforizmák

Meggondolatlanság mint személyiségminőség – az a tendencia, hogy ne gondolja végig tettei következményeit; nem kellően megfontoltan, ostobán, meggondolatlanul viselkedik; képtelenség mélyen és alaposan gondolkodni, valamit helyesen megérteni.

Egy kemény télen a családnak kifogyott a tűzifája. Az apa kiment a külterületre, talált egy elhalt fát, és kivágta. Tavasszal látta, hogy egy általa kivágott fa tuskójából hajtások emelkedtek ki. – Biztos voltam benne – mondta az apa –, hogy ez a fa meghalt. Olyan hideg volt akkor, hogy a fagy megrepedt, letört és a földre hullott az ágai, mintha egy csepp élet sem maradt volna a gyökereiben. Most látom, hogy ebben a csomagtartóban még mindig csillogott az élet.

És a fiához fordulva így szólt: „Emlékezz erre a leckére!” Soha ne vágj ki fát télen. Soha ne dönts elgondolkodva, rosszkor, vagy rossz lelkiállapotban. Várjon. Légy türelmes, a rossz idők elmúlnak. Ne feledje, hogy visszatér a tavasz.

A meggondolatlanság a hülyeség és az ostobaság lánya. Ez a józan ész jelenlétének hiánya. Az átgondoltság figyelmetlenségről és az emberek iránti tiszteletlenségről beszél. Akit szeretünk és tisztelünk, törődünk vele, aggódunk és aggódunk, ezért elképzeljük az összes árnyalatot, minden apróságot, ami árthat neki, vagy megzavarhatja az életét. Akit nem tisztelünk és nem becsülünk, azzal meggondolatlanságot mutatunk.

A meggondolatlanság az idiotizmus, a hülyeség, a hülyeség és az agyatlanság szövetségese.

A srác kíváncsiságot színlelve megkérdezi a csinos légiutas-kísérőt: - Lány, mit jelent a TU-154-2B? - Maga nem jut eszébe? Nos, a TU azt jelenti, hogy a gépet Tupolev tervező készítette, 150 az utastérben lévő ülőhelyek száma, 4 pedig a személyzet létszáma. - És 2B? - Nos, láthatóan a meggondolatlanság az erős oldalad! Ők vagyunk Marinka és én.

A meggondolatlanság az, amikor az ember anélkül él, hogy megértené, hogy minden cselekedetéért felelnie kell. Fel sem merül benne a gondolat, hogy tetteinek következményei, mint egy bumeráng, a karma törvénye szerint visszatérnek hozzá. A jó és a rossz is biztosan visszatér.

A meggondolatlanság bevált módja annak, hogy kellemetlenséget okozzon a körülötte lévőknek.

V. Schlachter azt mondja, hogy a meggondolatlanságot nagyon gyakran ostobaságként fogjuk fel. Vagy akár állatiasság miatt. Például a sofőr bement egy forgalmas kereszteződésbe. Mindenkinek blokkolta a forgalmat, aki a mellékúton állt és arra várt, hogy a jelzőlámpa zöldre váltson. De valószínűleg nem dühből tette, és nem azért, mert ostoba, aljas vadállat volt. Egyszerűen nem zavarta szegény kis fejét, hogy végiggondolja a következményeket. Most már mindenki dudál rá (gyakrabban rá!), és az informális szókincs leghízelgőbb jelzőinek nevezi.

„Hagyj sok vizet a macskának, három napig elmegyek” – mondja anya. A fiam pedig egy csomag másfél literes műanyag palackot hoz a macskának. Igyál, macska! Az, hogy egy macska nem tud kinyitni egy üveget és inni belőle, a fiának fel sem tűnik. Több vizet kértek – hozott többet, mi volt a probléma? Ezt nem hülyeségből csinálta. És nem a szerencsétlen macska iránti gyűlöletből. A meggondolatlanságból!

Az ostobaság sokkal korábban jut eszünkbe, mint a józan ész. Mindig elhamarkodott ítéletek kísérik.

A tanár mindig óva intette diákjait a meggondolatlanságtól, vagyis az emberekről szóló elhamarkodott ítéletektől és még inkább az elhamarkodott tanácsoktól. Ezt mondta: „Amíg a szívedben és az elmédben úgy nem érzed, hogy a probléma lényegéig hatoltál, és a legkisebb kétség sem hagy el, hogy helyesen cselekszel, addig a legjobb cselekedeted legyen a tétlenség, és a legbiztonságosabb. szó legyen csend.” . Ellenkező esetben tanácsai arra kényszerítik az embereket, hogy megismételjék a meggondolatlanságban szenvedő paraszt sorsát.

Mi történt vele? - kérdezték a diákok. - Dombon álló házát minden oldalról heves szelek fújták. A paraszt meggondolatlanságból naivan azt hitte, hogy a szél azért támad, mert a házat körülvevő magas fák egyik oldalról a másikra inognak. Egy nap feldühödött, és kivágta az összes fát. Ennek eredményeként a ház, miután elvesztette utolsó védelmét, még hidegebb és szelesebb lett.

A meggondolatlanság azoknak az embereknek a csapása, akik csak a saját érdekeikre gondolnak.

A zászlós megkérdezi a katonát: - Mit kell tenni atomrobbanás esetén? „Fekülj le a lábaddal a vaku felé, és takard el magad a kezével” – válaszolja. - Rossz. Géppuskával előre kell nyújtani a karjait, hogy az olvadt fém ne csöpögjön a kormány által kiadott csizmára.

A meggondolatlanság a bizonytalanság környezetébe taszítja az embert. Ha valaki nem tudja elképzelni, mi fog történni néhány perc múlva, az azt jelenti, hogy a teljes bizonytalanság állapotában él.

A férjem visszatért egy üzleti útról. Senki nincs otthon. Úgy döntöttem elbújok, hogy meglepjem a feleségemet. Hirtelen meglátja, hogy a felesége egy férfival együtt belép a lakásba. Bemennek a hálószobába. Az ajtó becsukódik, a férj a kulcslyukhoz fut. És látja, hogy a felesége csókolja ezt az embert, leveszi minden ruháját, mindketten az ágyra vetik magukat, ő leveti a ruháit, és a bugyiját a bejárati ajtó felé hajítja, ahol a férj rejtőzik, és ők meg lógnak. a fogantyút, zárja be a zárat a férjhez és a teljes áttekintést. És akkor a férj bosszúsan gondolja: „Nos, ez egy elpazarolt nap, megint teljes a bizonytalanság!”

Péter Kovaljov

1 éve | 9,8K

A programozásban nagyon gyakori feladat az, amikor HTTP-n vagy HTTPS-en keresztül kell elérni egy másik webhelyet. Ebben a cikkben a nyelvhasználat egy egyszerű módját tekintjük át PHP programozás végezze el ezt a feladatot.

Miért érhet el egy másik webhelyet PHP-vel HTTP-n vagy HTTPS-n keresztül?

Több oka is lehet, például a webhelyén a funkcionalitás egy része felelős azért, hogy új termékeket vagy filmkatalógusokat adjon a webhelyéhez.

Szinte minden nap új filmek kerülnek a képernyőre, és jobb ezt a folyamatot automatizálni, hogy egy robot végezze el, aki ingyen megteszi.

Az árukkal is ugyanez a helyzet - webáruházának lehetnek olyan partnerei, akik el szeretnék helyezni áruikat az Ön weboldalán, és minden egyes termékeladásból a partnerek adják a bevételük egy részét. Ha egy partnernek több ezer terméke van, és az adatbázis folyamatosan frissül, akkor a termékek oldalra történő felvételének folyamatát is automatizálni kell a PHP programozási nyelv segítségével.

Példa egy másik webhely elérésére PHP használatával

Abban egyszerű példa, akkor a file_get_contents() nevű szabványos PHP függvényt fogjuk használni.

A VK szerver válaszaként a következő információkat fogja látni:

( - válasz: [ - ( - id: 210700286, - keresztnév: "Lindsey", - vezetéknév: "Stirling", - bdate: "1986.9.21" - ) - ] )

ahol megkaptuk a 210700286 azonosítójú felhasználó keresztnevét, vezetéknevét és születési idejét.

Most hogyan tudnánk PHP használatával megszerezni ezeket az információkat, és tömbbé alakítani a kényelmes további munka érdekében?

A PHP programozási nyelv és a file_get_contents() függvény használatával ez nagyon egyszerű!

$user_id- ez az a változó, amelybe beírja a VK felhasználói azonosítót,

$info- ebben a változóban tároljuk a VK.COM webhely API-jához való hozzáférés eredményét

Ezen információkkal egy tömb birtokában valamilyen célból megjelenítheti az Önt érdeklő felhasználókat a weboldalán, illetve a segítségével is szépen megtervezheti ezen információk megjelenítését a weboldalán.

Következtetés

Amint látja, a PHP-vel nagyon könnyen kérhet HTTP és HTTPS oldalakat, és a PHP programozási nyelvnek csak egy funkcióját néztük meg, amellyel adatokat kérhet le egy külső webhelyről.

A következő cikkekben egy másik érdekes, de annál erősebb funkciót nézünk meg, amelyben beállíthatja Extra lehetőségek mint a böngésző, operációs rendszerés mások, a külső webhelyekkel való kecsesebb munka érdekében.

Először is javítani fogjuk a regisztrációs oldalt egy avatar feltöltésének lehetőségével. A forrásképnek jpg, gif vagy png formátumúnak kell lennie. Ezenkívül nem lehet több 2 MB-nál. Ne aggódjon, miután a szkript tömörítette, az avatar mérete körülbelül 3 kb és jpg formátum lesz. Nyissa meg az oldalt reg.phpés add hozzá a címkéhez < forma> vonal enctype="multipart/form-data", mint a példában:


Bejegyzés










Most spóroljunk reg.php

2.Ezután létre kell hoznia egy másik mezőt a táblázatban felhasználókat. Menjünk-hoz phpmyadmin, válassza ki a kívánt adatbázist és táblát.


Az összes értéket az ábrán látható módon állítjuk be:

Az avatar elérési útja ebben a mezőben kerül rögzítésre, és egy külön mappába kerül elmentésre, nevezzük „avataroknak”. A mappa ugyanabban a könyvtárban lesz, mint a többi parancsfájl.

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:

//töröl extra terek
$bejelentkezés = trim($login);

// új hozzáadása ********************************************

//ellenőrizze a bejelentkezési név és jelszó hosszát
if (strlen($login)< 3 or strlen($login) > 15) {
exit("A bejelentkezésnek legalább 3 és legfeljebb 15 karakterből kell állnia.");
}
if (strlen($jelszó)< 3 or strlen($password) > 15) {
exit("A jelszónak legalább 3 karakterből kell állnia, de legfeljebb 15 karakterből kell állnia.");
}

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
}

If(preg_match("/[.](JPG)|(jpg)|(jpeg)|(JPEG)$/", $fájlnév)) (
$im = imagecreatefromjpeg($elérési_út_90_könyvtárba.$fájlnév); //ha az eredeti benne volt jpg formátumban, akkor létrehozunk egy képet ugyanabban a formátumban. Szükséges a későbbi tömörítéshez
}
//NÉGYEDETES KÉP LÉTREHOZÁSA ÉS AZ UTÁN KÖVETKEZŐ TÖMÖRÍTÉSE A www.codenet.ru OLDALRÓL
// Hozzon létre egy 90x90-es négyzetet
// dest - az eredményül kapott kép
// w - képszélesség
// arány - arányossági együttható
$w = 90; // négyzet 90x90. Más méretben is szállítható.
// létrehozni eredeti kép alapján
// forrás fájlés határozza meg a méreteit
$w_src = képekx($im); //számolja ki a szélességet
$h_src = imagesy($im); //számítsuk ki a kép magasságát
// hozzon létre egy üres négyzet alakú képet
// a truecolor fontos!, különben 8 bites eredményt kapunk
$dest = imagecreatetruecolor($w,$w);
// vágja ki a négyzet közepét x mentén, ha a fénykép vízszintes
if ($w_src>$h_src)
imagecopyresampled($dest, $im, 0, 0,
round((max($w_src,$h_src)-min($w_src,$h_src))/2),
0, $w, $w, min($w_src,$h_src), min($w_src,$h_src));
// vágja ki a négyzet alakú felsőt y mentén,
// ha a fénykép függőleges (bár használhatod a középsőt is)
if ($w_src<$h_src)
imagecopyresampled($dest, $im, 0, 0, 0, 0, $w, $w,
min($w_src,$h_src), min($w_src,$h_src));
// A négyzet alakú kép méretezése kivágás nélkül történik
if ($w_src==$h_src)
imagecopyresampled($dest, $im, 0, 0, 0, 0, $w, $w, $w_src, $w_src);
$dátum=idő(); //az aktuális idő kiszámítása.
imagejpeg($dest, $elérési_út_90_könyvtárba.$dátum..jpg");//mentse a képet jpg formátumban a kívánt mappába, a név a következő lesz aktuális idő. Azért készült, hogy az avatarok ne legyenek azonos elnevezéssel.
//miért jpg? Nagyon kevés helyet foglal + a GIF kép animációja, ami elvonja a felhasználó figyelmét, megsemmisül. Nem túl kellemes olvasni a megjegyzését, amikor észrevesz valami mozgást a szemed sarkából.
$avatar = $elérési_út_a_90_könyvtárhoz.$dátum..jpg";//az avatar elérési útját helyezze be a változóba.
$delfull = $elérési_út_90_könyvtárhoz.$fájlnév;
unlink ($delfull);//törölje az eredeti feltöltött képet, már nincs rá szükségünk. A feladat egy miniatűr beszerzése volt.
}
más
{
//formátum eltérés esetén adj ki egy megfelelő üzenetet
exit("Az avatarnak a következő formátumban kell lennie JPG, GIF vagy PNG");
}
//a betöltési folyamat vége és a $avatar változóhoz hozzárendeljük a betöltött ava címét
}



// új hozzáadva *************************************************** **
// Következik minden a cikk első részéből, de módosítani kell az adatbázis-lekérdezést.
//csatlakozás az adatbázishoz
// ellenőrizze, hogy létezik-e azonos bejelentkezési névvel rendelkező felhasználó
$result = mysql_query("SELECT id FROM user WHERE login="$bejelentkezés"",$db);
if (!üres($myrow["id"])) (
exit("Sajnáljuk, a megadott bejelentkezési név már regisztrálva van. Adjon meg egy másik bejelentkezési nevet.");
}
// ha ez nem így van, akkor mentse el az adatokat
$result2 = mysql_query("INSERT INTO user (bejelentkezés,jelszó,avatar) VALUES("$bejelentkezés","$jelszó","$avatar")");
// Ellenőrizze, hogy vannak-e hibák
if ($eredmény2=="IGAZ")
{
echo "Sikeres regisztráció! Most már beléphet az oldalra. Kezdőlap";
}
más(
echo "Hiba! Ön nem regisztrált.";
}
?>

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:


ip - IP-cím.
dátum - az ezzel az ip-vel rendelkező felhasználó sikertelen bejelentkezésének dátuma az elmúlt 15 percben. col – az ezzel az ip-vel rendelkező felhasználó hibáinak száma az elmúlt 15 percben.
Nagy! Kész, most változtassuk meg a bejelentkezési és jelszó-ellenőrző fájlt, mert most a jelszavunk titkosítva van. Nyissa meg a testreg.php-t, és töröljön mindent a bejelentkezési névből és a jelszóból való szóközök eltávolításán kívül. Ezután a következő kódot adjuk hozzá:

//felesleges szóközök eltávolítása
$bejelentkezés = trim($login);
$jelszó = trim($jelszó);

// cserélje ki egy újra************************************************ *******
// csatlakozik az adatbázishoz
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
// mini-ellenőrzés a jelszó kiválasztásához
$ip=getenv("HTTP_X_FORWARDED_FOR");
if (üres($ip) || $ip=="ismeretlen") ( $ip=getenv("REMOTE_ADDR"); )//IP kibontása
mysql_query ("DELETE FROM oshibka WHERE UNIX_TIMESTAMP() - UNIX_TIMESTAMP(date) > 900");//törli azon felhasználók IP-címét, akik 15 perc után hibáztak a bejelentkezéskor.
$result = mysql_query("SELECT col FROM oshibka WHERE ip="$ip",$db); // lekéri az adatbázisból egy adott ip-vel rendelkező felhasználó sikertelen bejelentkezési kísérleteinek számát az elmúlt 15 során
$myrow = mysql_fetch_array($eredmény);
if ($myrow["col"] > 2) (
//ha kettőnél több hiba van, azaz három, akkor üzenetet adunk ki.
exit("Háromszor rosszul adta meg felhasználónevét vagy jelszavát. Kérjük, várjon 15 percet, mielőtt újra próbálkozna.");
}
$password = md5($password);//titkosítja a jelszót
$password = strrev($password);// a megbízhatóság érdekében adjon hozzá fordított értéket
$jelszó = $jelszó."b3p6f";
//felvehet néhány saját karaktert ízlése szerint, például a „b3p6f” beírásával. Ha ezt a jelszót nyers erővel feltörik ugyanazon az md5 szerveren, akkor nyilván semmi jó nem lesz belőle. De azt tanácsolom, hogy helyezzen más karaktereket, talán a sor elejére vagy a közepére.
//Ebben az esetben meg kell növelni a jelszó mező hosszát az adatbázisban. A titkosított jelszó sokkal nagyobb lehet.

$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
}

exit("Elnézést, a megadott felhasználónév vagy jelszó helytelen.");
}
más(
nbsp; //ha a jelszavak egyeznek, akkor munkamenetet indítunk a felhasználó számára! Gratulálhatsz neki, bejutott!
$_SESSION["jelszó"]=$myrow["jelszó"];
$_SESSION["bejelentkezés"]=$myrow["bejelentkezés"];
$_SESSION["id"]=$myrow["id"];//ezt az adatot nagyon gyakran használják, így a bejelentkezett felhasználó „magával viszi”

//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" ";//átirányítjuk a felhasználót a főoldalra, ahol értesítjük a sikeres bejelentkezésről
?>

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
}
?>


Kezdőlap


Kezdőlap

if (!isset($myrow["avatar"]) vagy $myrow["avatar"]=="") (
//ellenőrizze, hogy a felhasználói adatok kinyerésre kerültek-e az adatbázisból. Ha nem, akkor nincs bejelentkezve, vagy hibás a jelszó a munkamenetben. Megjelenítünk egy bejelentkezési ablakot. De nem fogjuk kitenni azoknak, akik bejönnek, már nincs rá szükségük.
nyomtatás<<


ITT;

If (isset($_COOKIE["login"])) //van a COOKIE-ban bejelentkezési változó. Így kell lennie, ha a felhasználó az „Emlékezz rám” jelölőnégyzetre kattintott az előző bejelentkezéskor
{
//ha igen, akkor írja be az értékét az űrlapba. Ebben az esetben a felhasználónak megjelenik, hogy a bejelentkezési adatait már megadta a kívánt oszlopban
echo " value="".$_COOKIE["bejelentkezés"]."">";
}

nyomtatás<<




ITT;

If (isset($_COOKIE["jelszó"]))// hogy van-e jelszóval rendelkező változó a COOKIE-ban. Így kell lennie, ha a felhasználó az „Emlékezz rám” jelölőnégyzetre kattintott az előző bejelentkezéskor
{
//ha igen, akkor írja be az értékét az űrlapba. Ebben az esetben a felhasználónak megjelenik, hogy a jelszava már be van írva a kívánt oszlopba
echo " value="".$_COOKIE["jelszó"]."">";
}

Nyomtatás<<



Emlékezz rám.






Regisztráció



Vendégként vagy bejelentkezve

ITT;
}
más
{
//ha a bejelentkezés sikeres, a felhasználónak minden alább látható a csillagok között.

nyomtatás<<
$_SESSION néven van bejelentkezve az oldalra (kilépés)


Ez a link csak regisztrált felhasználók számára érhető el

Az avatarod:




ITT;

//************************************************************************************
//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:

session_start();
if (üres($_SESSION["bejelentkezés"]) vagy üres($_SESSION["jelszó"]))
{
//ha nincs munkamenet bejelentkezési névvel és jelszóval, akkor ezt a fájlt egy be nem jelentkezett felhasználó érte el. Nem tartozik ide. Hibaüzenetet adunk ki, és leállítjuk a szkriptet
exit ("Ezt az oldalt csak regisztrált felhasználók férhetnek hozzá. Ha regisztrált, akkor jelentkezzen be az oldalra a felhasználónevével és jelszavával
Kezdőlap");
}

unset($_SESSION["jelszó"]);
unset($_SESSION["bejelentkezés"]);
unset($_SESSION["id"]);// megsemmisíti a változókat a munkamenetekben
kijárat(" ");
// elküldi a felhasználót a főoldalra.
?>

Rendben, most mindennek vége! Élvezze egészsége érdekében! Sok szerencsét!

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.</p> <p>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.</p> <p>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.</p> <p><i>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.</i></p> <p>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.</p> <p>2. A kód bonyolítása</p> <p>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 "<?php", и дальше php-код не прерывается. Весь вывод делается через echo (print). Такой код, вроде бы, выглядит логичнее. Пример: страница подписки на новые ссылки в каталоге. В форме предлагается выбрать, на какие рубрики подписывается пользователь.</p><p> <?php include "db-connect.inc"; include "login-check.inc"; if (!$logged_in) { header ("Location: /register.php"); exit(); } include "page-header.inc"; print("<h2>class="club_article_small_caption">Hírek ügyfeleknek</h2> <table cellpadding=\"4\" cellspacing=\"0\" border=\"0\">"); $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(" <tr><td>($sor)"); if ($sor["hírdátum"] > dátum("Y-h-d", time() - 3600*24*14)) print(" <font color=\"#cc0000\">új!</font>"); print("</td><td> <a href=\"read.php?id={$row}\"><b>($sor)</b></a> <br>($sor)</td></tr>"); print("</table>"); tartalmazza a "page-footer.inc"; ?></p><p> <?php ... else while ($row = mysql_fetch_assoc($result)) print_announce($row); ... ?> </p><p>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.</p> <p>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:</p><p> <?php include "db-connect.inc"; include "login-check.inc"; if (!$logged_in) { header ("Location: /register.php"); exit(); } include "page-header.inc"; ?><h2 class="club_article_small_caption">Hírek az ügyfeleknek</h2> <table cellpadding="4" cellspacing="0" border="0"><?php $result = mysql_query("SELECT id, title, announce, news_date FROM news ORDER BY news_date DESC LIMIT 10"); if (mysql_error()) print(mysql_error()); else while ($row = mysql_fetch_assoc($result)) { ?><tr><td><?=$row["news_date"]?><?php if ($row["news_date"] >dátum("Y-h-d", time() - 3600*24*14)) ( ?> <font color="#cc0000">új!</font><?php } ?></td><td> "> <b><?=$row["title"]?></b> <br><?=$row["announce"]?></td></tr><?php } ?></table><p>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ó.</p> <p>3. Puccs</p> <p>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:</p><p>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)</p><p>Í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.)</p> <p>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.</p> <p>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 <i>sablon osztályok</i>, ami megkönnyítette az oldalsablonnal való kezelést és az abba beírandó adatokat.</p> <p>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.</p> <p>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.</p> <p>4. Miért rosszak a házi sablonórák?</p> <p>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.</p> <p>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.</p> <p>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.</p> <p>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 <a href="https://bar812.ru/hu/electronic-transformer-shema-podklyucheniya-podrobnaya-shema-vybora-elektronnogo-transformatora-i-kak-p.html">hosszú munka</a> garantáltan kapsz valamit, ami működik, de nem feltétlenül zseniális.</p> <p>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. <a href="https://bar812.ru/hu/obzor-lg-g4-android-flagman-s-osobym-podhodom-usb-modem-zte-mf823.html">speciális megközelítés</a>é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.</p> <p>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> <p>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.</p> <p>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.</p> <p>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.</p><p> <table border> <tr> <td colspan=2> <b>__globális__</b> <p>(rejtett és automatikusan hozzáadott)</td> </tr> <tr> <td><b>blokk1</b></td> <td> <table border> <tr> <td colspan=2><b>blokk2</b></td> </tr> <tr> <td><b>belső1</b></td> <td><b>belső2</b></td> </tr> </table> </td> </tr> </table> </p><p>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.</p> <p>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:</p><p> <?php $tpl->setVariable(...); $tpl->parseCurrentBlock(); ?></p><p>Ha tartalmat szeretne hozzáadni a block1-hez, a következőket kell tennie:</p><p> <?php $tpl->setCurrentBlock("belső1"); $tpl->setVariable(...); $tpl->parseCurrentBlock(); $tpl->setVariable(...); $tpl->parseCurrentBlock(); $tpl->parse("blokk1"); ?></p><p>Ennek eredményeként a szkript kódja így néz ki:</p><p> <?php $tpl = new HTML_Template_IT(); // загрузка шаблона или указание его через класс $tpl->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(); ?></p><p>A kód kényelmesebb és áttekinthetőbb, mint a FastTemplate-nél.</p> <p>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 <table>És</table>), amely csak akkor jelent meg az eredményben, ha az SQL lekérdezésben voltak sorok.</p> <p>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.</p> <p><i>Rövid áttekintés az XML elméletéről, és miért van rá szükség.</i></p> <p><i>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). <a href="https://bar812.ru/hu/kak-izmenit-razreshenie-tekstovogo-dokumenta-tipy-formatov-failov-kak.html">szöveges formátumok</a>, amely lehetővé teszi az adatok strukturálását.</i></p> <p>Magyarázat arról, hogy mi a szerkezet.</p><p> <eshop> <!-- категории товаров --> <category id="3"> <title>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 ""; ) ) // 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:

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

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.