Paprasta RESTful paslauga vietinėje PHP. $_SERVER – Informacija apie serverį ir vykdymo aplinką Ką turėtų turėti mūsų RESTful paslauga

Efektyvaus informacijos organizavimo, paieškos ir platinimo galimybės jau seniai domino kompiuterinių technologijų srities specialistus. Kadangi informaciją daugiausia sudaro tekstas, susidedantis iš raidinių ir skaitmeninių simbolių, informacijos paieškos ir apdorojimo priemonių pagal tekstą apibūdinančius šablonus kūrimas tapo rimtų teorinių tyrimų objektu.

Šablonų paieška leidžia ne tik rasti konkrečius teksto fragmentus, bet ir pakeisti juos kitais fragmentais. Vienas standartinių šablonų derinimo pavyzdžių yra komandos rasti/pakeisti teksto rengyklėse, pavyzdžiui, MS Word, Emacs ir mano mėgstamiausia rengyklė vi. Visi UNIX vartotojai yra susipažinę su tokiomis programomis kaip sed, awk ir grep; Šių programų galimybių turtingumą daugiausia lemia jų šablonų paieškos galimybės. Šablonų paieškos mechanizmai išsprendžia keturias pagrindines problemas:

• ieškoti eilučių, kurios tiksliai atitinka nurodytą šabloną;
• ieškant eilutės fragmentų, atitinkančių nurodytą šabloną;
• eilučių ir poeilių pakeitimas naudojant šabloną;
• ieškoti eilučių su nurodytu šablonu nesutampa.

Interneto atsiradimas sukūrė greitesnių ir efektyvesnių duomenų paieškos įrankių, leidžiančių vartotojams visame pasaulyje rasti reikiamą informaciją milijarduose tinklalapių, poreikį. Paieškos sistemos, internetinės finansinės paslaugos ir elektroninės prekybos svetainės būtų visiškai nenaudingos, jei nebūtų priemonių išanalizuoti didžiulius duomenų kiekius šiuose sektoriuose. Iš tiesų, styginių informacijos apdorojimo priemonės yra gyvybiškai svarbi beveik bet kurio sektoriaus, kuris vienaip ar kitaip susijęs su šiuolaikinėmis informacinėmis technologijomis, dalis. Šiame skyriuje pagrindinis dėmesys skiriamas eilučių apdorojimo programoms PHP. Apžvelgsime kai kurias standartines eilučių funkcijas (jų kalboje yra daugiau nei 60!), o pateikti apibrėžimai ir pavyzdžiai suteiks informacijos, reikalingos kuriant žiniatinklio programas. Tačiau prieš pereinant prie PHP specifikos, noriu supažindinti jus su pagrindiniu mechanizmu, leidžiančiu suderinti šablonus. Mes kalbame apie reguliarias išraiškas.

Reguliarūs reiškiniai

Reguliarios išraiškos yra visų šiuolaikinių raštų derinimo technologijų pagrindas. Reguliarioji išraiška yra paprastų ir paslaugų simbolių, apibūdinančių ieškomą tekstą, seka. Kartais reguliarūs posakiai yra paprasti ir aiškūs (pavyzdžiui, žodis šuo), tačiau dažnai juose yra specialių simbolių, kurie reguliariosios išraiškos sintaksėje turi ypatingą reikšmę, pvz.,<(?)>.*<\/.?>.

PHP yra dvi funkcijų šeimos, kurių kiekviena yra skirtingo tipo reguliarioji išraiška: POSIX arba Perl stiliaus. Kiekvienas reguliaraus posakio tipas turi savo sintaksę ir yra aptariamas atitinkamoje skyriaus dalyje. Šia tema parašyta daug vadovėlių, kuriuos galima rasti tiek internete, tiek knygynuose. Todėl pateiksiu tik pagrindinę informaciją apie kiekvieną tipą, o jei norite, daugiau informacijos galite rasti patys. Jei dar nesate susipažinę su įprastų posakių veikimu, būtinai perskaitykite trumpą įvadinę pamoką, kuri apima likusią šio skyriaus dalį. Ir jei gerai išmanote šią sritį, nedvejodami pereikite prie kito skyriaus.

Reguliaraus posakio sintaksė (POSIX)

POSIX reguliariųjų reiškinių struktūra šiek tiek primena tipinių matematinių išraiškų struktūrą – skirtingi elementai (operatoriai) derinami tarpusavyje, kad susidarytų sudėtingesnės išraiškos. Tačiau būtent elementų derinimo jausmas daro reguliariąsias išraiškas tokia galinga ir išraiškinga priemone. Galimybės neapsiriboja tiesioginio teksto (pvz., konkretaus žodžio ar skaičiaus) paieška; galite ieškoti eilučių su skirtinga semantika, bet panašia sintaksė, pavyzdžiui, visos failo HTML žymos.

Paprasčiausias reguliarusis posakis atitinka vieną pažodinį simbolį – pavyzdžiui, išraiška g atitinka tokias eilutes kaip g , derėtis ir krepšys. Išraiška, gaunama sujungiant kelis pažodinius simbolius, atitinka tas pačias taisykles – pavyzdžiui, seka gan atitinka bet kurią eilutę, kurioje yra tie simboliai (pavyzdžiui, grupė, organizuoti arba Reiganas).

Operatorius | (vertikali juosta) patikrina, ar viena iš kelių alternatyvų atitinka. Pavyzdžiui, reguliarioji išraiška php | zend patikrina, ar eilutėje nėra php arba zend.

Laužtiniai skliaustai

Įprastų posakių kontekste laužtiniai skliaustai () turi ypatingą reikšmę – jie reiškia „bet kurį skliausteliuose pateiktą simbolį“. Skirtingai nuo php reguliariosios išraiškos, kuri atitinka visas eilutes, kuriose yra php literalinis tekstas, išraiška atitinka bet kurią eilutę, kurioje yra simboliai p arba h. Lakštiniai skliaustai atlieka svarbų vaidmenį dirbant su reguliariosiomis išraiškomis, nes paieškos procesas dažnai apima užduotį rasti simbolius iš tam tikro intervalo. Toliau pateikiami kai kurie dažniausiai naudojami intervalai:

• -- atitinka bet kurį dešimtainį skaitmenį nuo 0 iki 9;
• -- atitinka bet kurią mažąją raidę nuo a iki z;
• -- atitinka bet kurią didžiąją raidę nuo A iki Z;
• -- atitinka bet kokias mažąsias arba didžiąsias raides nuo a iki z.

Žinoma, aukščiau išvardyti intervalai tik parodo bendrą principą. Pavyzdžiui, galite naudoti tarpus, kad pareikštumėte bet kurį dešimtainį skaitmenį nuo 0 iki 3, arba tarpus, kad pavaizduotumėte bet kokį mažąją raidę nuo b iki v. Trumpai tariant, intervalai nustatomi visiškai savavališkai.

Kvantifikatoriai

Yra speciali paslaugų simbolių klasė, nurodanti vieno simbolio ar konstrukcijos pakartojimų skaičių laužtiniuose skliaustuose. Šie specialieji simboliai (+, * ir (...)) vadinami kiekybiniai rodikliai. Jų veikimo principą lengviausia paaiškinti pavyzdžiais:

• p+ reiškia vieną ar daugiau p simbolių iš eilės;
• p* reiškia nulį ar daugiau p simbolių iš eilės;
• R? reiškia nulį arba vieną simbolį p;
• p(2) reiškia du p simbolius iš eilės;
• p(2,3) reiškia nuo dviejų iki trijų p simbolių iš eilės;
• p(2,) reiškia du ar daugiau p simbolių iš eilės.

Kiti paslaugų veikėjai

Paslaugos simboliai $ ir ^ atitinka ne simbolius, o tam tikras pozicijas eilutėje. Pavyzdžiui, išraiška p$ reiškia eilutę, kuri baigiasi simboliu p, o išraiška ^p reiškia eilutę, kuri prasideda simboliu p.

• Konstrukcija [^a-zA-Z] atitinka bet kurį simbolį neįtrauktos nurodytais intervalais (a-z ir A-Z).
• Paslaugos simbolis. (taškas) reiškia „bet koks simbolis“. Pavyzdžiui, posakis p.p atitinka simbolį p, po kurio eina savavališkas simbolis, o po to vėl rašomas p.

Sujungus paslaugų simbolius gaunamos sudėtingesnės išraiškos. Pažvelkime į kelis pavyzdžius:

• ^.(2)$ – bet kokia eilutė, kurioje yra sklandžiai du simboliai;
• (.*)-- savavališka simbolių seka tarp<Ь>Ir(tikriausiai HTML žymės, skirtos paryškintam tekstui rodyti);
• p(hp)* – simbolis p, po kurio seka nulis arba daugiau sekos hp atvejų (pavyzdžiui, phphphp).

Kartais eilutėse reikia rasti specialiųjų simbolių, o ne naudoti juos ypatingame aprašytame kontekste. Norėdami tai padaryti, paslaugų simboliai yra pašalinami pasviruoju brūkšniu (\). Pavyzdžiui, norėdami ieškoti dolerio pinigų sumos, galite naudoti posakį \$+, tai yra „dolerio ženklas, po kurio rašomas vienas ar keli skaitmenys po kablelio“. Atkreipkite dėmesį į pasvirąjį brūkšnį prieš $. Galimos šios reguliarios išraiškos atitiktys yra $42, $560 ir $3.

Standartinės intervalo išraiškos (simbolių klasės)

Kad būtų lengviau programuoti, POSIX standartas apibrėžė kai kurias standartines intervalų išraiškas, dar vadinamas charakterio klases(personažo klasės). Simbolių klasė apibrėžia vieną simbolį iš nurodyto diapazono, pavyzdžiui, abėcėlės raidę arba skaičių:

• [[:alpha:]] -- abėcėlė (aA-zZ);
• [[:skaitmuo:]]-skaitmuo (0-9);
• [[:alnum:]] -- abėcėlė (aA-zZ) arba skaičius (0-9);
• [[:tarpas:]] -- tarpas (naujos eilutės, skirtukai ir tt).

PHP funkcijos, skirtos darbui su reguliariosiomis išraiškomis (suderinama su POSIX)

Šiuo metu PHP palaiko septynias paieškos funkcijas naudojant POSIX stiliaus reguliariąsias išraiškas:

• ereg();
• ereg_replace();
• eregi();
• eregi_replace();
• padalinti ();
• padalinti ();
• sql_regcase().

Šių funkcijų aprašymai pateikiami tolesniuose skyriuose.

Funkcija ereg() ieško tam tikros eilutės, kad atitiktų šabloną. Jei randama atitiktis, grąžinama TRUE, kitu atveju – FALSE. Funkcijos ereg() sintaksė yra tokia:

int ereg (eilutės šablonas, eilutės eilutė [, masyvo atitikmenys])

Paieška atliekama atsižvelgiant į abėcėlės raidžių atvejį. Ereg() naudojimo ieškant domenai.com eilutėse pavyzdys:

$is_com - ereg("(\.)(com$)", $el. paštas:

// Funkcija grąžina TRUE, jei $email baigiasi ".com" simboliais

// Visų pirma pavyks ieškoti eilučių

// "www.wjgilmore.com" ir " [apsaugotas el. paštas]"

Atminkite, kad dėl simbolio $, reguliarioji išraiška atitinka tik tada, kai eilutė baigiasi .com simboliais. Pavyzdžiui, ji atitiks eilutę „www.apress.com“, bet nesutaps eilutėje „www.apress.com/catalog“.

Neprivalomame atitikties parametre yra visų posakių atitikčių masyvas, esantis reguliariosios reiškinio skliausteliuose. 8.1 sąraše parodyta, kaip naudoti šį masyvą padalyti URL į kelis segmentus.

Sąrašas 8.1. $regs masyvo elementų spausdinimas

$url = "http://www.apress.com";

// Padalinkite $url į tris komponentus: "http://www". "apress" ir "com"

$www_url = ereg("^(http://www)\.([[:alnum:]+\.([[:alnum:]]+)". $url, $regs);

if ($www_url) : // Jei $www_url yra URL

echo $regs; // Visa eilutė "http://www.apress.com"

spausdinti"
";

echo $regs[l]; // "http://www"

spausdinti"
";

echo $regs; // "apress"

spausdinti"
";

echo $regs; // "com" endif;

Vykdant scenarijų 8.1 sąraše, gaunama tokia išvestis:

http://www.apress.com http://www apress com

Funkcija ereg_replace() ieško tam tikros eilutės, kad atitiktų šabloną, ir pakeičia ją nauju fragmentu. Funkcijos ereg_replace() sintaksė:

eilutė ereg_replace (stygos šablonas, eilutės pakeitimas, eilutės eilutė)

Funkcija ereg_replace() veikia tuo pačiu principu kaip ir ereg(), tačiau jos galimybės išplečiamos nuo paprastos paieškos iki paieškos su pakeitimu. Atlikus pakeitimą, funkcija grąžina pakeistą eilutę. Jei atitiks

trūksta, linija išlieka tos pačios būsenos. Funkcija ereg_replace(), kaip ir ereg(), yra didžiosios ir mažosios raidės. Žemiau pateikiamas paprastas šios funkcijos naudojimo pavyzdys:

$copy_date = "Autorių teisės 1999":

$kopijos_data = ereg_replace("(+)". "2000", $kopijos_data);

print $copy_date: // Spausdina eilutę "Autorių teisės 2000"

Viena įdomi PHP paieškos ir keitimo įrankių savybė yra galimybė naudoti atgalines nuorodas į pagrindinės išraiškos dalis, esančias skliausteliuose. Atgalinės nuorodos yra panašios į pasirenkamojo atitikties parametro ereg() elementus, su viena išimtimi: atgalinės nuorodos rašomos kaip \0, \1, \2 ir tt, kur \0 atitinka visą eilutę, \1 atitinka sėkmingą atitiktį pirmoji posakis ir tt Išraiškoje gali būti iki 9 atgalinių nuorodų. Šis pavyzdys pakeičia visas URL nuorodas tekste veikiančiomis hipersaitais:

$url = "Apress (http://www.apress.com");

$url = ereg_replace("http://(()*)", " \\0", $url);

// Rodoma eilutė:

// Apress (http://www.apress.com)

Funkcija eregi() ieško nurodytos eilutės, kad atitiktų šabloną. Funkcijos eregi() sintaksė:

int eregi (eilutės šablonas, eilutės eilutė [, masyvo atitikmenys])

Vyksta paieška neįskaitant abėcėlės raidžių atvejai. Funkcija eregi() ypač naudinga tikrinant įvestų eilučių (pavyzdžiui, slaptažodžių) galiojimą. Funkcijos eregi() naudojimas parodytas šiame pavyzdyje:

$slaptažodis = "abc";

if (! eregi("[[:alnum:]](8.10), $slaptažodis) :

print "Neteisingas slaptažodis! Slaptažodžiai turi būti nuo 8 iki 10 simbolių ilgio.";

// Vykdant šį fragmentą rodomas klaidos pranešimas.

// nes eilutės "abc" ilgis nepatenka į leistiną intervalą

// nuo 8 iki 10 simbolių.

Funkcija eregi_replace() veikia lygiai taip pat, kaip ereg_replace(), su viena išimtimi: paieška neskiria didžiųjų ir mažųjų raidžių. Funkcijos ereg_replace() sintaksė:

eilutė eregi_replace (eilutės šablonas, eilutės pakeitimas, eilutės eilutė)

Funkcija split() padalija eilutę į elementus, kurių ribas lemia duotas šablonas. Split() funkcijos sintaksė yra tokia:

masyvo padalijimas (eilutės šablonas, eilutės eilutė [, int slenkstis])

Pasirenkamas slenksčio parametras nurodo maksimalų elementų, į kuriuos eilutė yra padalinta iš kairės į dešinę, skaičių. Jei šablone yra abėcėlės simbolių, funkcija spl it() yra didžiosios ir mažosios raidės. Toliau pateiktame pavyzdyje parodytas split() funkcijos naudojimas norint padalinti kanoninį IP adresą į trejetus:

$ip = "123.345.789.000"; // Kanoninis IP adresas

$iparr = split ("\.", $ip) // Kadangi taškas yra paslaugos simbolis.

// reikia pabėgti.

spausdinti „$iparr
"; // Išveda "123"

spausdinti „$iparr
"; // Išveda "456"

spausdinti „$iparr
"; // Išveda "789"

spausdinti „$iparr
"; // Išveda "000"

Funkcija spliti() veikia lygiai taip pat, kaip jos prototipas split(), su viena išimtimi: it neatsižvelgia simbolių registras. Spliti() funkcijos sintaksė yra tokia:

masyvo padalijimas (eilutės šablonas, eilutės eilutė [, int slenkstis])

Žinoma, didžiosios ir mažosios raidės svarbios tik tuo atveju, jei šablone yra abėcėlės simbolių. Kitų simbolių atveju spliti() atlikimas yra lygiai toks pat kaip split().

Funkcija sql_regcase() pagalbinė priemonė kiekvieną įvesties eilutės simbolį įtraukia į laužtinius skliaustus ir prie jo prideda atitinkamą simbolį. Funkcijos sql_regcase() sintaksė:

eilutė sql_regcase (eilutės eilutė)

Jei abėcėlės simbolis yra dviem variantais (didžiosiomis ir mažosiomis raidėmis), laužtiniuose skliaustuose esančioje išraiškoje bus abu variantai; kitu atveju pradinis simbolis kartojamas du kartus. Funkcija sql_regcase() ypač naudinga naudojant PHP su programinės įrangos paketais, kurie palaiko vienkartines reguliariąsias išraiškas. Eilutės konvertavimo naudojant funkciją sql_regcase() pavyzdys:

$versija = "php 4.0";

spausdinti sql_regcase($versija);

// Rodo eilutę [..]

Perl stiliaus reguliariosios išraiškos sintaksė

Eilutės konvertavimas į didžiąsias ir mažąsias raides

PHP yra keturios funkcijos, skirtos pakeisti eilutės didžiąsias ir mažąsias raides:

• strtolower();
• strtoupper ();
• ucfirst();
• ucwords ().

Visos šios funkcijos yra išsamiai aprašytos toliau.

strtolower ()

Funkcija strtolower() konvertuoja visus eilutės abėcėlės ženklus į mažąsias raides. Funkcijos strtolower() sintaksė yra tokia:

eilutė strtolower (eilutės eilutė)

Funkcija nekeičia neabėcėlės ženklų. Eilutės konvertavimas į mažąsias raides naudojant funkciją strtolower() parodytas šiame pavyzdyje:

$sakinys = strtolower($sakinys);

// "maisto gaminimas ir programavimas php yra dvi mano mėgstamiausios pramogos!"

Stygas galima konvertuoti ne tik į mažąsias, bet ir į didžiąsias. Konvertavimą atlieka funkcija strtoupper(), kurios sintaksė yra tokia:

stygos stroupper (stygos eilutė)

Funkcija nekeičia neabėcėlės ženklų. Eilutės konvertavimas į didžiąsias raides naudojant strtoupper() funkciją parodytas šiame pavyzdyje:

$sentence = "Valgio gaminimas ir PHP programavimas yra dvi mano mėgstamiausios pramogos!";

$sakinys = strtoupper($sakinys);

// Iškvietus funkciją $sakinys turi eilutę

// "GALIOJIMAS IR PROGRAMAVIMAS PHP YRA DU MĖGSTAMIAUSIAS LAISVALAIKIS!"

Funkcija ucfirst() konvertuoja pirmąjį eilutės simbolį į didžiąsias raides, jei tai yra abėcėlės simbolis. ucfirst() funkcijos sintaksė:

eilutė ucfirst (stygos eilutė)

Funkcija nekeičia neabėcėlės ženklų. Pirmojo eilutės simbolio konvertavimas naudojant funkciją ucfirst() parodytas šiame pavyzdyje:

&sentence = "Maisto gaminimas ir programavimas PHP yra dvi mano mėgstamiausios pramogos!";

$sakinys = ucfirst($sakinys);

// Iškvietus funkciją $sakinys turi eilutę

// "Maisto gaminimas ir programavimas PHP yra dvi mano mėgstamiausios pramogos!"

Funkcija ucwords() konvertuoja pirmąją kiekvieno žodžio raidę eilutėje į didžiąsias raides. Funkcijos ucwords() sintaksė:

eilučių ucwords (eilutės eilutė")

Funkcija nekeičia neabėcėlės ženklų. „Žodis“ apibrėžiamas kaip simbolių seka, atskirta tarpais nuo kitų eilutės elementų. Šis pavyzdys parodo, kaip funkcija ucwords() konvertuoja pirmuosius žodžių simbolius:

$sentence = "Valgio gaminimas ir PHP programavimas yra dvi mano mėgstamiausios pramogos!";

$sakinys = ucwords($sakinys);

// Iškvietus funkciją $sakinys turi eilutę

// "Maisto gaminimas ir programavimas PHP yra mano dvi mėgstamiausios pramogos!"

Projektas: naršyklės identifikavimas

Kiekvienas programuotojas, bandantis sukurti patogią svetainę, peržiūrėdamas svetainę skirtingose ​​naršyklėse ir operacinėse sistemose turi atsižvelgti į puslapio formatavimo skirtumus. Nors W3 konsorciumas (http://www.w3.org) ir toliau skelbia standartus, kurių programuotojai turi laikytis kurdami žiniatinklio programas, naršyklių kūrėjai mėgsta šiuos standartus pridėti savo nedideliais „patobulinimais“, o tai galiausiai sukelia chaosą ir painiavą. . Kūrėjai dažnai išsprendžia šią problemą kurdami skirtingus puslapius kiekvienam naršyklės tipui ir operacinei sistemai – tai žymiai padidina darbo krūvį, tačiau sukurta svetainė idealiai tinka kiekvienam vartotojui. Rezultatas – gera svetainės reputacija ir pasitikėjimas, kad vartotojas joje apsilankys dar kartą.

Kad vartotojas galėtų peržiūrėti puslapį savo naršyklei ir operacinei sistemai tinkamu formatu, informacija apie naršyklę ir platformą išgaunama iš gaunamo puslapio užklausos. Gavęs reikiamus duomenis, vartotojas nukreipiamas į norimą puslapį.

Toliau pateiktame projekte (sniffer.php) parodyta, kaip naudoti PHP funkcijas dirbant su reguliariosiomis išraiškomis, norint gauti informaciją iš užklausų. Programa nustato naršyklės ir operacinės sistemos tipą bei versiją, o gautą informaciją parodo naršyklės lange. Tačiau prieš pereinant prie tikrosios programos analizės, noriu pristatyti vieną iš pagrindinių jos komponentų – standartinį PHP kintamąjį $HTTP_USER_AGENT. Šis kintamasis saugo įvairią informaciją apie vartotojo naršyklę ir operacinę sistemą eilučių formatu – būtent tai, kas mus domina. Šią informaciją galima lengvai parodyti ekrane tik viena komanda:

echo $HTTP USER_AGENT;

Paleidus Internet Explorer 5.0 kompiuteryje su Windows 98, rezultatas atrodys taip:

Mozilla/4.0 (suderinamas; MSIE 5.0; Windows 98; DigExt)

Netscape Navigator 4.75 rodomi šie duomenys:

„Mozilla“ / 4.75 („Win98“; U)

Sniffer.php iš $HTTP_USER_AGENT ištraukia reikiamus duomenis naudodamas eilučių apdorojimą ir reguliariųjų reiškinių funkcijas. Programos algoritmas pseudokode:

• Apibrėžkite dvi funkcijas naršyklei ir operacinei sistemai identifikuoti: browser_info() ir opsys_info(). Pradėkime nuo funkcijos browser_info() pseudokodo.
• Nustatykite naršyklės tipą naudodami eged() funkciją. Nors ši funkcija yra lėtesnė nei supaprastintos eilutės funkcijos, pvz., strstr(), šiuo atveju ji yra patogesnė, nes reguliarioji išraiška leidžia nustatyti naršyklės versiją.
• Naudokite if/elseif konstrukciją, kad nustatytumėte šias naršykles ir jų versijas: Internet Explorer, Opera, Netscape ir nežinomo tipo naršyklę.
• Pateikite naršyklės tipo ir versijos informaciją kaip masyvą.
• Funkcija opsys_info() nustato operacinės sistemos tipą. Šį kartą naudojama strstr() funkcija, nes OS tipas nustatomas nenaudojant reguliarių išraiškų.
• Naudodami if/elseif konstrukciją identifikuokite šias sistemas: Windows, Linux, UNIX, Macintosh ir nežinomą operacinę sistemą.
• Pateikite informaciją apie operacinę sistemą.

Sąrašas 8.3. Naršyklės tipo ir kliento operacinės sistemos nustatymas

Failas: sniffer.php

Tikslas: naršyklės tipo/versijos ir platformos identifikavimas

// Funkcija: naršyklės_informacija

// Tikslas: pateikia naršyklės tipą ir versiją

funkcija browser_info ($agent) (

// Nustatykite naršyklės tipą

// Ieškokite Internet Explorer parašo

if (ereg("MSIE (.(1,2))", $agentas, $versija))

$browse_type = "IE";

$naršyti versija = $versija;

// Ieškokite Opera parašo

elseif (ereg("Opera (.(1,2))". $agentas, $versija)):

$browse_type = "Opera":

$browse_version = $versija:

// Ieškokite „Netscape“ parašo. „Netscape“ naršyklės tikrinimas

// *privaloma* atlikti patikrinus Internet Explorer ir Opera,

// nes visos šios naršyklės mėgsta pranešti apie pavadinimą

// Mozilla kartu su tikruoju vardu.

elseif (ereg("Mozilla/(.(1,2))". $agentas, $versija)) :

$browse_type = "Netscape";

$naršymo_versija = $versija;

// Nebent Internet Explorer, Opera ar Netscape.

// reiškia, kad aptikome nežinomą naršyklę,

$browse_type = "Nežinoma";

$browse_version = "Nežinoma";

// Grąžina naršyklės tipą ir versiją kaip masyvą

grąžinti masyvą ($naršymo_tipas, $naršymo_versija);

) // Funkcijos browser_info pabaiga

// Funkcija: opsys_info

// Paskirtis: pateikia informaciją apie vartotojo operacinę sistemą

funkcija opsys_info($agent) (

// Nustatykite operacinę sistemą

// Ieškokite „Windows“ parašo

if (strstr($agent. "win")) :

$opsys = "langai";

// Ieškokite „Linux“ parašo

elseif (strstr ($ agentas, "Linux")) :

$opsys = "Linux";

// Ieškoti UNIX parašo

elseif (strstr (Sagent, "Unix")) :

$opsys = "Unix";

// Ieškokite „Macintosh“ parašo

elseif (strstr($agentas, "Mac")) :

$opsys = "Macintosh";

// Kita nežinoma platforma:

$opsys = "Nežinoma";

// Grąžina informaciją apie operacinę sistemą

sąrašas ($browse_type. $browse_version) = naršyklės_informacija ($HTTP_USER_AGENT); Soperating_sys = opsysjnfo($HTTP_USER_AGENT);

spausdinti "Naršyklės tipas: $browse_type
";

spausdinti „Naršyklės versija: $browse_version
";

spausdinti „Operacinė sistema: $operating_sys
":

Tai viskas! Pavyzdžiui, jei vartotojas naudoja Netscape 4.75 naršyklę Windows kompiuteryje, bus rodoma ši išvestis:

Naršyklės tipas: Netscape

Naršyklės versija: 4.75

Operacinė sistema: Windows

Kitame skyriuje sužinosite, kaip naršyti puslapiuose ir netgi sukurti stiliaus lapus konkrečioms operacinėms sistemoms ir naršyklėms.

Rezultatai

Šiame skyriuje buvo pateikta gana daug medžiagos. Kam naudinga programavimo kalba, jei negalite dirbti su tekstu? Apėmėme šias temas:

• bendra informacija apie reguliariąsias išraiškas POSIX ir Perl stiliuose;
• standartinės PHP funkcijos darbui su reguliariosiomis išraiškomis;
• keičiant linijos ilgį;
• eilutės ilgio nustatymas;
• alternatyvios PHP funkcijos, skirtos eilučių informacijai apdoroti;
• paprasto teksto konvertavimas į HTML ir atvirkščiai;
• simbolių raidžių keitimas eilutėse.

Kitas skyrius atveria antrąją knygos dalį – beje, mano mėgstamiausią. Jame pradėsime tyrinėti PHP į žiniatinklį orientuotus įrankius, apžvelgsime dinamiško turinio, įskaitant failus, kūrimo ir bendrų šablonų kūrimo procesą. Vėlesniuose 2 dalies skyriuose aptariamas darbas su HTML formomis, duomenų bazėmis, seansų duomenų sekimu ir išplėstiniais šablonų įrankiais. Laikykitės – linksmybės tuoj prasidės!

Turinys

$user_info

Tai visi raktai, apibrėžti $user_info, esantį loadUserSettings(). Kai kurie iš jų yra savaime suprantami.

grupės

masyvas. Visos galimos narių grupės taip pat prijungtos prie vartotojo. Raktai nesvarbu. Vertybės yra grupės, išvalytos kaip int, tik tuo atveju. Tai įtraukia:

• Pirminė grupė
• Pranešimų skaičiavimo grupė
• Papildomos grupės. Jie saugomi duomenų bazėje kaip kableliais atskirta eilutė.

galbūt_robotas

bool. Tiesa, jei agentas atitinka žinomą vorą, jei funkcija įjungta, o jei išjungta, daro pagrįstą spėjimą.

id

int Atitinka nario duomenų bazės reikšmę "id_member".!}

Vartotojo vardas

vardas

styga. Jų rodomas vardas.

paštu

passwd

kalba

yra_svečias

yra_adminas

tema

Paskutinis prisijungimas

tarpt. Unix laiko žyma.

ip

$_SERVER["REMOTE_ADDR"]

ip2

$_SERVER["BAN_CHECK_IP"]

pranešimų

tarpt. Pašto skaičius.

laiko formatas

styga. Pasirinktinis strtftime () formatas.

time_offset

tarpt. Vartotojo valandinis įskaitymas nuo forumo laiko.

avataras

• url:string
• failo pavadinimas:string
• custom_dir: bool
• id_attach: tarpt

šypsenėlių rinkinys

žinutes

tarpt. Jų turimų PM skaičius.

neskaityti_pranešimai

tarpt. Jų turimų neskaitytų PM skaičius.

total_time_logged_in

bičiuliai

Styga. Jų bičiulių sąrašas atskirtas kableliais.

ignoravimo lentos

Styga. Lentų, kurių jie nepaisė, sąrašas atskirtas kableliais.

ignoruojančiųjų

Styga. Naudotojų, kurių jie pasirinko nepaisyti, sąrašas atskirtas kableliais.

• SMF 1.1.x ignoruojami tik PM.
• SMF 2.0.x ir naujesnėje versijoje ši funkcija buvo patobulinta, kad taip pat būtų paslėpti ignoruojamo vartotojo įrašai.

įspėjimas

tarpt. Jų įspėjamieji taškai.

leidimai

query_see_board

Visų lentų, kurias jie gali matyti kaip paruošto SQL sakinio dalį, sąrašas.

query_wanna_see_board

Sąrašas lentų, kurias jie nori matyti kaip paruošto SQL sakinio dalį.

mod_cache

is_mod

Būlio. Netiesa, išskyrus valdybas, kuriose narys yra moderatorius. Jis visada nustatytas.

Tie, kurie daugiau ar mažiau rimtai studijavo PHPžinokite, kad yra vienas labai naudingas visuotinis masyvas PHP kuris vadinamas $_SERVER. Ir šiame straipsnyje norėčiau išanalizuoti populiariausius raktus ir jų reikšmes šiame masyve, nes jų žinios yra tiesiog privalomos net pradedantiesiems PHP programuotojas.

Prieš tau pradedant pasaulinis masyvas $_SERVER PHP, tuoj pat duosiu nedidelę užuominą. Yra įmontuota puiki funkcija PHP, kuris vadinamas phpinfo (). Iš karto pateiksime jo naudojimo pavyzdį:

phpinfo ();
?>

Vykdydami šį paprastą scenarijų pamatysite didžiulę lentelę su įvairiais PHP interpretatoriaus nustatymai, įskaitant, netoli pabaigos bus verčių lentelė pasaulinis masyvas $_SERVER. Jame bus išvardyti visi raktai ir visos juos atitinkančios reikšmės. Kaip tai gali jums padėti? Ir faktas yra tas, kad jei jums reikia tos ar kitos vertės ir pamiršote, kaip vadinamas raktas, tada naudokite funkciją phpinfo () Jūs visada galite prisiminti jo pavadinimą. Apskritai, jūs vykdysite šį scenarijų ir iškart mane suprasite.

Dabar pereikime prie populiariausių į $_SERVER masyvo raktus:

• HTTP_USER_AGENT- šis raktas leidžia sužinoti kliento savybes. Daugeliu atvejų tai tikrai yra naršyklė, tačiau ne visada. Ir vėl, jei tai naršyklė, tai kuri, apie ją galite sužinoti šiame kintamajame.
• HTTP_REFERER- yra absoliutus kelias į tą failą ( PHP scenarijus, HTML puslapis), iš kurio perėjome prie šio scenarijaus. Grubiai tariant, iš kur klientas atsirado.
• SERVER_ADDR - IP adresas serveris.
• REMOTE_ADDR - IP adresas klientas.
• DOCUMENT_ROOT- fizinis kelias į pagrindinį svetainės katalogą. Ši parinktis nustatyta per Apache serverio konfigūracijos failas.
• SCRIPT_FILENAME- fizinis kelias į iškviestą scenarijų.
• QUERY_STRING- labai naudinga reikšmė, leidžianti gauti eilutę su užklausa, o tada galite išanalizuoti šią eilutę.
• REQUEST_URI- dar naudingesnė reikšmė, kurioje yra ne tik pati užklausa, bet ir santykinis kelias į iškviestą scenarijų iš šaknies. Tai labai dažnai naudojama siekiant pašalinti dubliavimą iš index.php, tai yra, kai tokius turime URL: "http://mysite.ru/index.php"Ir" http://mysite.ru/“, veda į vieną puslapį ir URL skiriasi, taigi ir dubliavimasis, o tai turės blogos įtakos paieškos sistemų optimizavimui. Ir su pagalba REQUEST_URI galime nustatyti: su index.php ar ne scenarijus buvo vadinamas. Ir mes galime atlikti peradresavimą su index.php(jei jis dalyvavo REQUEST_URI) be index.php. Dėl to siunčiant tokią užklausą: " http://mysite.ru/index.php?id=5“, turėsime nukreipimą į URL: "http://mysite.ru/?id=5“. Tai yra, atsikratėme dubliavimosi pašalindami iš URL tai index.php.
• SCRIPT_NAME- santykinis kelias į iškviestą scenarijų.

Galbūt tai yra visi elementai pasaulinis masyvas $_SERVER PHP kurie naudojami reguliariai. Jūs turite juos žinoti ir mokėti naudoti, kai reikia.

vasario 5 d , 2017

Nežinau jokios PHP sistemos. Tai liūdna ir gėdinga, bet to dar nedraudžia įstatymai. Bet tuo pat metu noriu žaisti su REST API. Problema ta, kad php pagal numatytuosius nustatymus palaiko tik $_GET ir $_POST. O norint RESTful paslaugą, taip pat reikia mokėti dirbti su PUT, DELETE ir PATCH. Ir nelabai aišku, kaip kultūringai apdoroti daugelį tokių prašymų GAUTI http://site.ru/users, IŠTRINTI http://site.ru/goods/5 ir kitų nešvankybių. Kaip visas tokias užklausas sujungti į vieną tašką, visuotinai išanalizuoti į dalis ir paleisti reikiamą kodą duomenims apdoroti?

Beveik bet kuri PHP sistema gali tai padaryti iš karto. Pavyzdžiui, Laravel, kur maršrutas įgyvendinamas aiškiai ir paprastai. Bet ką daryti, jei mums šiuo metu nereikia studijuoti naujos didelės temos, o tiesiog norime greitai pradėti projektą su REST API palaikymu? Tai bus aptarta straipsnyje.

Ką turėtų sugebėti mūsų RESTful paslauga?

1. Palaikykite visus 5 pagrindinius užklausų tipus: GET, POST, PUT, PATCH, DELETE.
2. Išspręskite įvairius vaizdo maršrutus
PAŠTAS /prekės
PUT /prekės/(goodId)
GAUTI /users/(userId)/info
ir kitos savavališkai ilgos grandinės.

Dėmesio: šis straipsnis nėra apie REST API pagrindus
Manau, kad jūs jau esate susipažinę su REST metodu ir suprantate, kaip jis veikia. Jei ne, tada internete yra daug puikių straipsnių apie REST pagrindus - nenoriu jų kopijuoti, mano idėja yra parodyti, kaip praktiškai dirbti su REST.

Kokias funkcijas palaikysime?

Panagrinėkime 2 subjektus – produktus ir vartotojus.

Produktų parinktys yra šios:

• 1. GAUTI /prekes/(goodId)- Informacijos apie produktą gavimas
• 2. PAŠTAS /prekės- Naujo produkto pridėjimas
• 3. PUT /prekės/(goodId)- Produkto redagavimas
• 4. PATCHAS /prekės/(goodId)— Kai kurių gaminio parametrų redagavimas
• 5. IŠTRINTI /prekės/(goodId)- Produkto pašalinimas

Vartotojams, norėdami įvairovės, apsvarstykite keletą GET variantų

• 1. GAUTI /naudotojai/(userId)— Visa informacija apie vartotoją
• 2. GAUTI /users/(userId)/info— Tik bendra informacija apie vartotoją
• 3. GAUTI /users/(userId)/užsakymus— Vartotojų užsakymų sąrašas

Kaip tai veiks su vietine PHP?

Pirmiausia nustatysime .htaccess, kad visos užklausos būtų peradresuotos į index.php failą. Būtent jis užsiims duomenų išgavimu.

Antra, nuspręskime, kokių duomenų mums reikia ir parašykime kodą, kad juos gautume – į index.php.
Mus domina 3 tipų duomenys:

• 1. Užklausos metodas (GET, POST, PUT, PATCH arba DELETE)
• 2. Duomenys iš URL, pvz., vartotojai/(userId)/info – reikalingi visi 3 parametrai
• 3. Duomenys iš užklausos institucijos

Ir trečia, parašysime kodą, kuris vykdo būtinas funkcijas. Funkcijos suskirstytos į failus, viskas yra Feng Shui, pridėti naujų kelių ir metodų RESTful paslaugai bus labai paprasta.

.htaccess

Projekto šaknyje sukurkime .htaccess failą

RewriteEngine PerwriteCond %(REQUEST_FILENAME) !-f Perrašymo taisyklė ^(.+)$ index.php?q=$1

Šiomis paslaptingomis eilutėmis liepiame jums tai padaryti:
1 - siųskite visas bet kokio pobūdžio užklausas į karaliaus failą index.php
2 – padarykite URL eilutę prieinamą index.php parametre get parametre q. Tai yra, duomenys iš tokio URL kaip /users/(userId)/info gausime iš $_GET["q"].

index.php

Pažvelkime į index.php eilutę po eilutės. Pirmiausia išsiaiškinkime užklausos metodą.

// Apibrėžkite užklausos metodą $method = $_SERVER["REQUEST_METHOD"];

Tada duomenys iš užklausos įstaigos

// Gauti duomenis iš užklausos turinio $formData = getFormData($method);

Naudojant GET ir POST, nesunku gauti duomenis iš atitinkamų $_GET ir $_POST masyvų. Tačiau kitiems metodams reikia būti šiek tiek iškrypusiam. Jų kodas ištraukiamas iš srauto php://input, kodą lengva Google, aš ką tik parašiau bendrą įpakavimą - funkciją getFormData($method)

// Duomenų gavimas iš užklausos kūno funkcijos getFormData($method) ( // GET arba POST: grąžinkite duomenis kaip ir if ($method === "GET") return $_GET; if ($method === "POST" ) return $_POST; // PUT, PATCH arba DELETE $data = array("&", file_get_contents("php://input") ($item = explode). ("=", $pair if (count($item) == 2) ( $duomenys = urldecode($item); ) ) return $duomenys;

Tai yra, reikiamus duomenis gavome paslėpę visas detales getFormData – na, puiku. Pereikime prie įdomiausios dalies – maršruto parinkimo.

// Išanalizuoti URL $url = (isset($_GET["q"])) ? $_GET["q"] : ""; $url = rtrim($url, "/"); $urls = explode("/", $url);

Aukščiau sužinojome, kad .htaccess įdės parametrus iš URL į $_GET masyvo q parametrą. Tai reiškia, kad $_GET["q"] bus kažkas panašaus į tai: vartotojai/10. Nepriklausomai nuo to, kokį metodą naudojame užklausai vykdyti.

A sprogti ("/", $url) paverčia šią eilutę mums į masyvą, su kuriuo jau galime dirbti. Taigi kurkite tokias ilgas užklausų grandines, kokias norite, pavyzdžiui,
GAUTI /goods/page/2/limit/10/sort/price_asc
Ir būkite tikri, gausite masyvą

$urls = array("prekės", "puslapis", "2", "riba", "10", "rūšiuoti", "price_asc");

Dabar turime visus duomenis, turime su jais ką nors naudingo padaryti. Ir tai padarys tik 4 kodo eilutės

// Apibrėžkite maršrutizatorių ir url duomenis $router = $urls; $urlData = masyvas_slice($urls, 1); // Prijunkite maršrutizatoriaus failą ir paleiskite pagrindinę funkciją include_once "routers/" . $ maršrutizatorius. ".php"; maršrutas($metodas, $urlData, $formData);

Ar supranti? Sukuriame maršrutizatorių aplanką, kuriame dedame failus, kurie manipuliuoja vienu subjektu: produktais arba vartotojais. Tuo pačiu sutinkame, kad failų pavadinimai sutampa su pirmuoju parametru urlData – tai bus maršrutizatorius, $router. Ir šį maršrutizatorių reikia pašalinti iš urlData, mums jo nebereikia ir naudojamas tik reikiamam failui prijungti. masyvo_slice($urls, 1) ir pateiks mums visus masyvo elementus, išskyrus pirmąjį.

Dabar belieka prijungti norimą maršrutizatoriaus failą ir paleisti maršruto funkciją su trimis parametrais. Koks yra šios funkcijos maršrutas? Susitarkime, kad kiekviename maršrutizatoriaus faile bus apibrėžta funkcija, kuri pagal įvesties parametrus nustatys, kokį veiksmą vartotojas inicijavo ir vykdys reikiamą kodą. Dabar bus aiškiau. Apsvarstykime pirmąjį prašymą – duomenų apie prekę gavimą.

GAUTI /prekes/(goodId)

Failų maršrutizatoriai/goods.php

// Maršrutizatoriaus funkcijos maršrutas($method, $urlData, $formData) ( // Informacijos apie produktą gavimas // GET /goods/(goodId) if ($method === "GET" && count($urlData) == = 1) ( // Gaukite produkto ID $goodId = $urlData; // Ištraukite produktą iš duomenų bazės... // Išveskite atsakymą klientui echo json_encode(array("method" => "GET", "id" => $goodId, "good" => "phone", "price" => 10000) // Return error header("HTTP/1.0 400 Bad Request"); error" => "Blogas prašymas") ") )

Failo turinys yra viena didelė maršruto funkcija, kuri, priklausomai nuo perduotų parametrų, atlieka reikiamus veiksmus. Jei GET metodas ir 1 parametras (goodId) perduodami urlData, tai yra užklausa gauti duomenis apie produktą.

Dėmesio: pavyzdys labai supaprastintas
Realiame gyvenime, žinoma, reikia papildomai patikrinti įvesties parametrus, pavyzdžiui, kad goodId yra skaičius. Užuot čia rašę kodą, tikriausiai įtrauksite reikiamą klasę. O norėdami gauti produktą, sukurkite šios klasės objektą ir iškvieskite jame kokį nors metodą.
O gal perduokite valdymą kokiam nors valdikliui, kuris jau pasirūpins reikiamų modelių inicijavimu. Yra daug variantų, mes svarstome tik bendrą kodo struktūrą.

Atsakyme klientui pateikiame reikiamus duomenis: prekės pavadinimą ir jos kainą. Produkto ID ir metodas yra visiškai neprivalomi realioje programoje. Rodome juos tik norėdami įsitikinti, kad iškviečiamas teisingas metodas su tinkamais parametrais.

Pabandykime su pavyzdžiu: atidarykite naršyklės konsolę ir paleiskite kodą

$.ajax((url: "/examples/rest/goods/10", metodas: "GET", dataType: "json", sėkmė: function(response)(console.log("atsakymas:", atsakymas))) )

Kodas išsiųs užklausą serveriui, kuriame įdiegiau panašią programą, ir išduos atsakymą. Įsitikinkite, kad maršrutas, kuriuo jus domina, yra /prekės/10 tikrai dirbo. Skirtuke Tinklas pastebėsite tą pačią užklausą.
Ir taip, /examples/rest yra pagrindinis mūsų bandomosios programos kelias į svetainę

Jei esate labiau įpratę naudoti curl konsolėje, paleiskite tai terminale - atsakymas bus toks pat ir net su antraštėmis iš serverio.

Curl -X GET https://site/examples/rest/goods/10 -i

Funkcijos pabaigoje parašėme šį kodą.

// Grąžinti klaidos antraštę("HTTP/1.0 400 Blog Request"); echo json_encode(array("klaida" => "Bloga užklausa"));

Tai reiškia, kad jei suklydome su parametrais arba nenurodytas prašomas maršrutas, klientui grąžinsime 400 Bad Request klaidą. Pavyzdžiui, prie URL pridėkite kažką panašaus: prekės/10/kitas_param ir pamatysite klaidą konsolėje ir 400 atsakymą – kreiva užklausa nepraėjo.

Pagal serverio atsako http kodus
Nesivarginsime išvesti skirtingus kodus, nors tai verta daryti pagal REST. Yra daug klientų klaidų. Net ir mūsų paprastu atveju 405 yra tinkamas neteisingai pasirinkto metodo atveju. Nenoriu tyčia visko komplikuoti.
Jei pasiseks, mūsų serveris visada grąžins 200 OK. Laimei, kurdami šaltinį turėtumėte nurodyti 201 Created. Bet vėlgi, supaprastinimo prasme, mes atsisakysime šių subtilybių, tačiau realiame projekte jas nesunkiai įgyvendinsite patys.

Sąžiningai, straipsnis baigtas. Manau, kad jūs jau suprantate požiūrį, kaip išsprendžiami visi maršrutai, gaunami duomenys, kaip juos išbandyti, kaip pridėti naujų užklausų ir pan. Tačiau norint užbaigti vaizdą, pateiksiu likusių 7 užklausų, kurias aprašėme straipsnio pradžioje, įgyvendinimą. Pakeliui pateiksiu keletą įdomių komentarų, o pabaigoje paskelbsiu archyvą su šaltinio kodu.

PAŠTAS /prekės

Naujo produkto pridėjimas

// Naujo produkto pridėjimas // POST /goods if ($method === "POST" && empty($urlData)) ( // Produkto įtraukimas į duomenų bazę... // Išveskite atsakymą klientui echo json_encode (masyvas("metodas" => "POST", "id" => rand(1, 100), "formData" => $formData));

urlData dabar tuščia, bet naudojamas formData – tiesiog parodysime klientui.

Kaip tai padaryti "teisingai"?
Pagal REST kanonus, įrašo užklausoje turėtumėte grąžinti tik sukurto objekto ID arba URL, pagal kurį galima gauti šį objektą. Tai yra, atsakymas bus tik skaičius - (goodId), arba /prekės/(goodId).
Kodėl kabutėse parašiau „teisingai“? Taip, nes REST – tai ne griežtų taisyklių rinkinys, o rekomendacijos. O kaip tai įgyvendinsite, priklauso nuo jūsų pageidavimų ar jau priimtų susitarimų dėl konkretaus projekto.
Tiesiog atminkite, kad kitas programuotojas, skaitantis kodą ir žinantis REST metodą, atsakydamas į užklausą, tikėsis sukurto objekto ID arba URL, iš kurio bus galima gauti duomenis apie šį objektą su užklausa gauti.

Testavimas iš konsolės

$.ajax((url: "/examples/rest/goods/", metodas: "POST", duomenys: (prekė: "notebook", kaina: 20000), dataType: "json", sėkmė: function(response)( console.log("atsakymas:", atsakymas))))

Curl -X POST https://site/examples/rest/goods/ --duomenys "good=notebook&price=20000" -i

PUT /prekės/(goodId)

Produkto redagavimas

// Atnaujinkite visus produkto duomenis // Įdėkite /prekės/(goodId) if ($method === "PUT" && count($urlData) === 1) ( // Gaukite produkto ID $goodId = $urlData; / / Atnaujinkite visus duomenų bazės produkto laukus... // Išveskite atsakymą klientui echo json_encode(array("method" => "PUT", "id" => $goodId, "formData" => $formData)) ;

Čia visi duomenys jau naudojami iki galo. Produkto ID ištraukiamas iš urlData, o savybės ištraukiamos iš formData.

Testavimas iš konsolės

$.ajax((url: "/examples/rest/goods/15", metodas: "PUT", duomenys: (prekė: "užrašų knygelė", kaina: 20000), dataType: "json", sėkmė: function(response) (console.log("atsakymas:", atsakymas))))

Curl -X PUT https://site/examples/rest/goods/15 --duomenys "good=notebook&price=20000" -i

PATCHAS /prekės/(goodId)

Dalinis produkto atnaujinimas

// Dalinis produkto duomenų atnaujinimas // PATCH /prekės/(goodId) if ($method === "PATCH" && count($urlData) === 1) ( // Gaukite produkto ID $goodId = $urlData; // Duomenų bazėje atnaujiname tik nurodytus produkto laukus... // Išveda atsakymą klientui echo json_encode(array("method" => "PATCH", "id" => $goodId, "formData" => $formData));

Testavimas iš konsolės

$.ajax((url: "/examples/rest/goods/15", metodas: "PATCH", duomenys: (kaina: 25000), dataType: "json", sėkmė: function(response)(console.log(") atsakymas:", atsakymas)))

Curl -X PATCH https://site/examples/rest/goods/15 --data "price=25000" -i

Kam visas šis demonstravimas su PUT ir PATCH?
Ar neužtenka vieno PUT? Ar jie neatlieka to paties veiksmo – atnaujina objekto duomenis?
Teisingai – išoriškai veiksmas yra vienas. Skirtumas yra perduodamuose duomenyse.
PUT tai daro prielaidą Visi objektų laukus, o PATCH – tik pasikeitė. Tie, kurie siunčiami užklausos įstaigoje. Atkreipkite dėmesį, kad ankstesniame PUT mes perdavėme ir produkto pavadinimą, ir kainą. O PATCHe - tik kaina. Tai yra, į serverį siuntėme tik pakeistus duomenis.
Ar jums reikia PATCH – spręskite patys. Tačiau atsiminkite tą kodų skaitymo programuotoją, kurį minėjau aukščiau.

IŠTRINTI /prekės/(goodId)

Produkto pašalinimas

// Produkto ištrynimas // IŠTRINTI /prekes/(goodId) if ($method === "DELETE" && count($urlData) === 1) ( // Gaukite produkto ID $goodId = $urlData; // Ištrinti produktą iš duomenų bazės... // Išvesti atsakymą klientui echo json_encode(array("method" => "DELETE", "id" => $goodId));

Testavimas iš konsolės

$.ajax((url: "/examples/rest/goods/20", metodas: "DELETE", duomenų tipas: "json", sėkmė: function(response)(console.log("atsakymas:", atsakymas))) )

Curl -X DELETE https://site/examples/rest/goods/20 -i

Viskas aišku su prašymu IŠTRINTI. Dabar pažiūrėkime, kaip dirbti su vartotojais - vartotojų maršrutizatoriumi ir atitinkamai failu users.php

GAUTI /naudotojai/(userId)

Gaunami visi vartotojo duomenys. Jei GET užklausa yra kaip /naudotojai/(naudotojo ID), tada grąžinsime visą informaciją apie vartotoją, jei bus nurodyta papildomai /info arba /užsakymai, tada atitinkamai tik bendra informacija arba užsakymų sąrašas.

// Maršrutizatoriaus funkcijos maršrutas($method, $urlData, $formData) ( // Visos informacijos apie vartotoją gavimas // GET /users/(userId) if ($method === "GET" && count($urlData) = = = 1) ( // Gaukite produkto ID $userId = $urlData; // Ištraukite visus duomenis apie vartotoją iš duomenų bazės... // Išveskite atsakymą klientui echo json_encode(array("method" => " GET", "id" = > $userId, "info" => array("email" => " [apsaugotas el. paštas]", "name" => "Webdevkin"), "orders" => array(array("orderId" => 5, "summa" => 2000, "orderDate" => "01/12/2017"), masyvas (" orderId" => 8, "summa" => 5000, "orderDate" => "02/03/2017"))) return ) // Grąžina klaidos antraštę ("HTTP/1.0 400 Bad Request"); ); echo json_encode( array("error" => "Bloga užklausa"));

Testavimas iš konsolės

$.ajax((url: "/examples/rest/users/5", metodas: "GET", duomenų tipas: "json", sėkmė: function(response)(console.log("atsakymas:", atsakymas))) )

Curl -X GET https://site/examples/rest/users/5 -i

GAUTI /users/(userId)/info

Bendra informacija apie vartotoją

// Bendrosios informacijos apie vartotoją gavimas // GAUTI /users/(userId)/info if ($method === "GET" && count($urlData) === 2 && $urlData === "informacija") ( / / Gaukite produkto ID $userId = $urlData // Iš duomenų bazės ištraukite bendruosius duomenis apie vartotoją... // Išveskite atsakymą į klientą echo json_encode(array("method" => "GET", "id; " => $userId, " info" => array("email" => " [apsaugotas el. paštas]", "name" => "Webdevkin"))); grįžti; )

Testavimas iš konsolės

$.ajax((url: "/examples/rest/users/5/info", metodas: "GET", duomenų tipas: "json", sėkmė: function(response)(console.log("response:", atsakymas) )))

Curl -X GET https://site/examples/rest/users/5/info -i

GAUTI /users/(userId)/užsakymus

Naudotojų užsakymų sąrašo gavimas

// Gauti vartotojų užsakymus // GET /users/(userId)/orders if ($method === "GET" && count($urlData) === 2 && $urlData === "užsakymai") ​​( // Gauti produkto ID $userId = $urlData // Gauti duomenis apie vartotojo užsakymus iš duomenų bazės... // Išvesti atsakymą klientui echo json_encode(array("method" => "GET", "id" => $); userId, "orders" => array(masyvas("orderId" => 5, "summa" => 2000, "orderDate" => "01/12/2017"), array("orderId" => 8, "summa" " => 5000, "orderDate " => "02/03/2017")))); grąžinti; )

Testavimas iš konsolės

$.ajax((url: "/examples/rest/users/5/orders", metodas: "GET", duomenų tipas: "json", sėkmė: function(response)(console.log("atsakymas:", atsakymas) )))

Curl -X GET https://site/examples/rest/users/5/orders -i

Rezultatai ir šaltiniai

Šaltiniai iš straipsnių pavyzdžių –

Kaip matote, organizuoti REST API palaikymą vietiniame php pasirodė ne taip sunku ir visiškai teisėtais būdais. Pagrindinis dalykas yra maršrutų ir nestandartinių PHP metodų PUT, PATCH ir DELETE palaikymas.

Pagrindinis kodas, įgyvendinantis šį palaikymą, telpa į 3 dešimtis index.php eilučių. Likusi dalis yra tik diržai, kuriuos galima įgyvendinti bet kokiu būdu. Aš pasiūliau tai padaryti naudojant papildinių maršrutizatoriaus failus, kurių pavadinimai atitinka jūsų projekto esybes. Tačiau galite pasitelkti fantaziją ir rasti įdomesnį sprendimą.

Gauna WP_User objektą, kuriame yra visi nurodyto vartotojo duomenys.

Funkcijų grąžinami duomenys visiškai atitinka duomenų bazės lentelių laukus: wp_users ir wp_usermeta (lentelės aprašymas).

Tai yra prijungiama funkcija – t.y. jį galima pakeisti iš papildinio. Tai reiškia, kad jis veiks (jungsis) tik sujungus visus įskiepius, o iki šio momento funkcija dar neapibrėžta... Todėl šios ir nuo jos priklausančių funkcijų iškviesti tiesiogiai iš įskiepio kodo negalima. Juos reikia iškviesti naudojant plugins_loaded kabliuką arba vėliau, pvz., init hook.

Funkcijos pakeitimas (nepaisymas) - įskiepyje galite sukurti funkciją tuo pačiu pavadinimu, tada ji pakeis esamą funkciją.

✈ 1 kartas = 0,000296 s = greitai| 50 000 kartų = 0,78 s = labai greitai| PHP 7.1.2RC1, WP 4.7.2

Kabliukų nėra.

Grąžina

WP_User/false. Duomenų objektas arba klaidingas, jei nurodyto vartotojo nepavyko rasti.

Naudojimas

get_userdata($naudotojo kodas); $userid (skaičius) (būtina) Vartotojo, kurio duomenis norite gauti, ID.
Numatytasis: ne

Pavyzdžiai

#1 Kaip išvesti duomenis iš gauto duomenų objekto

$vartotojo_informacija = get_userdata(1); echo "Vartotojo vardas: " . $user_info->user_login . "\n"; echo "Prieigos lygis: " . $user_info->user_level . "\n"; echo "ID:". $user_info->ID . "\n"; /* Išėjimai: Vartotojo vardas: admin Prieigos lygis: 10 ID: 1 */

#1.2 Duomenys į kintamąjį

Kitas pavyzdys, tik čia mes pirmiausia įrašysime duomenis į kintamuosius, o tada parodysime juos ekrane:

$vartotojas = get_userdata(1); $vartotojo vardas = $vartotojas->naudotojo_prisijungimas; $pirmas_vardas = $vartotojas->vardas; $pavardė = $vartotojas->pavardė; echo "$first_name $last_name prisijungė prie svetainės pagal prisijungimo vardą: $username."; /* Objektas $user: WP_User Object( => stdClass Object( => 80 => kogian => $P$BJFHKJfUKyWv1TwLOVAENYU0JGNsq. => kogian => [apsaugotas el. paštas]=> http://example.com/ => 2016-09-01 00:34:42 => => => kogian) => 80 => Masyvas( => 1) => wp_pajėgumai => Masyvas( => prenumeratorius) => Masyvas( => 1 => 1 => 1) => => 1) */

#2 Klasės metodai

Objektas, gautas naudojant get_userdata(), yra klasės egzempliorius ir jame yra metodai, kuriuos galima naudoti. Kartais tai gali praversti. Štai paprastas pavyzdys, kaip gauti vartotojo parinktį naudojant $user->get() metodą:

$vartotojas = get_userdata(1); echo $vartotojo vardas = $vartotojas->get("naudotojo_prisijungimas");

Kai kurių metodų sąrašas:

get($key) – grąžina parinkties reikšmę;

has_prop($key) – patikrina, ar nurodyta parinktis įdiegta;

has_cap($cap) – patikrina, ar vartotojas turi nurodytą galimybę ar vaidmenį;

get_role_caps() – gauna visas vartotojo vaidmens galimybes ir sujungia jas su individualiomis vartotojo galimybėmis;

add_role($role) – prideda vaidmenį vartotojui;

remove_role($role) – pašalina vaidmenį iš vartotojo;

• set_role($role) – nustato vartotojo vaidmenį;

Pastabos

Štai keletas naudingų wp_users ir wp_usermeta lentelės laukų verčių, kurias galite naudoti norėdami gauti duomenis:

• rodomas pavadinimas

user_meta

• vartotojo_aprašymas

  wp_capabilities (masyvas)

  admin_color (administratoriaus skydelio tema. Numatytoji – nauja)

  uždarytas pašto dėžučių_puslapis

• šaltinio_domenas

Taip pat reikia pažymėti, kad nuo 3.2 versijos grąžinami duomenys šiek tiek pasikeitė: grąžinamas WP_User objektas. Duomenys objekte suskirstyti į grupes: duomenys, ribos, vaidmenys (anksčiau duomenys buvo grąžinami bendrame sąraše).

Tačiau dėl PHP „stebuklingų“ (naudingumo) metodų duomenis galima gauti kaip ir anksčiau, pavyzdžiui, dabar duomenys saugomi taip: get_userdata(1)->data->rich_editing , bet galite gauti kaip tai: get_userdata(1)->rich_editing , nors var_dump() šio ryšio nerodys.

Kodas gauti vartotojo duomenis: wp-includes/pluggable.php WP 5.2.2

document.write("");