Maitsetu valideerimine php. Valideeritud, kinnitatud... ja kinnitatud! Andmete validaatorite võrdlemine PHP-s. Validatori eksemplari loomine ja andmete valideerimine

Reg.ru: domeenid ja hostimine

Venemaa suurim registripidaja ja hostingu pakkuja.

Kasutusel on üle 2 miljoni domeeninime.

Reklaam, domeenipost, ärilahendused.

Rohkem kui 700 tuhat klienti üle maailma on juba oma valiku teinud.

* Kerimise peatamiseks liikuge hiirega üle.

Tagasi Edasi

Valideerimine ja andmete puhastamine PHP abil

Andmete turvalisus on väga oluline punkt, mida nii arendajad kui ka kliendid sageli alahindavad. Alates PHP 5.2.0-st on andmete puhastamine ja valideerimine (teatud kriteeriumidele vastavuse kontrollimine) muutunud lihtsamaks andmete filtreerimise kasutuselevõtuga. Täna vaatleme filtreerimistehnikaid, filtrite kasutamist ja kohandatud funktsioonide loomist.

Sissejuhatus

Olen alati tundnud, et PHP-s koodi kirjutamine on lihtne ja veel lihtsam on PHP-s halba koodi kirjutada. PHP laialdast kasutamist veebiarenduse vallas on soodustanud paljud avatud lähtekoodiga projektid nagu WordPress, Drupal, Magento. Lisaks on need veebirakendused nagu Facebook jne. PHP nii laialdase kasutuse juures (dünaamilised veebisaidid, ajaveebiplatvormid, sisuhaldussüsteemid, kasutamine e-kaubanduse rakendustes jne) on määrdunud teabe ja ebaturvaliste süsteemide sattumise tõenäosus väga suur. See õpetus näitab mõningaid meetodeid andmete puhastamiseks ja kinnitamiseks PHP abil. Keskendume mitmele sisenditüübile ning PHP filtrite ja kohandatud funktsioonide kasutamisele.

Miks puhastada ja kontrollida?

Selles juhendis keskendume teabele, mis pärineb otse kasutajatelt ja muudest välistest allikatest. See tähendab, et meil ei ole kontrolli saadava teabe üle. Kõik, mida saame teha, on kontrollida, mida selle saadud teabega tehakse. Peaaegu igat tüüpi ohud pärinevad kasutajate või muude kolmandate isikute edastatud teabest.

Peamiste hulgas:

- XSS (saitidevaheline skriptimine)

See on koodi sisestamise meetod, mille puhul skript süstitakse rünnatud veebisaidi lehele täiesti erinevalt saidilt erinevas serveris. Seda haavatavust peetakse võrgus üheks levinumaks.

- SQL-i süstimine

Järgmine populaarne haavatavus on teine ​​koodisüstimise vorm, mis võimaldab erinevat tüüpi pahatahtlikku käitumist, sealhulgas volitamata juurdepääsu teabele, andmebaasi teabe muutmist või muul viisil veebirakenduse normaalse toimimise häirimist. See rünnak viiakse läbi, sisestades päringusse suvalise SQL-koodi, mis on loodud andmebaasiga suhtlemiseks.

- CSRF/XSRF (saidiülese taotluse võltsimine)

See haavatavus on vähem levinud kui eelmised. Tavaliselt tekivad sellised haavatavused seansside ja küpsistega töötamisel ning harvemini siis, kui andmed on halvasti kontrollitud ja puhastatud. CSRF-i saab kasutada selleks, et lubada saidil teha mis tahes päringuid ilma kasutaja teadmata. Üks tuntud viise selle rünnaku rakendamiseks on kasutada valesti vormindatud atribuuti src pildi juures, mis viib mingi skripti täitmiseni, mitte pildi näitamiseni.

- Vale teave

Ebaõige teave iseenesest ei ole haavatavus. Selline teave põhjustab aga paljudel juhtudel mitmeid probleeme nii saidi omanikule kui ka andmebaasi administraatorile. Sageli põhjustab ebaõige ülesehitusega teave häireid töös, eriti kui sait on rakendatud amatööri tasemel, mitte vastavalt standarditele, samuti tõrkeid automatiseeritud süsteemide töös, mis eeldavad selgelt struktureeritud andmeid teatud vormingus. töötlemiseks.


Dialoogi tõlge pildile:

Tere, see on teie poja kool, kes teid häirib. Meil on siin probleeme arvutitega.

Oh jumal, kas ta murdis midagi?

Teie poja pärisnimi on Robert"); DROP TABLE õpilased;?

Oh jah, me kutsume teda Väikesed Bobby lauad

Saate aru, oleme kaotanud kõik selle aasta õpilaste rekordid. Loodan, et jäite rahule.

Ja loodan, et õpite andmebaasi sisestatud teavet kontrollima.

Oma eesmärkidel keskendume ainult serveripoolsete tehnikate kasutamisele teabeturbe parandamiseks, seega vaatame, kuidas on määratletud terminid "puhastus" ja "valideerimine", nagu need kehtivad PHP-s. Vaatame PHP kasutusjuhendit:

"Valideerimist kasutatakse selleks, et kontrollida, kas kontrollitav teave vastab teatud nõuetele. Näiteks FILTER_VALIDATE_EMAIL abil teeme kindlaks, kas teave on kehtiv (st struktuurselt õige) meiliaadress, kuid ei muuda neid andmeid.

Puhastamine tähendab kontrollitava teabe võimalikku muutmist, näiteks soovimatute märkide eemaldamist. Näiteks FILTER_SANITIZE_EMAIL kasutamisel eemaldatakse märgid, mis ei tohiks e-posti aadressis sisalduda. Need. Sel juhul ei toimu aadressi õigsuse kontrollimist (st valideerimist), kuid ilmselgelt sobimatud märgid eemaldatakse – ei muud."

Põhimõtteliselt, kui arvate, et teie sait on ööklubi, kuhu kõik tahavad minna, on valideerimine ülesanne kontrollida, kas külaline on külaliste nimekirjas, desinfitseerimine on tagasilöögivahend, mis hoiab soovimatud elemendid klubist eemal. Midagi sellist.

Millised filtrid mul on?

Kõik PHP installid ei saa olla identsed. Kuigi filtrid võeti kasutusele PHP 5.2.0-s, ei ole kõigil installidel sama filtrikomplekt. Enamikul juhtudel on kõik filtrid, millest me räägime, juba teie serverisse installitud PHP-ga kaasas, kuid et aidata teil filtrite kohta veidi rohkem teada saada, vaatame, mis on teie serveris saadaval. Lähtekoodi fail on lisatud getfilters.php, mis pärast installimist ja serveris töötamist kuvab kõigi teie filtrite loendi (nagu funktsiooni kaudu saadaolevad teabefiltrid filter_var, ja voogesitus, saadaval läbi stream_filter_append)

Kaja "Andmefiltrid\n

\n \n"; kaja " \n"; kaja " \n"; foreach(filter_list() as $id =>$filter) ( echo " \n"; ) kaja "
Filtri IDFiltri nimi
$filter".filter_id($filter)."
\n";

Kõigepealt saame massiivi, mis sisaldab kõigi funktsiooni abil saadaolevate filtrite loendit filter_list, mille järel liigume massiivi läbi, kuvades filtri nime ja selle ID.

Kuidas filtrit kasutada?

PHP-filtrid valideerimiseks ja puhastamiseks aktiveeritakse funktsiooni edastamisega filter_var vähemalt kaks parameetrit. Näiteks rakendame täisarvule tühjendusfiltrit:

$value = "123abc456def"; echo filter_var($value, FILTER_SANITIZE_NUMBER_INT); !}

Selles näites on meil muutuja väärtus, mille edastame funktsioonile filter_var PHP filtrite laiendusest, kasutades filtrit FILTER_SANITIZE_NUMBER_INT. Selle tulemusena saame:

Täisarvude puhastusfilter eemaldab kõik mittetäisarvulised märgid, andes meile "puhta" täisarvu. Allikates saate proovida erinevaid sisendeid ja neile rakendatakse mitmeid levinud filtreid. Arhiiv sisaldab erinevaid stringe, mida saate ise katsematerjalina kasutada.

Mida erinevad filtrid teevad?

Allolev loend pole täielik, kuid sisaldab enamikku filtreid, mis on kaasas standardse PHP 5.2.0+ installiga.

FILTER_VALIDATE_BOOLEAN: kontrollib, kas edastatud teave on tõeväärtus TRUE või FALSE. Kui edastatud väärtus ei ole Boole'i ​​väärtus, tagastatakse FALSE. Allolev skript prindib muutuja näite puhul TRUE väärtus1 väärtus02:

$väärtus01 = TÕENE; if(filter_var($väärtus01,FILTER_VALIDATE_BOOLEAN)) ( echo "TRUE"; ) else ( echo "FALSE"; ) echo "

" $väärtus02 = VÄÄR; if(filter_var($väärtus02,FILTER_VALIDATE_BOOLEAN)) ( echo "TRUE"; ) else ( kaja "FALSE"; )

FILTER_VALIDATE_EMAIL: kontrollib, kas edastatud teave on struktuuri poolest kehtiv e-posti aadress. See ei kontrolli, kas see aadress on reaalselt olemas, vaid ainult aadressi kehtivust, s.t. selle struktuuri õigsus. Allolev skript prindib muutuja näite puhul TRUE väärtus01 ja FALSE muutuja näite puhul väärtus02(kuna vajalik osa @-märgiga puudub):

$value01 = " [e-postiga kaitstud]"; if(filter_var($value01,FILTER_VALIDATE_EMAIL)) ( echo "TRUE"; ) else ( echo "FALSE"; ) kaja "

" $value02 = "nettuts"; if(filter_var($value02,FILTER_VALIDATE_EMAIL)) ( echo "TRUE"; ) else ( kaja "FALSE"; )

FILTER_VALIDATE_FLOAT: kontrollib, kas edastatud väärtus on ujukomaarv. Allolev skript prindib muutuja näite puhul TRUE väärtus01 ja FALSE muutuja näite puhul väärtus02(kuna split "," pole ujukomanumbrites lubatud):

$value01 = "1,234"; if(filter_var($väärtus01,FILTER_VALIDATE_FLOAT)) ( echo "TRUE"; ) else ( echo "FALSE"; ) echo "

" $value02 = "1,234"; if(filter_var($value02,FILTER_VALIDATE_FLOAT)) ( kaja "TRUE"; ) else ( kaja "FALSE"; )

FILTER_VALIDATE_INT: kontrollib, kas edastatud väärtus on täisarv. Allolev skript prindib muutuja näite puhul TRUE väärtus01 ja FALSE muutuja näite puhul väärtus02(kümnendarvud ei ole täisarvud):

$väärtus01 = "123456"; if(filter_var($väärtus01,FILTER_VALIDATE_INT)) ( echo "TRUE"; ) else ( echo "FALSE"; ) echo "

" $value02 = "123.456"; if(filter_var($value02,FILTER_VALIDATE_INT)) ( echo "TRUE"; ) else ( kaja "FALSE"; )

FILTER_VALIDATE_IP: kontrollib, kas edastatud väärtus on kehtiv IP-aadress. See ei kontrolli, kas sellelt aadressilt on vastus, vaid ainult seda, et edastatud väärtus on oma struktuuri järgi IP-aadress. Allolev skript prindib muutuja näite puhul TRUE väärtus01 ja FALSE muutuja näite puhul väärtus02:

$value01 = "192.168.0.1"; if(filter_var($väärtus01,FILTER_VALIDATE_IP)) ( echo "TRUE"; ) else ( echo "FALSE"; ) echo "

" $value02 = "1.2.3.4.5.6.7.8.9"; if(filter_var($value02,FILTER_VALIDATE_IP)) ( echo "TRUE"; ) else ( kaja "FALSE"; )

FILTER_VALIDATE_URL: kontrollib, kas edastatud väärtus on kehtiv URL. See ei kontrolli, see ei kontrolli, kas ressurss on juurdepääsetav, vaid ainult seda, et järgitakse URL-i struktuuri. Allolev skript prindib muutuja näite puhul TRUE väärtus01 ja FALSE muutuja näite puhul väärtus02:

$value01 = "http://net.tutsplus.com"; if(filter_var($value01,FILTER_VALIDATE_URL)) ( echo "TRUE"; ) else ( echo "FALSE"; ) echo "

" $value02 = "nettuts"; if(filter_var($value02,FILTER_VALIDATE_URL)) ( kaja "TRUE"; ) else ( kaja "FALSE"; )

FILTER_SANITIZE_STRING: vaikimisi eemaldab see filter stringist kehtetu või volitamata teabe. Näiteks eemaldab see kõik HTML-sildid, nagu või sisendstringist:

$value = "alert("TROUBLE HERE");"; echo filter_var($value, FILTER_SANITIZE_STRING); !}

See skript eemaldab sildid ja tagastab järgmise:

Alert("HÄDA SIIN");

FILTER_SANITIZE_ENCODED: funktsiooni kasutavad paljud programmeerijad urlencode(). See filter täidab sisuliselt samu funktsioone. Näiteks kodeerib järgmine näide sisendstringis kõik erimärgid ja tühikud:

$value = "alert("TROUBLE HERE");"; echo filter_var($value, FILTER_SANITIZE_ENCODED); !}

Skript kodeerib kirjavahemärke, tühikuid, sulgusid ja tagastab järgmised andmed:

%3Cscript%3Ealert%28%27TROUBLE%20SIIN%27%29%3B%3C%2Fscript%3E

FILTER_SANITIZE_SPECIAL_CHARS: see filter kasutab vaikimisi erimärkide (nt jutumärkide, ampersandide ja sulgude) HTML-kodeeringut. Kuna demoleht ei saa seda selgesõnaliselt näidata (kuna HTML-kodeeringuga erimärke tõlgendab ja kuvab brauser), näete seda lähtekoodi vaadates:

$value = "alert("TROUBLE HERE");"; echo filter_var($value, FILTER_SANITIZE_SPECIAL_CHARS); !}

Erimärgid teisendatakse nende HTML-üksusteks:

FILTER_SANITIZE_EMAIL: see filter teeb täpselt seda, mida kõik arvasid. See eemaldab aadressist märgid, mis ei tohiks aadressis olla (ümmargused ja nurksulud, koolonid jne) Oletame, et lisasite kogemata oma aadressi tähe ümber sulud (ärge küsige, kuidas, kasutage oma kujutlusvõimet :) )

$value = "t(e) [e-postiga kaitstud]"; kaja filter_var($väärtus, FILTER_SANITIZE_EMAIL);

Sulgud eemaldatakse ja saate oma puhta ja ilusa e-kirja:

[e-postiga kaitstud]

See on suurepärane filter, mida saab kasutada meilivormides, eriti kui see on seotud FILTER_VALIDATE_EMAIL-ga, mis vähendab kasutaja vigu ja hoiab ära XSS-i rünnakud.

FILTER_SANITIZE_URL: see filter on sarnane eelmisele. See eemaldab kõik märgid, mis pole URL-is lubatud. Oletame näiteks, et aadressis oli juhuslikult märk "®". Jällegi, kuidas ta sinna sattus, on täielik mõistatus.

$value = "http://net.tuts®plus.com"; echo filter_var($value, FILTER_SANITIZE_URL); !}

Nii eemaldame mittevajaliku "®" märgi ja saame tavalise aadressi:

http://net.tutsplus.com

FILTER_SANITIZE_NUMBER_INT: see filter sarnaneb filtriga FILTER_VALIDATE_INT, kuid selle asemel, et kontrollida, kas arv on täisarv, eemaldab see ka kõik, mis ei ole täisarv. Suurepärane asi, eriti tüütute rämpsposti robotite ja petiste vastu, kes üritavad valdkonda lollusi sisestada:

$value01 = "123abc456def"; kaja filter_var($väärtus01, FILTER_SANITIZE_NUMBER_INT); kaja"
"; $value02 = "1.2.3.4.5.6.7.8.9"; kaja filter_var($value02, FILTER_SANITIZE_NUMBER_INT);

123456 123456789

FILTER_SANITIZE_NUMBER_FLOAT: sarnane FILTER_VALIDATE_INT. Samuti võimaldab see saavutada sarnase efekti:

$value01 = "123abc456def"; kaja filter_var($väärtus01, FILTER_SANITIZE_NUMBER_FLOAT); kaja"
"; $value02 = "1.2.3.4.5.6.7.8.9"; kaja filter_var($value02, FILTER_SANITIZE_NUMBER_FLOAT);

Mõlemad märgikomplektid teisendatakse ja väljund on järgmine:

123456 123456789

$väärtus = "1,23"; kaja filter_var($väärtus, FILTER_SANITIZE_NUMBER_FLOAT);

Punkt eemaldatakse ja väärtus tagastatakse:

Üks peamisi põhjusi, miks filtrid FILTER_SANITIZE_NUMBER_FLOAT ja FILTER_SANITIZE_INT on eraldatud, on võimalus kasutada spetsiaalset lippu FILTER_FLAG_ALLOW_FRACTION, mis on funktsioonile edastatav kolmas parameeter. filter_var:

$väärtus = "1,23"; kaja filter_var($väärtus, FILTER_SANITIZE_NUMBER_FLOAT, FILTER_FLAG_ALLOW_FRACTION);

Valikud, lipud ja juhtmassiivid – Mein Gott!

Eelmises näites kasutatud lipp on vaid üks võimalus saada täpsem kontroll puhastatavate andmetüüpide, eraldaja määratluste, massiivide filtrite töötlemise jne üle. Lisateavet ühenduses kasutatavate lippude ja funktsioonide kohta leiate filtrite kasutamisega PHP käsiraamatus, Filtritele pühendatud osas - php.net/manual/en/book.filter.php.

Muud meetodid teabe kustutamiseks PHP abil

Vaatleme nüüd mõnda peamist andmete puhastamise tehnikat, et vältida teie rakenduse ründamist. Need on eriti olulised nende rakenduste jaoks, mis töötavad endiselt PHP4-s, nagu need ilmusid selle väljalaskega.

htmlspecialchars: see PHP-funktsioon teisendab 5 erimärki vastavateks HTML-üksusteks.

Järgmised asjad kuuluvad ümberkujundamisele:

& (ampersand)
" (jutumärgid), kui lipp ENT_NOQUOTES pole määratud
“ (üks jutumärke) ainult siis, kui lipp ENT_QUOTES on seatud
< (меньше, чем)
> (rohkem kui)

Seda funktsiooni kasutatakse samamoodi nagu mis tahes muud PHP-s:

Echo htmlspecialchars("$string");

htmlentities: sarnane funktsiooniga htmlspecialchars see funktsioon teisendab erimärgid nende HTML-i olemiteks. Ainus erinevus seisneb selles, et sel juhul teisendatakse kõik erimärgid, mida saab teisendada. See on üsna levinud meetod e-posti aadresside rämpsposti robotitest hägustamiseks, kuna mitte kõik neist pole konfigureeritud html-olemite lugemiseks:

Echo htmlentities("$string");

mysql_real_escape_string: see on MySQL-i funktsioon, mis aitab kaitsta SQL-i süstimise rünnakute eest. Heaks tavaks (ja tegelikult vajalikuks) peetakse kogu selle funktsiooni kaudu SQL-päringule edastatud teabe edastamist. See väldib kõiki ohtlikke erimärke, mis võivad probleeme põhjustada ja põhjustada väikesed Bobby lauad hävitab kooli andmebaasis veel ühe tabeli.

$query = "SELECT * FROM tabelist WHERE value=".mysql_real_escape_string("$string")." LIMIT 1,1"; $runQuery = mysql_query($query); !}

Kohandatud funktsioonid

Paljude inimeste jaoks ei pruugi sisseehitatud funktsioonidest ja filtritest piisata. Sageli võib olla vaja rangemat ja kitsamat valideerimist või puhastamist. Soovitud tulemuste saavutamiseks kirjutavad paljud inimesed ise andmete valideerimiseks funktsioone. Näiteks on võimalus otsida andmebaasist teatud tüüpi väärtusi, näiteks:

Funktsioon checkZipCode($value) ($zipcheck = "SELECT COUNT(*) FROM `andmebaasist`.`sipcodes` WHERE value="".filter_var(mysql_real_escape_string($value),FILTER_SANITIZE_NUMBER_INT)."""; $count = mysql_query( $zipcheck) if($count==1) ( return TRUE; ) else ( return FALSE; ) )

Teised kasutajafunktsioonid ei pruugi olla otse andmebaasiga ühendatud, kuid valmistavad teabe enne selle andmebaasi sisestamist ette:

Funktsioon cleanString($string) ( $detagged = strip_tags($string); if(get_magic_quotes_gpc()) ( $stripped = ribakriipsud($detagged); $escaped = mysql_real_escape_string($stripped); ) else ( $escaped = mysql_string(real_e) detagged);

Võimalused on peaaegu lõputud, eriti regulaaravaldiste kasutamisel. Kuid enamikul juhtudel võib filtrite kasutamine juba vajalikke probleeme lahendada.

Kas teile meeldis materjal ja soovite mind tänada?
Lihtsalt jaga oma sõprade ja kolleegidega!


Peaaegu kõik interaktiivsed veebirakendused peavad sisendi kinnitama. Näiteks registreerimisvorm nõuab tõenäoliselt kinnitamiseks parooli. Võib-olla peaks meiliaadress olema kordumatu. Taustakontroll võib olla tülikas protsess. Õnneks mitte Laravelis. Klass Validator pakub hämmastavat komplekti valideerimisabilisi, muutes andmete valideerimise võimalikult lihtsaks. Vaatame näidet:

Andmete massiivi hankimine valideerimiseks: $input = Input::all(); Andmete valideerimise reeglite defineerimine: $rules = array("nimi" => "required|max:50", "email" => "required|email|unique:users",); Validatori eksemplari loomine ja andmete valideerimine: $validation = Validator::make($input, $rules); if ($validation->fails()) ( tagastab $validation->errors; )

Kui kinnisvara on olemas vead saate juurdepääsu sõnumite kogujale, mis võimaldab teil hõlpsasti oma veateateid luua. Loomulikult on kõikidel valideerimisreeglitel vaikimisi veateated. Standardsed veateated leiate saidilt language/en/validation.php.

Nüüd olete tuttav Validatori klassi kasutamise põhireeglitega. Olete valmis oma andmete kontrollimiseks kasutatavaid reegleid uurima ja õppima!

Valideerimisreeglid Nõutavad andmed Nõutava mittetühja parameetri väärtuse kontrollimine: "name" => "nõutav" Alfa, Alfa numbriline ja alfakriips Ainult tähtede olemasolu kontrollimine: "name" => "alpha" Ainult tähtede olemasolu kontrollimine tähed ja numbrid: "username" " => "alpha_num" Kontrollib ainult tähtede, numbrite, sidekriipsude ja alakriipsude olemasolu: "username" => "alpha_dash" Suurus Kontrollib stringi atribuudi stringi suurust või vahemikku numbrilise atribuudi väärtused: "name" => "size:10" Kontrollige väärtuste vahemikku: "makse" => "vahemikus:10.50"

Märkus. Miinimum ja maksimum sisalduvad vahemikus.

Atribuudi minimaalse suuruse kontrollimine: "payment" => "min:10" Atribuudi maksimaalse suuruse kontrollimine: "payment" => "max:50" Numbritüübid Kontrollimine, kas atribuut kuulub numbriliigi: "makse " => "numeric" Kontrollimine, kas atribuut kuulub täisarvu tüüpi: "payment" => "integer" Esinemised ja välistused Väärtuste massiivi kaasatava atribuudi kontrollimine: "size" => "in:small, medium,large" Väärtuste massiivist välja jäetava atribuudi kontrollimine: "language" => "not_in:cobol,assembler" Kinnitus

Reegel kinnitatud kontrollib, kas antud atribuudi jaoks on olemas vastav atribuudi_kinnitus.

Atribuudi kontrollimine kinnituse saamiseks: "password" => "kinnitatud"

Selles näites kontrollib Validator, et parameeter parool vastab tingimustele parooli_kinnitus valideerimismassiivist.

Vastuvõtmine

Reegel vastu võetud kontrollib parameetri väärtust jah või 1 . See reegel kontrollib kohustuslike märkeruutude installimist, näiteks märkeruutu "Teenusetingimused".

Aktsepteerimise kontroll: "terms" => "accepted" Vasted ja erinevused Kontrollige, kas atribuut on sama, mis teine ​​võrreldav atribuut: "token1" => "same:token2" Kontrolli, et atribuudil oleks erinev tähendus: "password" => "erinev:vana_parool", Regulaaravaldised

Reegel vaste kontrollib, kas atribuut vastab regulaaravaldisele.

Regulaaravaldise rahulolu kontrollimine: "username" => "match:/+/"; Unikaalsus ja olemasolu Parameetri unikaalsuse kontrollimine andmebaasis: "email" => "unikaalne:kasutajad"

Selles näites parameeter meili kontrolliti tabelist unikaalsust kasutajad. Kas soovite kontrollida peale selle veeru mõne muu atribuudi unikaalsust? Pole probleemi:

Teise kontrollitava veeru määramine: "email" => "unikaalne:kasutajad,e-posti aadress"

Sageli peate kirje värskendamisel kasutama kordumatut reeglit, kuid välistage värskendatav kirje. Näiteks soovite lubada kasutajatel oma e-posti aadresse muuta. Aga kui reegel jookseb ainulaadne, peate selle kasutaja vahele jätma, et vältida kujuteldava valideerimisvea tekitamist. See on lihtne:

Määratud ID ignoreerimine: "email" => "unikaalne:kasutajad,e-posti aadress,10" Kontrollimine, kas atribuut on määratud andmebaasis olemas: "state" => "exists:states" Olemasoleva reegli veeru nime määramine: "state " => " on olemas:olekud,lühend" Kuupäevad Kontrollimine, et kuupäevaparameeter oleks enne...: "birthdate" => "before:1986-28-05"; Kontrollitakse, kas kuupäeva parameetril on väärtus pärast...: "birthdate" => "after:1986-28-05";

Märkus. Enne ja pärast kontroll kasutab PHP strtotime funktsiooni.

E-posti aadressid Kontrollige, kas parameeter on e-posti aadress: "aadress" => "e-post"

Märkus. See reegel kasutab PHP sisseehitatud meetodit filter_var.

URL-id Kontrollimine, et parameeter on URL: "link" => "url" Kontrollimine, kas parameeter on aktiivne URL: "link" => "active_url"

Märkus: reegel aktiivne_url kasutab checkdnsr et kontrollida, kas URL on aktiivne.

Allalaadimised

Reeglid miimid kontrollige, kas allalaaditud fail vastab MIME tüübile. See reegel kasutab faili sisu kontrollimiseks ja selle tüübi määramiseks PHP Fileinfo laiendit. Kõik sellele reeglile kehtivad faililaiendid on määratletud keeles config/mimes.php.

Kontrollimine, kas fail kuulub teatud tüüpi: "picture" => "mimes:jpg,gif"

Märkus. Kontrollimisel kasutage kindlasti Input::file() või Input::all().

Kontrollimine, kas fail on pilt: "picture" => "image" Faili suuruse kontrollimine: "picture" => "image|max:100" Veateate küsimine

Laravel võimaldab teil veateateid käsitleda lihtsa klassi, mida nimetatakse veakogujaks, abil. Pärast helistamismeetodid möödub või ebaõnnestub Validaatori eksemplar, saate veale juurde pääseda atribuudi abil vead. Veakogujal on veateadete pärimiseks lihtsad funktsioonid:

Määramine, et atribuudil on veateade: if ($validation->errors->has("email")) ( // E-posti atribuudil on vead... ) Esimese veateate päring atribuudi jaoks: echo $ valideerimine ->vead->first("e-post");

Võimalik, et peate oma veateate mähkima HTML-märgenditesse. Pole probleemi. Kutsudes :message place-holder, määra meetodi teise parameetrina vorming.

Veateate vorming: echo $validation->errors->first("email", ""); Kõigi atribuudi veateadete toomine: $messages = $validation->errors->get("email"); Kõigi atribuudi veateadete vormindamine: $messages = $validation->errors->get("email", ""); Kõigi atribuutide kõigi veateadete hankimine: $messages = $validation->errors->all(); Kõigi atribuutide kõigi veateadete vormindamine: $messages = $validation->errors->all(""); Valideerimise läbimine

Kui olete valideerimise lõpetanud, vajate vaates vigade kuvamiseks lihtsat viisi. Laravel teeb selle väga lihtsaks. Vaatame tüüpilist stsenaariumi. Seda saab määratleda kahel viisil:

Route::get("register", function() ( return View::make("kasutaja.register"); )); Route::post("register", function() ( $reeglid = array(...); $validation = Validator::make(Input::all(), $reeglid); if ($validation->fails( )) ( return Redirect::to("register")->with_errors($validation); ) );

Suurepärane! Seega on meil registreerimisvormi jaoks kaks lihtsat marsruuti. Üks vormikuva ja üks vormisisestuse haldamiseks. POST-i marsruudil teeme sisendis mõningaid kontrolle. Kui kinnitamine ebaõnnestub, suuname Teid tagasi registreerimisvormile, näidates ära vead ja kuvades viimased vormis.

Kuid pange tähele, et me ei seosta tõrkeid otseselt oma GET-marsruudi sihtmärgiga. Veamuutuja on aga vaates saadaval. Laravel tuvastab arukalt, kas seansil on vigu, ja kui jah, lisab vaatele teated. Kui vigu pole, lisatakse tühi veateate konteiner ikkagi vaatele. Veateadete konteiner on vaates alati saadaval. Meile meeldib teie elu lihtsamaks teha.

Kohandatud veateated

Kas soovite kasutada oma veateadet? Võib-olla soovite teatud atribuudi ja reegli jaoks isegi kohandatud veateateid kasutada. Mõlemal juhul teeb Validatori klass selle tegemise lihtsaks.

Oma veateadete massiivi loomine Validatori jaoks: $messages = array("required" => "Väl:atribuut on kohustuslik.",); $validation = Validaator::make(Sisend::get(), $reeglid, $teated);

Suurepärane! Nüüd kasutatakse kinnitamisel alati meie kohandatud sõnumeid. Aga mis on väljend :attribute meie sõnumis. Teie elu hõlbustamiseks asendab Validaatori klass atribuudi :attribute vea põhjustanud atribuudiga. See eemaldab isegi atribuudi nimest alakriipsu. Veateadete koostamiseks saate kasutada ka kohatäiteid :other , :size , :min , :max ja :values.

Kohandatud veateadete näited: $messages = array("same" => "Atribuut:atribuut ja:muu peavad ühtima.", "size" => "Atribuut peab olema täpselt:suurus.", "beween" => "The:attribute peab olema vahemikus:min - :max.", "in" => "Atribuut peab olema ühte järgmistest tüüpidest: :values",);

Mis siis, kui teil on vaja määratleda nõutav sõnum, kuid ainult e-posti atribuudi jaoks? Pole probleemi. Lihtsalt määrake sõnum, kasutades atribuudi_reegli nimetamist:

Teate määratlemine konkreetse atribuudi jaoks: $messages = array("email_required" => "Me peame teadma teie e-posti aadressi!",);

Selles näites kasutatakse kohandatud veateadet ainult e-posti atribuudi jaoks, vastasel juhul kasutatakse standardseid sõnumeid.

Samas, kui kasutad palju enda veateateid, võib nende kõigi koodis täpsustamine muuta selle tülikaks ja ebamugavaks. Sel põhjusel on võimalik keelefailis määratleda oma massiiv:

Oma massiivi lisamine keelefaili: "custom" => array("email_required" => "Peame teadma teie e-posti aadressi!",) Kohandatud valideerimisreeglid

Laravel pakub mitmeid võimsaid valideerimisreegleid. Siiski saate luua oma. Valideerimisreeglite loomiseks on kaks lihtsat viisi. Mõlemad on kasutamiseks usaldusväärsed. Kõik, mida pead tegema, on valida oma projekti jaoks sobivam.

Enda valideerimisreegli registreerimine: Validator::register("vinge", function($attribute, $value, $parameters) ( return $value == "awesome"; }); !}

Selles näites oleme registreerinud klassi Validator uued valideerimisreeglid. See reegel hõlmab kolme parameetrit. Esimene on kontrollitava atribuudi nimi, teine ​​on kontrollitava atribuudi väärtus ja kolmas on reegli jaoks määratud parameetrite massiiv.

Teie reeglikutse näeb välja selline:

$reeglid = array("kasutajanimi" => "nõutav|vinge",);

Loomulikult peate uue reegli jaoks määratlema veateate. Seda saate teha kas massiivi erisõnumites:

$messages = array("awesome" => "Atribuudi väärtus peab olema äge!",); $validator = Validaator::make(Sisend::get(), $reeglid, $teated);

või lisades reegli kirje keele/en/validation.php :

"awesome" => "Atribuudi väärtus peab olema suurepärane!",

Nagu eespool mainitud, saate isegi kohandatud reeglis määrata ja hankida parameetrite loendi.

// Reegli koostamisel... $rules = array("kasutajanimi" => "required|awesome:yes",); // Reeglis... Validator::register("vinge", function($attribute, $value, $parameters) ( return $value == $parameters; )

Selles näites saab teie valideerimisreegli argumentide parameeter massiivi, mis sisaldab ühte elementi: "jah".

Teine võimalus kohandatud valideerimisreeglite loomiseks ja salvestamiseks on Validatori klassi laiendamine. Veelgi enam, tänu Laraveli nimeruumidele saab see klass end laiendada. Seda tehes loote validaatorist uue versiooni, millel on kõik varasemad funktsioonid koos uute täiendustega. Soovi korral saate isegi mõne vaikemeetodi asendada. Vaatame näidet:

Esmalt looge Validatori klass, mis pärib klassist Laravel\Validator, ja asetage see rakendusse/teekidesse:

Oma klassi määratlemine:

Käivita näide »

Pange tähele, et skripti alguses kontrollime, kas vorm on esitatud kasutades $_SERVER["REQUEST_METHOD"]. Kui REQUEST_METHOD on POST, siis on vorm esitatud – ja see tuleks kinnitada. Kui seda ei ole esitatud, jätke kinnitamine vahele ja kuvage tühi vorm.

Ülaltoodud näites on aga kõik sisestusväljad valikulised. Skript töötab hästi ka siis, kui kasutaja andmeid ei sisesta.

Järgmine samm on sisestusväljade kohustuslikuks muutmine ja vajadusel veateadete loomine.


Eelmises artiklis lubasin kirjutada oma teegi võrdluse teiste saadaolevate lahendustega, nii et täna vaatleme valideerimist, kasutades Aura.Filter, Respect Validation, Sirius Validation ja Valitron.


Kujutagem ette, et meil on väljatöötamisel teatud avalik teenus, mis nõuab kasutajatelt registreerimist, et saada täielik juurdepääs kõikidele funktsioonidele. Seega sisaldab registreerimisvorm järgmisi välju:

  • nimi.
  • Peab sisaldama täpselt kahte sõna, kus esimene on kasutaja eesnimi ja teine ​​perekonnanimi.
  • sisse logida.
  • Kui väärtus edastatakse, peab see sisaldama ainult ladina tähti, sidekriipse ja allkriipse.
  • meili.

    • Peab sisaldama kehtivat e-posti aadressi.


    parool.

    Peab olema määratud ja olema kuni 64 tähemärgi pikkune.

    Määratleme reeglid, kasutades Aura\Filter\FilterFactory; $filter = (uus FilterFactory)->newSubjectFilter(); $filter->validate("nimi") ->isNotBlank() ->is("kaks_sõna") ->setMessage("Nimi peab koosnema kahest sõnast."); $filter->validate("login") ->isBlankOr("alnum") ->setMessage("Kui määrate sisselogimise, peab see sisaldama ainult ladina tähti."); $filter->validate("email") ->isNotBlank() ->is("email") ->setMessage("Palun sisesta kehtiv meiliaadress."); $filter->validate("parool") ->isNotBlank() ->is("strlenMax", 64) ->setMessage("Palun kirjutage oma parool."); $filter->validate("kokkulepitud") ->is("tagasihelistamine", function($subject, $field) ( return $subject->($field) === true; ))->setMessage("Sul on vaja nõustun teenusetingimustega.");

    Nagu näete, on reeglite kirjeldus üsna lihtne. Aura.Filter pakub tervet komplekti kasulikke reegleid ja mõnda neist kasutati ülaltoodud näites:

  • isNotBlank meetod.
  • Määrab, et väljal ei tohi olla nullväärtust.
  • alnum.
  • See reegel lubab kasutada ainult ladina tähti.
  • meili.

    • Ja see on nii selge :)


    strlenMax.

    Määrab, et väli ei tohi ületada meetodi is teise argumendiga määratud pikkust.


    tagasihelistamine.


    kasuta Aura\Filter\FilterFactory; $reeglid = [ "kaks_sõna" => function() ( tagastab uue kasutajanimereegel; ) ]; $filter = (uus FilterFactory($reeglid))->newSubjectFilter();

    Nüüd saab meie kahe_sõna reeglit kasutada samamoodi nagu mis tahes muud standardreeglit.

    Tagasiside

    Nagu mäletate, on meie kontrollitavad sissetulevad andmed täiesti kehtetud, kuna iga väli sisaldab vale väärtust või ei sisalda seda üldse. Seetõttu eeldatakse, et valideerimise tulemusena saame vead ja nende kohta vastavad teated.


    Valideerime Aura.Filteriga järgmiselt:


    $kehtiv = $filter->rakendus($andmed); if (! $kehtiv) ( $tõrkeid = $filter->getFailures(); $messages = $failures->getMessages(); )

    IN $sõnumeid massiivi kirjutatakse, nii et sõnumite kuvamiseks vajame kahte pesastatud foreach'i:


    Austa valideerimist

    Teine teek, mida võrdluses kasutasin, on suhteliselt populaarne lahendus nimega Respect Validation. Kuna inimesed usaldavad teda, siis arvan, et seal on midagi vaadata.


    Katse puhtuse huvides kasutame teekide võrdlemisel sama andmestikku, mis on määratletud alguses:


    kasuta Respect\Validation\Validator kui v; $data = [ "nimi" => "Albert", // Peab olema kaks sõna "login" => "@lbert", // "Keelatud" märk @ "email" => "midagi valesti", / / ​​Peab olema ole siin e-kiri "password" => "" // Parool pole üldse määratud // "kokkulepitud" pole massiivis kuna kasutaja ei märkinud kasti ];

    Reeglite määratlemine


    Nagu ka Aura.Filteri puhul, vajame kasutajanime jaoks oma valideerimisreeglit, nii et alustame sellest:

    nimeruum MinuNimeruum; kasutage Respect\Validation\Rules\AbstractRule; klass UserNameRule laiendab AbstractRule'i ( avalik funktsioon valide($input) ( return (bool) preg_match("/^+\s+$/u", $input); ) )


    Väliste reeglite API on peaaegu identne Aura.Filteriga, __invoke() maagia asemel kasutatakse ainult meetodit validate(). Mulle tundus see API lihtsam ja arusaadavam. Noh, see on Kontroliole lähemal :).


    Ma ei leidnud dokumentatsioonist selle kohta ühtegi mainimist, kuid lisaks reeglile endale peate selle jaoks looma oma eranditüübi. Erandklassi nimi peab koosnema reegliklassi nimest ja postfiksist

    Noh, lõpuks saame oma andmed kinnitada. Esiteks edastame oma uue reegli validaatorile, et ta sellest teaks ja saaksime seda edaspidi kasutada. Respect Validationis tehakse seda meetodi with() kutsumisega, edastades nimeruumi, milles ebastandardsed reeglid asuvad.


    v::with("Minunimeruum\\");

    Nüüd kõik nimeruumis asuvad mittestandardsed reeglid MinuNimeruum, tunneb valideerija ära. Järgmine samm on vajalike reeglite kirjeldamine ja valideerimine.


    v::attribute("nimi", v::userNameRule()) ->attribute("login", v::alnum("-_")) ->attribute("email", v::email()) ->attribute("parool", v::notEmpty()->stringType()->length(null, 64)) ->attribute("kokkulepitud", v::trueVal()) ->assert((objekt) $andmed);

    Pange tähele, kuidas me oma reeglit atribuudile rakendame nimi. Siin on reegliklassi nimi teisendatud validaatori meetodi nimeks. Ülejäänud reeglid on üldiselt intuitiivsed.


    Eraldi tasub mainida, miks me massiivi pakume $andmed objektile. Fakt on see, et Respect Validation aktsepteerib sisendina objekte, mitte massiive. Seda tuleks selle teegi arendamisel arvesse võtta.

    Tagasiside

    Erinevalt Aura.Filterist teeb Respect validaator erandi, kui valideerimine ebaõnnestub. Ja see erand sisaldab valideerimise veateateid. Seetõttu tuleks just näidatud näide kirjutada järgmiselt:


    try ( v::with("RespectValidationExample\\"); v::attribute("nimi", v::userNameRule()) ->attribute("login", v::alnum("-_")) - >attribute("email", v::email()) ->attribute("password", v::notEmpty()->stringType()->length(null, 64)) ->attribute("agreed", v::trueVal()) ->assert((objekt) $andmed ) püüdmine (NestedValidationException $ex) ( $messages = $ex->getMessages(); )

    Kasutades getMessages() saame kindla massiivi kõigist teadetest, mille validaator valideerimisprotsessi käigus kogus. Massiivi dumpingu abil saame midagi sellist:


    array(5) ( => string(29) "Andmete valideerimine ebaõnnestus %s jaoks" => string(60) "sisselogimine peab sisaldama ainult tähti (a-z), numbreid (0-9) ja "-_"" => string (25) "e-post peab olema kehtiv e-post" => string(26) "parool ei tohi olla tühi" => string(32) "Kohal lepitud atribuut peab olema olemas" )

    Saate sõnumeid enda omadeks muuta. Võib-olla sain ma sellest teegist kuidagi valesti aru, kuid see protsess ei tundunud mulle nii ilmne: käsitletud erandi puhul peate kasutama meetodit findMessages(), mille puhul määratlete sõnumid mitte atribuutide, vaid reeglite jaoks.


    $ex->findMessages([ "userNameRule" => "Kasutajanimi peab koosnema kahest sõnast.", "alnum" => "Meile ei meeldi teie sisselogimine.", "email" => "Teile ilmselgelt mitte tahad meile oma e-maili anda.", "notEmpty" => "Noh, kus on teie parool?", "agreed" => "Kahju, et te ei nõustu." ]);

    Ma ei tea, mis viga, aga paarist asjast ma ikka aru ei saa. Selle saame, kui määratleme reeglid ülaltoodud viisil:


    array(5) ( => string(40) "Kasutajanimi peab olema kahesõnaline." => string(31) "Meile ei meeldi teie sisselogimine." => string(25) "e-post peab olema kehtiv e-post" = > string(5) "Noh, kus on teie parool?" => string(9) "Kahju, et te ei nõustu."

    Nagu näete, meilivälja teadet ei rakendatud, jäi tavaline. Kuid indeksi 4 sõnum on vastupidine! Ja seda hoolimata sellest, et ma ei kasutanud mitte reegli nime, vaid välja nime. Kui ma oleksin kasutanud reegli nime (trueVal), oleks mu sõnum kuhugi kadunud. Selle raamatukogu kogenud kasutajate kommentaarid on väga teretulnud.

    Siriuse kinnitamine

    Ok, liigume edasi järgmise teegi juurde ja vaatame, kuidas see sarnaste ülesannetega toime tuleb.

    Reeglite määratlemine

    Taaskord peame määratlema kasutajanime reegli. Kirjutame selle umbes nii:


    class UserNameRule extends AbstractRule ( // Veateated const MESSAGE = "Kasutajanimi peab olema kahesõnaline."; const LABELED_MESSAGE = "(silt) peab olema kaks sõna."; avalik funktsioon valide($value, $valueIdentifier = null ) ( return (bool) preg_match("/^+\s+$/u", $value ) )

    Pange tähele lähenemisviiside erinevust juba käsitletud raamatukogudega võrreldes. Me defineerime kahte tüüpi sõnumeid konstantides, mitte ei kasuta atribuute, meetodeid või reegli argumente.


    Nüüd kirjeldame valideerimisloogikat:


    $validator = uus Validaator; $validator ->add("nimi", "nõutav | MyApp\Validation\Rule\UserNameRule") ->add("sisselogimine", "nõutav | alfanumhyphen", null, "Sisselogimine võib sisaldada ainult ladina tähti, sidekriipse ja alakriipse. ") ->add("email", "required | email", null, "Palun sisesta õige e-mail.") ->add("parool", "nõutav | maxlength(64)", null, "Teie parool, sir.") ->add("nõus", "nõutav | võrdne(true)", null, "Miks te ei nõustunud?");

    Nagu näete, on reeglistik väga lihtne ja loetav. Kirjeldamiseks kasutame horisontaalsete ribadega eraldatud nimesid. See lähenemine on sarnane Laravelis ja Kontrolios kasutatavale.


    Meetodi add() neljas argument kirjeldab valideerimise veateadet, mida Sirius kasutab, kui valideerimine ebaõnnestub. Miks me ei lisanud oma uuele reeglile sõnumit? Kasutajanime reegel?


    $validator->add("nimi", "nõutav | MinuReegel\Valideerimine\Reegel\KasutajanimiReegel")

    Seda seetõttu, et teateid on juba klassikonstantides kirjeldatud:


    class UserNameRule extends AbstractRule ( // Veateated const MESSAGE = "Kasutajanimi peab olema kahesõnaline."; ...

    Teine võimalus on kasutada validaatori enda meetodit addMessage().


    $validator->addMessage("e-post", "Palun sisesta kehtiv e-mail.");

    Pange tähele, et kohandatud reeglid tuvastatakse nende klassi täisnime järgi, samas kui Kontrolio's saate määrata aliase/aliase.

    Tagasiside

    Valideerimise teostamiseks kutsume valideerimismeetodit validate() , edastades sellele andmed:


    $data = [ "nimi" => "Albert", // Peab olema kaks sõna "login" => "@lbert", // "Keelatud" märk @ "email" => "midagi valesti", / / ​​Peab olema ole siin e-kiri "password" => "" // Parool pole üldse määratud // "kokkulepitud" pole massiivis kuna kasutaja ei märkinud kasti ]; $validator->validate($andmed);

    Erinevalt Respectist ei tee Sirius erandit, vaid tuleb lihtsalt tagasi vale. Valideerimise veateateid saab hankida valideerimismeetodi getMessages() kaudu. See tagastab atribuutide järgi rühmitatud vead, seega vajame vigade läbimiseks kahte foreach-tsüklit:


    foreach ($validator->getMessages() as $attribute => $messages) ( foreach ($messages as $message) ( echo $message->getTemplate() . "\n"; ) )

    Siin on $message klassi objekt Sirius\Validation\ErrorMessage, millel on meetod getTemplate(), mis tagastab just meile vajaliku sõnumi.

    Valitron Reeglite määratlemine

    Esimene erinevus: uue reegli lisamiseks ei pea te eraldi klassi looma. Võite lihtsalt kasutada sulgemist, mis tagastab tõeväärtusliku tulemuse.


    Kohandatud reeglite lisamiseks on Valitronil staatiline meetod addRule(), mille puhul on kaks esimest argumenti kohustuslikud ja kolmas on valikuline. Mulle meeldis see meetod, kuna siin on reegli identifikaator, loogika ja veateade märgitud ühes kohas.


    kasuta Valitron\Validator; Validator::addRule("kaks_sõna", function($field, $value) ( ​​return (bool) preg_match("/^+\s+$/u", $value); ), "Kasutajanimi peab koosnema täpselt kaks sõna ");

    Teine erinevus seisneb selles, kuidas reegleid atribuutidele rakendatakse. Kõigil eelnevatel juhtudel nägime, et atribuut on justkui esmane asi.


    Valitron valis teistsuguse tee ja seadis valideerimisreeglid esikohale. Reegleid kirjeldades näib, et rakendate nendele reeglitele atribuute ja mitte vastupidi.


    $validator = new Validaator($andmed); $validator ->rule("kaks_sõna", "nimi")->silt("") ->reegel("nõutav", [ "nimi", "sisselogimine", "e-post", "parool", "kokkulepitud" ] ) ->rule("slug", "login") ->rule("email", "email") ->rule("aktsepteeritud", "kokkulepitud");

    Nagu näitest näha, kirjutame meetodis rule() esmalt reegli nime ja alles siis märgime ära atribuudid, mis peavad sellele reeglile vastama. Täpsem näide on nõutav reegel, mis näitab, kuidas atribuudid sellele reeglile "kuuluvad".


    Valitron (nagu ka teised lahendused, mida oleme üle vaadanud) pakub standardseid veateateid. Kui kasutate neid lihtsalt, näete, et iga teade algab vastava atribuudi nimega.


    Valitron asendab teate tekstis atribuutide nimed isegi mittestandardsete veateadete kasutamisel. Seetõttu kasutasime atribuudi nime eemaldamiseks meetodit label() tühja stringiga.


    $validator->rule("kaks_sõna", "nimi")->silt("") Tagasiside

    Täpsemalt, mis puudutab valideerimist, ei erine Valitroni teegi API praktiliselt sellest, mida me artiklis juba nägime. Valideerimise läbiviimiseks kutsume valideerimismeetodit validate() :


    $validator->validate();

    Valideerimise veateateid saab hankida meetodi getErrors() abil:


    $validator->errors();

    Siin on kirjad atribuutide järgi grupeeritud samamoodi nagu Sirius Validationis, ainult et kirja jaoks pole eraldi klassi ja saame tavalise mitmemõõtmelise massiivi.


    foreach ($validator->errors() as $attribute => $messages) ( foreach ($messages as $message) ( echo $message . "\n"; ) ) Kontrolio

    Ja lõpuks, tänane viimane raamatukogu on minu enda arendus nimega Kontrolio.

    Reeglite määratlemine

    Jällegi, viiendat korda, loome kasutajanimele valideerimisreegli. Kõik on suhteliselt lihtne ja standardne:


    nimeruum MyProject\Validation\Rules; kasutage Kontrolio\Rules\AbstractRule; klass TwoWords laiendab Kontrolio\Rules\AbstractRule ( avalik funktsioon onValid($input = null) ( return (bool) preg_match("/^+\s+$/u", $input); ) )

    Nüüd loome tehase ja registreerime sellega reegli, kasutades meetodit extend():


    nimeruum MyProject; kasutada Kontrolio\Factory; kasutage MyProject\Validation\Rules\TwoWords; $factory = Kontrolio\Factory::getInstance()->extend();

    Pärast reegli registreerimist saame seda kasutada, sealhulgas nime järgi - kaks_sõna. Loome validaatori:


    $data = [ "nimi" => "Albert", // Peab olema kaks sõna "login" => "@lbert", // "Keelatud" märk @ "email" => "midagi valesti", / / ​​Peab olema ole siin e-kiri "password" => "" // Parool pole üldse määratud // "kokkulepitud" pole massiivis kuna kasutaja ei märkinud kasti ]; $reeglid = [ "nimi" => "kaks sõna", "login" => "mõnikord|alphadash", "e-post" => "e-post", "parool" => "pikkus: 1,64", "kokkulepitud" = > " vastu võetud" ]; $messages = [ "name" => "Kasutajanimi peab koosnema kahest sõnast.", "login" => "Meile ei meeldi teie sisselogimine.", "email" => "Sa ilmselt ei taha anda us your email .", "password" => "Noh, kus on teie parool?", "agreed" => "Kahju, et te ei nõustu." ]; $validator = $factory->make($andmed, $reeglid, $teated);

    Kirjeldasime reegleid, kasutades Laravelis kasutatava süntaksit, kuigi oleksime võinud kasutada paljusõnalisemat versiooni:


    $reeglid = [ "nimi" => new TwoWords, "login" => , "email" => new Email, "password" => new Length(1, 64), "agreed" => new Aktsepteeritud ];

    Tagasiside


    $validator->validate();

    Valideerimist alustatakse sama valide() meetodiga:



    Nüüd saame veateateid saada, kasutades ühte meetoditest getErrors() või getErrorsList(). Esimene meetod võimaldab keerukamat veaväljundit, teine ​​aga tagastab lame massiivi. Kasutades getErrors() saame väljastada selliseid sõnumeid:


    Ja getErrorsList() abil saate koostada lihtsama kirjade loendi:

    Alumine rida

  • Selles artiklis näitasin näiteid järgmiste teekide kasutamise kohta:
  • Aura.Filter
  • Siriuse kinnitamine
  • Austa valideerimist
  • Valitron

    • "Reaalse maailma näide" võib tunduda liiga lihtne. Pean nõustuma, sest tõepoolest, mõned raamatukogu võimalused jäid artiklist välja. Põhimõtteliselt saate huvi korral ise nende omadusi uurida.


    Igal raamatukogul on oma omadused ja varjuküljed, nii et ma arvan, et selle valimine on maitse küsimus ja väljakutse.


    Täname lugemise eest. Tehke õige valik.

    Sildid:

    • andmete valideerimine
    • php
    • jalgratta ehitamine
    Lisa sildid

    Laravel on varustatud lihtsa ja kasutajasõbraliku süsteemiga valideerimiseks (sisendandmete kontrollimiseks reeglite suhtes) ja veateadete vastuvõtmiseks – valideerimisklass.

    Valideerimise lihtsaim näide $validator = Validator::make(array("nimi" => "Dale"), array("name" => "required|min:5"));

    Esimene parameeter, mis antakse meetodile make, on testitavad andmed. Teine parameeter on nende suhtes kohaldatavad reeglid.

    Massiivide kasutamine reeglite määramiseks

    Mitu reeglit saab eraldada kas sirgjoonega (|) või olla üksikud massiivielemendid.

    $validator = Validaator::make(array("nimi" => "Dale"), array("nimi" => array("nõutav", "min:5")));

    Mitme välja valideerimine $validator = Validator::make(array("name" => "Dale", "password" => "bad passsword", "email" => " [e-postiga kaitstud]"), array("nimi" => "nõutav", "parool" => "nõutav|min:8", "e-post" => "nõutav|e-post|unikaalne"));

    Kui Validatori eksemplar on loodud, saab valideerimise läbiviimiseks kasutada meetodit nurjub (või läheb läbi).

    Kui ($validator->fails()) ( // Edastatud andmete kinnitamine ebaõnnestus)

    Kui Validator leiab vigu, saate selle teateid järgmiselt.

    $teated = $validator->messages();

    Samuti saate ilma sõnumiteta saada hulga reegleid, andmeid, mis ei läbinud kontrolli:

    $ebaõnnestunud = $validator->failed();

    Failide kontrollimine

    Klass Validator sisaldab mitmeid failide valideerimise algreegleid, nagu suurus , mime ja muud. Failide kontrollimiseks edastage failid lihtsalt koos muude andmetega.

    Konks pärast kinnitamist

    Pärast valideerimise lõpetamist saab Laravel käivitada teie sulgemisfunktsiooni, milles saate näiteks kontrollida midagi erilist või lisada mingi veateate. Selleks kasutatakse meetodit after():

    $validator = Validaator::make(...); $validator->after(function($validator) ( if ($this->somethingElseIsInvalid()) ( $validator->errors()->add("field", "Selle väljaga on midagi valesti!"); ) )); if ($validator->fails()) ( // )

    Vajadusel saate lisada mitu järelsõna.

    Valideerimine kontrollerites

    Täieliku valideerimiskoodi kirjutamine iga kord, kui peate andmeid kinnitama, on ebamugav. Seetõttu pakub Laravel selle protseduuri lihtsustamiseks mitmeid lahendusi.

    Põhikontroller App\Http\Controllers\Controller sisaldab tunnust ValidatesRequests, mis sisaldab juba valideerimismeetodeid:

    /** * Salvestage blogipostitus.

    * * @param Request $request * @return Response */ public function store(Request $request) ( $this->validate($request, [ "title" => "required|unique|max:255", "body") => "nõutav", ] // )

    Kui valideerimine läbib, jätkatakse koodi täitmist. Kui ei, siis kuvatakse Illuminate\Contracts\Validation\ValidationException. Kui te seda erandit ei taba, püüab raamistik selle kinni, täidab flash-muutujad valideerimise veateadetega ja suunab kasutaja vormiga eelmisele lehele – ise!

    AJAX-i päringu korral ümbersuunamist ei toimu;

    Ülaltoodud kood on sarnane sellele:

    /** * Salvestage blogipostitus.

    * * @param Request $request * @return Response */ public function store(Request $request) ( $v = Validator::make($request->all(), [ "title" => "nõutav|unikaalne|max :255", "body" => "nõutav", ]); if ($v->fails()) (tagasi redirect()->back()->with Errors($v->errors()); ) // )

    Viga vormingu muudatused

    Kui soovite kohandada ümbersuunamise ajal seansi flash-muutujatesse salvestatud valideerimise veateateid, alistage oma kontrolleris meetod formatValidationErrors:

    /** * (@inheritdoc) */ kaitstud funktsiooni formaatValidationErrors(\Illuminate\Validation\Validator $validator) ( tagasta $validator->errors()->all(); ) Päringu valideerimine

    Keerulisemate valideerimisstsenaariumide rakendamiseks võib olla mugav kasutada niinimetatud vormitaotlusi. Need on spetsiaalsed HTTP päringu klassid, mis sisaldavad valideerimisloogikat. Nad töötlevad päringu enne, kui see jõuab vastutava töötlejani.

    Päringuklassi loomiseks kasutage käsku make:request artisan:

    /** * Hankige päringule kehtivad valideerimisreeglid.

    * * @return array */ public function rules() ( return [ "title" => "required|unikaalne|max:255", "body" => "nõutav", ]; )

    Selleks, et raamistik päringu enne kontrollerit kinni saaks, lisage see klass nõutava kontrolleri meetodi argumentidele:

    Päringu valideerimise õigel kasutamisel võite olla kindel, et teie kontrollerid sisaldavad alati ainult kinnitatud sisendandmeid!

    Ebaõnnestunud valideerimise korral täidab raamistik flash-muutujad valideerimisvigadega ja tagastab ümbersuunamise eelmisele lehele. AJAX-i päringu korral tagastatakse vastus koodiga 422 ja JSON-i koos valideerimisvigadega.

    Juurdepääsu kontroll

    Vormipäringu klassid sisaldavad ka autoriseerimismeetodit. Selle meetodi abil saate kontrollida, kas kasutajal on lubatud seda toimingut teha, antud ressurssi värskendada. Näiteks kui kasutaja üritab postituse kommentaari muuta, kas ta on selle autor?

    /** * Määrake, kas kasutajal on õigus seda päringut esitada.

    * * @return bool */ public function authorize() ( $commentId = $this->route("comment"); return Comment::where("id", $commentId) ->where("kasutaja_id", Auth: :id())->olemas();

    Pange tähele ülaltoodud route() meetodi kutset. See meetod annab teile juurdepääsu marsruudil määratletud URL-is (antud juhul (kommentaar)) olevatele parameetritele:

    Marsruut::post("kommentaar/(kommentaar)");

    Kui autoriseerimismeetod tagastab vale, genereerib raamistik vastuse HTTP koodiga 403 ja saadab selle kohe. Kontrolleri meetodit ei käivitata.

    /** * Määrake, kas kasutajal on õigus seda päringut esitada.

    * * @return bool */ public function authorize() ( return true; )

    Flash-muutujate tõrkevormingu muudatused

    Esimese sõnumi hankimine väljale echo $messages->first("email"); Kõigi kirjade hankimine ühele väljale foreach ($messages->get("email") kui $message) ( // ) Kõigi väljade kõigi kirjade hankimine foreach ($messages->all() kui $message) ( // ) Valideerimine sõnumi olemasolu kohta väljale if ($messages->has("email")) ( // ) Vea vastuvõtmine määratud vormingus echo $messages->first("email", "");

    Märkus. Vaikimisi on sõnumid vormindatud viisil, mis sobib Twitter Bootstrapiga.

    Kõigi kirjade toomine etteantud vormingus foreach ($messages->all("
  • :sõnum
    • ") kui $sõnum) ( // ) Vead ja mustrid

    Kui olete valideerimise lõpetanud, vajate lihtsat viisi vigade mallile edastamiseks. Laravel võimaldab seda mugavalt teha. Näiteks on meil järgmised marsruudid:

    Route::get("register", function() ( return View::make("kasutaja.register"); )); Route::post("register", function() ( $reeglid = array(...); $validator = Validator::make(Input::all(), $reeglid); if ($validator->fails( )) ( return redirect("register")->withErrors($validator); ) );

    Pange tähele, et kui kontrollid ebaõnnestuvad, edastame Validaatori objekti ümbersuunamisobjektile, kasutades meetodit withErrors. See meetod salvestab veateated ühekordse seansi välklambi muutujatesse, muutes need järgmise päringu jaoks kättesaadavaks.

    Kuid pange tähele, et me ei edasta View::make("user.register"); $errors muutujad mallile. Laravel ise kontrollib seansi andmetes muutujate olemasolu ja saadab need automaatselt mallile, kui need on saadaval. Seetõttu on oluline meeles pidada, et muutuja $errors on kõikidele teie mallidele alati ja iga taotluse korral saadaval. . See võimaldab eeldada, et muutuja $errors on alati defineeritud ja seda saab ohutult kasutada. Muutuja $errors on klassi MessageBag eksemplar.

    Seega saate pärast ümbersuunamist kasutada mallis automaatselt määratud muutujat $errors:

    Nimega MessageBag

    Kui teil on lehel mitu vormi, saate valida MessageBag objekti nime, milles veatekstid tagastatakse, et saaksite neid soovitud vormi jaoks õigesti kuvada.

    Return redirect("register")->withErrors($validator, "login");

    Hankige veatekst MessageBagist koos nimega sisselogimisega:

    Valideerimisreeglid

    Allpool on loetelu kõigist saadaolevatest reeglitest ja nende funktsioonidest:

    vastu võetud

    Väljal peab olema väärtus jah, sisse või 1 . See on kasulik reeglite ja litsentside aktsepteerimise kontrollimiseks.

    aktiivne_url

    Väli peab olema kehtiv URL, millele pääseb juurde funktsiooni checkdnsrr kaudu.

    pärast: kuupäev

    Väljal peab kuupäev olema hilisem kui kuupäev

    alfa

    Väli peab sisaldama ainult tähestikulisi märke.

    alfa_kriips

    Väli peab sisaldama ainult tähemärke, numbreid, allkriipse (_) ja sidekriipse (-).

    alfa_num

    Väli peab sisaldama ainult tähemärke ja numbreid.

    massiivi

    Väli peab olema massiiv.

    enne: kuupäev

    Väljal peab olema kuupäev varasem kui kuupäev. Stringid teisendatakse kuupäevadeks funktsiooni strtotime abil.

    vahel: min,max

    Välja suurus peab olema vahemikus min juurde max. Stringe, numbreid ja faile käsitletakse sarnaselt suurusereegliga.

    tõeväärtus

    Väli peab olema tõeväärtus. Lubatud väärtused on tõene , false , 1 , 0 , "1" ja "0" .

    kinnitatud

    Välja väärtus peab ühtima selle nimega välja väärtusega, millele lisandub foo_confirmation . Näiteks kui parooliväli on märgitud, siis tuleb sisendisse edastada väärtusele sobiv väli password_confirmation.

    kuupäev

    Väljal peab olema kehtiv kuupäev vastavalt funktsioonile strtotime.

    date_format: vormingus

    Väli peab vastama kuupäeva vormingule vormingus vastavalt funktsioonile date_parse_from_format.

    erinev: valdkonnas

    Kontrollitava välja väärtus peab erinema välja väärtusest valdkonnas.

    meili

    Väljal peab olema kehtiv e-posti aadress.

    olemas: laud,veerus

    Väli peab olemas olema määratud andmebaasi tabelis.

    Lihtne kasutada:

    "osariik" => "olemas: osariigid"

    Välja nime määramine tabelis:

    "osariik" => "olemas: olekud, lühend"

    Samuti saate määrata rohkem tingimusi, mis lisatakse päringule "WHERE":

    "email" => "olemas:personal,e-post,konto_id,1"

    pilt

    Üleslaaditav fail peab olema jpeg-, png-, bmp-, gif- või svg-vormingus pilt.

    sisse: foo,baar,...

    Välja väärtus peab olema üks järgmistest ( foo, baar jne).

    täisarv

    Väljal peab olema kehtiv täisarv.

    ip

    Väljal peab olema kehtiv IP-aadress.

    max: väärtus

    Välja väärtus peab olema väiksem või võrdne väärtus

    miimid: foo,baar,...

    Üleslaaditud faili MIME-tüüp peab olema üks loetletud tüüpidest.

    Lihtne kasutada:

    "foto" => "mimes: jpeg, bmp, png"

    min: väärtus

    Välja väärtus peab olema suurem kui väärtus. Stringe, numbreid ja faile käsitletakse sarnaselt reegliga.

    not_in: foo,baar,...

    Välja väärtus ei tohi olla üks järgmistest ( foo, baar jne).

    numbriline

    Väljal peab olema kehtiv arv- või murdosa väärtus.

    regex: muster

    Väli peab vastama antud regulaaravaldisele.

    Hoiatus. Selle reegli kasutamisel peate võib-olla loendama teisi reegleid massiivielementidena, eriti kui avaldis sisaldab torumärki (|).

    nõutud

    Testitav väli peab olema olemas ja selle väärtus ei tohi olla tühi.

    kohustuslik_kui: valdkonnas,väärtus,...

    Testitav väli peab olema olemas ja teise välja puhul peab selle väärtus olema mittetühi valdkonnas olemas ja sellel on mis tahes tähendus väärtus.

    kohustuslik_koos: foo,baar,...

    Vähemalt üks loetletud väljadest on olemas ja selle väärtus ei ole tühi ( foo, baar jne).

    Nõutud_with_all: foo,baar,...

    Testitav väli peab olema olemas ja selle väärtus ei tohi olla tühi, kuid ainult siis, kui kõik loetletud väljad on olemas ja nende väärtus ei ole tühi ( foo, baar jne).

    kohustuslik_ilma: foo,baar,...

    Kontrollitav väli peab olema olemas ja selle väärtus ei tohi olla tühi, kuid ainult siis, kui vähemalt üks loetletud väljadest puudub või sellel on tühi väärtus ( foo, baar jne).

    kohustuslik_ilma_kõik: foo,baar,...

    Kontrollitav väli peab olema olemas ja selle väärtus ei tohi olla tühi, kuid ainult siis, kui kõik loetletud väljad puuduvad või neil on tühjad väärtused ( foo, baar jne).

    sama: valdkonnas

    Väljal peab olema sama väärtus kui väljal valdkonnas.

    suurus: väärtus

    Väli peab ühtima väärtus suurus. Stringide puhul on see pikkus, numbrite puhul arv, failide puhul suurus kilobaitides.

    ajavöönd

    Väli peab sisaldama ajavööndi identifikaatorit, üht neist, mis on loetletud php-funktsioonis timezone_identifiers_list

    ainulaadne: laud,veerus,välja arvatud,idColumn

    Välja väärtus peab antud andmebaasi tabelis olema kordumatu. Kui veergu pole määratud, kasutatakse välja nime.

    Lihtkasutus "email" => "unikaalne:kasutajad" Välja nime määramine tabelis "email" => "unikaalne:kasutajad,e-posti aadress" Konkreetse ID ignoreerimine "email" => "unikaalne:kasutajad,e-posti aadress,10" Lisamine lisatingimused

    Samuti saate määrata rohkem tingimusi, mis lisatakse päringule "WHERE":

    "email" => "unikaalne:kasutajad,e-posti aadress,NULL,id,konto_id,1"

    Ülaltoodud reegli kohaselt kaasatakse tšekki ainult need read, mille konto_id on 1.

    url

    Väljal peab olema kehtiv URL.

    Märkus. Kasutatakse PHP funktsiooni filter_var

    Tingimuslikud reeglid

    Mõnikord peate teatud välja kinnitama ainult siis, kui see on sisendandmetes olemas. Selleks lisage mõnikord reegel:

    $v = Validaator::make($data, array("email" => "mõnikord|nõutav|e-post"));

    Ülaltoodud näites käivitab meiliväli valideerimise ainult siis, kui $data["email"] on olemas.

    Keerulised tingimusreeglid

    Mõnikord soovite, et väljal oleks väärtus ainult siis, kui mõnel teisel väljal on väärtus, näiteks suurem kui 100. Või võite nõuda ainult kahe välja väärtust, kui on määratud ka kolmas. Seda on lihtne saavutada tingimuslike reeglitega. Esmalt looge Validaatori objekt staatiliste reeglitega, mis ei muutu kunagi:

    $v = Validaator::make($data, array("email" => "nõutav|e-post", "mängud" => "nõutav|numbriline"));

    Oletame nüüd, et teie taotlus on kirjutatud mängude kogujatele. Kui registreerub kollektsionäär, kellel on rohkem kui 100 mängu, siis tahame neilt küsida, miks neil nii palju vaja on. Näiteks võib neil olla pood või neile meeldib neid lihtsalt koguda. Nii et sellise tingimusliku reegli lisamiseks kasutame Validaatori meetodit.

    $v->sometimes("reason", "required|max:500", function($input) ( return $sisend->mängud >= 100; ));

    Selle meetodi esimene parameeter on kontrollitava välja nimi. Teine parameeter on reegel, mille tahame lisada, kui läbitud sulgemisfunktsioon (kolmas parameeter) tagastab tõese . See meetod võimaldab teil hõlpsasti luua keerulisi sisendi kontrollimise reegleid. Saate lisada samu tingimusreegleid isegi mitmele väljale korraga.

    $v->sometimes(array("põhjus", "kulu"), "nõutav", function($input) ( return $sisend->mängud >= 100; ));

    Märkus. Sulgurile edastatud parameeter $input on objekt Illuminate\Support\Fluent ja seda saab kasutada kontrollitud sisendi ja failide lugemiseks.

    Enda veateated

    Saate vaiketeadete asemel edastada oma veateateid. Selleks on mitu võimalust.

    Teie kirjade edastamine Validaatorile $messages = array("required" => "Välja:atribuut tuleb täita.",); $validator = Validaator::make($sisend, $reeglid, $teated);

    Märkus: line:attribute asendatakse kontrollitava välja nimega. Võite kasutada ka muid muutujastringe.

    Teiste stringimuutujate kasutamine $messages = array("same" => "Atribuutide:attribute ja:other väärtused peavad ühtima.", "size" => "Välja:atribuut peab olema täpselt:suurus.", "vahel " => "Atribuudi väärtus peab olema alates:min kuni:max.", "in" => "Väljal:attribute peab olema üks järgmistest väärtustest: :values",); Oma sõnumi täpsustamine konkreetse välja jaoks

    Mõnikord peate võib-olla täpsustama oma sõnumi eraldi välja jaoks.

    $messages = array("email.required" => "Me peame teadma teie e-posti aadressi!",);

    Enda sõnumite määramine lokaliseerimisfailis

    Samuti on võimalik valideerimissõnumeid määratleda lokaliseerimisfailis, selle asemel, et neid otse Validaatorile edastada. Selleks lisage sõnumid lokaliseerimisfaili app/lang/xx/validation.php kohandatud massiivi.

    "custom" => array("email" => array("required" => "Me peame teadma teie e-posti aadressi!",),),

    Oma valideerimisreeglid Registreerige oma valideerimisreegel

    Laraveliga on kaasas palju kasulikke reegleid, kuid võib-olla peate ise looma. Üks viis kohandatud reegli registreerimiseks on meetod Validator::extend.

    Validator::extend("foo", function($attribute, $value, $parameters) ( return $value == "foo"; }); !}

    Märkus. Reegli nimi peab olema formaadis_alakriipsudega.

    Läbitud sulgemisfunktsioon saab kolm parameetrit: kontrollitava välja nimi $attribute , välja $value väärtus ja reeglile edastatud parameetrite massiiv $parameters.

    Funktsiooni asemel saate laiendamismeetodile edastada viite klassimeetodile:

    Validaator::extend("foo", "FooValidator@validate");

    Pange tähele, et uue reegli jaoks peate määratlema ka veateate. Seda saate teha, edastades selle stringide massiivina Validatorile või kirjutades selle lokaliseerimisfaili.

    Validaatori klassi laiendamine

    Selle asemel, et kasutada saadaolevate reeglite komplekti laiendamiseks sulgemisfunktsioone, saate laiendada Validatori klassi ennast. Selleks loo klass, mis pärib Illuminate\Validation\Validator . Saate lisada uusi valideerimismeetodeid, alustades nende nime sõnadega validate .



    SEOTUD ARTIKLID