Dovada prostii. Validare simplă pentru formularul jquery

Ați fost nevoit vreodată să căutați scripturi și pluginuri pentru a valida formulare și containere personalizate? Când nu este folosită eticheta „form”? Și când este necesar să se verifice corectitudinea câmpurilor în orice moment și să nu se utilizeze mecanisme conceptuale cablate? Puteți argumenta mult timp cu privire la necesitatea de a respecta standardele și de a sprijini trimiterea datelor printr-o reîncărcare completă a paginii. Cu toate acestea, astăzi, majoritatea aplicațiilor web nu mai pot fi imaginate fără suport pentru javascript. Dezactivați javascript și serviciile devin inutile, chiar dacă vă puteți înregistra, autentifica și naviga în mai multe pagini.

Notă: Ideea este că eticheta de formular este destinată să trimită date folosind metoda POST și necesită o reîncărcare a paginii sau a cadrului. Totuși, cu cât mergi mai departe, cu atât se folosește mai rar această metodă și cu atât se trimit mai des aceleași date de către ajax, căruia, în general, nu îi pasă ce etichete au fost folosite înainte de a genera datele.

Notă: Desigur, există giganți de internet care trebuie să accepte diferite metode și moduri. Dar, în cazul lor, chiar și cel mai mic procent înseamnă milioane de utilizatori.

Să ne uităm la pluginurile existente pentru validarea formularelor folosind jQuery

Notă de subsol: Numele pluginurilor nu este în mod deliberat dat în articol, deoarece scopul nu este de a critica aplicații specifice, ci de a crea un instrument simplu care poate fi aplicat formelor arbitrare.

Majoritatea scripturilor existente pentru validarea formularelor au câteva limitări serioase, care nu pot fi întotdeauna ocolite cu simple stub-uri sau care vor necesita o rutină lungă din partea dvs.

Legare tare la eticheta „form”. Prin urmare, dacă aveți câteva zeci de formulare construite pe div-uri sau tabele și sunteți hotărât să utilizați soluții populare, atunci pregătiți-vă să petreceți mult timp adăugând manual etichete și ajustând scripturi și stiluri.
Legarea la numele câmpurilor. Unii validatori sunt legați de numele câmpurilor, ceea ce înseamnă că scrieți foi de JavaScript pentru fiecare caz. Dacă acest lucru nu este înfricoșător pentru câteva forme, atunci pentru o colecție înseamnă deja generare manuală de cod îndelungată.
Fără validare la cerere, fără a fi necesară inițializarea pluginului. Nu puteți verifica manual formularul o dată. Trebuie să creați corect formularul (adevărat, acest lucru este necesar peste tot, dar nu acesta este scopul), apoi să inițializați motorul de plugin, care va lega neapărat o grămadă de scripturi la elementele formularului. Și după aceea, apelați metoda isValid, care nu este întotdeauna disponibilă în mod explicit. Uneori, această metodă trebuie să fie „cumva” scoasă din mecanismele interne.

Notă: Pe de o parte, este destul de logic ca legarea să meargă la eticheta de formulare, deoarece pluginurile au apărut „după”. Pe de altă parte, scripturile de astăzi vă permit să creați și să colectați rapid date din orice formă arbitrară. Cu un anumit nivel de curiozitate și persistență, puteți crea cu ușurință un formular cu doar etichete „span”(div) și „input” și va arăta exact la fel ca toate celelalte.

Desigur, majoritatea pluginurilor au o mulțime de caracteristici frumoase. Dar, în general, se rezumă la:

Disponibilitatea validatoarelor preconfigurate. În esență, expresii regulate gata făcute
Verificarea diferitelor tipuri. Inclusiv verificarea datelor din mai multe câmpuri (de exemplu, confirmarea parolei etc.)
Posibilitatea de a crea propriile validatoare
Animație frumoasă cu ferestre pop-up și sfaturi care apar

Dacă animația frumoasă anterioară și un mecanism sofisticat în sine erau argumente destul de convingătoare în favoarea utilizării unuia sau altui plugin, astăzi acest lucru nu mai este în întregime adevărat. Găsirea expresiilor regulate gata făcute pentru verificarea celor mai cunoscute tipuri de câmpuri nu este o sarcină foarte dificilă. Un număr mare de tipuri diferite de verificări nu mai sunt la fel de relevante ca înainte. Dorința de minimalism în forme duce la o reducere a numărului de verificări. Încercați să vă amintiți ultima dată când ați întâlnit verificări diferite de validarea textului, excluzând repetarea parolei? Necesitatea de a vă crea propriile validatoare, având în vedere abundența de expresii regulate gata făcute, devine din ce în ce mai puțin obișnuită. Animațiile frumoase și sfaturile instrumente din Windows au entuziasmat cândva imaginația și au oferit aplicațiilor farmec și unicitate. Cu toate acestea, astăzi, este suficient să marcați câmpurile binecunoscute în roșu, iar majoritatea utilizatorilor înșiși vor înțelege ce anume trebuie corectat.

Notă: Nu presupuneți că pluginurile sunt inutile și că nu merită folosite. Există destul de multe situații în care scrierea codului de la zero va costa mult mai mult decât utilizarea pluginurilor gata făcute. Acest articol tratează acele situații în care limitările pluginurilor fie creează obstacole, fie avantajele acestora nu depășesc cu mult costul timpului și efortului.

Scriem un script pentru validarea formularelor personalizate folosind jQuery

Notă de subsol: nu trebuie să scrieți o aplicație de la zero; un exemplu cu un script și stiluri gata făcute poate fi descărcat din linkul de la sfârșitul articolului.

Înainte de a vă implementa mecanismul, trebuie să determinați capacitățile și limitările acestuia:

. Ar putea fi span, div, table și așa mai departe. Important este că formularul este un element DOM separat. Stocarea datelor din 15 containere diferite nu mai este o formă obișnuită, cu orice imaginație.
Scriptul trebuie să accepte atât validarea din mers, cât și validarea aleatorie a oricăror formulare sau chiar câmpuri individuale, fără legături de script sau alte restricții.
Pluginul ar trebui să fie simplu atât în ceea ce privește configurarea și lansarea, cât și în ceea ce privește organizarea și codul.
Trebuie să fie extins în orice moment. Adăugați validatori. Încorporați mesaje pop-up. Și mult mai mult.
Configurarea validatoarelor de teren ar trebui să fie nu numai universală, ci și simplă

Și, în primul rând, să trecem la cel mai important lucru, la definirea mecanismului principal - apelarea verificărilor pentru câmpuri. La urma urmei, algoritmul selectat va afecta direct nu numai complexitatea configurației, ci și numărul de litere pe care va trebui să le tastați pentru a o lansa corect. Pe baza cerințelor compilate, cel mai simplu mecanism ar fi apelarea validatorilor pe baza prezenței claselor de stil în atributul „clasă”. În primul rând, stilurile sunt ușor de stabilit și nu impun restricții serioase. În al doilea rând, acestea pot fi adăugate și îndepărtate în orice moment. În al treilea rând, dacă utilizați deja unele clase de stil în proiect, atunci redenumirea acestora, atât în scriptul de validare, cât și în câmpuri, poate fi rezolvată prin simpla înlocuire a unei linii cu alta, fără a schimba radical codul.

Notă: Din păcate, chiar și abundența de verificări javascript și de gestionare a evenimentelor nu va salva nicio aplicație de nevoia de a valida datele de pe partea serverului. Amintiți-vă că puteți compune cu ușurință și trimite datele în aproape orice browser.

Să creăm un proiect de testare

Acum, să creăm un proiect de testare cu următoarea structură:

css - director cu stiluri
- template.css - fișier de stil
imagini - director pentru imagini pentru stiluri de validare
- icon-fail.png - pictogramă pentru un câmp completat incorect
- icon-ok.png - pictogramă pentru un câmp completat corect
js - director pentru scripturi
- jquery-validate.js - script personalizat de validare a formularelor
index.html - formular de testare

Notă: Când creați structura proiectului de testare, încercați să o aduceți cât mai aproape de structura proiectului real. Acest lucru vă va ajuta să identificați problemele legate de structură în timpul dezvoltării.

Fișier de stil - template.css

Cea mai mare parte a fișierului de stil este ocupată de stilurile formularului în sine, astfel încât exemplul demonstrativ să pară atractiv. Pentru pluginul în sine, sunt necesare doar primele două reguli „.field-input.input-ok” și „.field-input.input-error”

Notă: Încercați să adăugați cel puțin un design minim chiar și la formularele de testare. Cu cât proiectul de testare este mai aproape de cel real, cu atât este mai mare șansa de a detecta erori și probleme ascunse. De exemplu, imaginea din „fondul” pentru câmpurile bifate va ocupa o parte a câmpului. Aceasta înseamnă că câmpurile cu cantități mari de text trebuie să fie stilate cu indentare.

Field-input.input-ok( background: url(../images/icon-ok.png) no-repeat dreapta centru #e3ffe5; chenar: 1px solid #96b796; line-height: 19px; ) .field-input. input-error( fundal: url(../images/icon-fail.png) fără repetare centru dreapta #ffebef; chenar: 1px roșu continuu;line-height: 19px; ) .clear(clear:both;)body( lățime: 1000px;margin:auto;) .form(float: stânga;lățime: 490px;margin-dreapta: 5px;) .form .header(culoare: albastru;dimensiune font: 20px;familie font: Georgia;margin- jos: 10px) .form .label(padding: 5px;padding-left: 0px;font-size: 18px;) .form .field(margin-bottom: 10px;) .form .field-input(padding: 5px;font -size: 15px;width: 400px;) .form .save-button(cursor: pointer;margin-top: 10px;culoare: white;background: green;border: 1px solid #ddd;padding: 5px 10px;) .form .buton-salvare:hover(fond: rgb(60, 176, 60);)

Fișier script de validare a formularelor personalizate jQuery - jquery-valiate.js

Deoarece scriptul este destul de simplu și toate informațiile necesare sunt descrise în detaliu în comentarii, fișierul este dat în întregime:

(funcție (parentObject) ( // Verificați reinițializarea dacă (parentObject.validation) revine; /////////////////////////////// ///////////////// // Creați o interfață comună pentru validarea formularelor ///////////////////////// / /////////////////////// parentObject.validation = ( _defaultOptions: ( // Container. Poate fi un selector sau un container de elemente: "", // Selector pentru câmpul de căutare fieldSelector: ".field-input", // Verificare online liveCheck: true, // Selector pentru butoanele de trimitere submitSelector: ".save-button", // Handler care este apelat după validarea cu succes submitHandler: null, // Clasa de câmpuri cu erori errorClass: "input-error", // Clasa de câmpuri valide okClass: "input-ok", // Lista validatorilor // Notă: deoarece validatorul pentru câmpurile goale este plasat separat, // apoi gol șirurile din alte validatoare sunt considerate validatoare trecute: ( „necesar”: funcția (str) ( returnează lungimea str. > 0; ), „numeric”: funcție (str) ( var regExp = new RegExp("\\-?\ \d+((\ \.|\\,)\\d(0,))?"); returnează regExp.test(str) || !str; ), "alpha": funcție (str) ( var regExp = new RegExp("^[a-яА-ЯеАоa-zA-Z\\s]+$"); return regExp.test(str) || !str; ), „alfanumeric”: funcție (str) ( var regExp = new RegExp("^[a-zA-Yayoa-zA-Z0-9\\s]+$"); return regExp.test(str) || ! str; ), „date”: funcție (str) ( var regExpISO = new RegExp ("(19|20)\\d\\d-((0|1)-(0|\\d)|(0| 1)-30|(0|1)-31)"), regExpRU = new RegExp ("((0|\\d)\\.(0|1)|30\\.(0|1)|31 \\.(0|1))\\.(19|20)\\d\\d"); return (regExpISO.test(str) | regExpRU.test(str)) || !str; ), " datetime": function (str) ( var regExpISO = new RegExp ("(19|20)\\d\\d-((0|1)-(0|\\d)|(0|1)-30| (0|1)-31) (\\d+):(\\d+)"), regExpRU = new RegExp ("((0|\\d)\\.(0|1)|30\\.( 0|1)|31\\.(0|1))\\.(19|20)\\d\\d (\\d+):(\\d+)"); return (regExpISO.test(str ) | regExpRU.test(str)) || !str; ), "timp": funcție (str) ( var regExp = new RegExp ("(\\d+):(\\d+)"); return regExp.test (str) || !str; ), "cifră": funcție (str) ( var regExp = new RegExp ("^+$"); return regExp.test(str) || !str; ), "parolă": function (str) ( var regExp = new RegExp("^[a-яА-ЯеЁа-zA-Z0-9\\s]+$"); returnează regExp.test(str) || !str; ), „e-mail”: funcție (str) ( var regExp = new RegExp("^(+\\.)* +(\\.+)*\\.(2,6)$"); returnează regExp.test (str) || !str; ), "url": funcție (str) ( var regExp = new RegExp ("^((https?|ftp)\\:\\/\\/)?((1)) ((\\.)|())*\\.((2,6))(\\/?)$"); return regExp.test(str) || !str; ) ) ), // Funcție initialization // Creează un cadru pentru formularele init: function (_options) ( var options = $.extend((), this. _defaultOptions, (_opțiuni || ())), self = this; // Dacă este specificat un container (sau selectorul acestuia), // precum și un selector pentru câmpuri, // apoi creați un cadru if (options.container && options.fieldSelector) ( // Dacă există un selector pentru butoane, // apoi difuzăm handlerul pentru a face clic pe if (options.submitSelector) ( $(options.container).find(options.submitSelector).on(„clic”, funcția () ( if (self.isValid(opțiuni)) ( // Dacă este specificat un handler, după validarea cu succes, // apoi îl apelați if (typeof (options.submitHandler) === „funcție”) options.submitHandler(); return true; ) else ( return false; ) )) ; ) // Dacă este necesară verificarea online dacă (options.liveCheck) ( // Parcurgeți toate câmpurile și verificați validitatea $(options.container).find(options.fieldSelector).each(function (cnt, item) ( $(item).on(„clic”, funcția () ( self.validItem($(element), opțiuni) )).on(„blur”, funcția () ( self.validItem($(element), opțiuni) )).on(„schimbare”, funcția () ( self.validItem($(articol), opțiuni) )).on(„keyup”, funcția () ( self.validItem($(articol), opțiuni) )) ; )); ) ) ), // Funcție pentru validarea unui singur element validItem: function (item, _options) ( var options = $.extend((), this._defaultOptions, (_options || ())), classList = $(item) .attr("class").split(/\s+/), validResult = true; // Parcurgem toate clasele din atributul "class", // si daca gasim o clasa cu numele validatorului, apoi numiți-o $.each(classList, function (index, cl) ( // Verificați câmpurile duplicate, // numele câmpului care ar trebui repetat este indicat în atributul „confirm-field” dacă (cl === "confirmfield") ( validResult &= ($(options.container ).find("").val() == $(item).val()); ) // În caz contrar, verificați normal else if (typeof (opțiuni) .validators) === „funcție”) ( validResult &= opțiuni .validators(item.val()); ) )); // Dacă câmpul nu a trecut validarea dacă (!validResult) $(item).addClass( options.errorClass).removeClass(options.okClass); // Câmpul a trecut validarea altfel $(item).addClass(options.okClass).removeClass(options.errorClass); // Returnează rezultatul returnat validResult; ), // Verificarea tuturor câmpurilor de formă liberă esteValid: function (_options) ( var options = $.extend((), this._defaultOptions, (_options || ())), validResult = true, self = this; // Dacă este specificat un container (sau selectorul acestuia), precum și un selector pentru câmpuri, // apoi verificăm toate câmpurile dacă (options.container && options.fieldSelector) ( $(options.container).find(options.fieldSelector). each(function ( cnt, item) ( validResult &= self.validItem($(item), options); )); ) // Returnează rezultatul verificării return validResult; ), // Şterge câmpurile tuturor claselor de stil care au fost adăugate în timpul verificării clear: function (_options) ( var options = $.extend(true, (), this. _defaultOptions, (_opțiuni || ())); if (options.container && options.fieldSelector) ( $(options.container).find(options.fieldSelector).removeClass(options.errorClass).removeClass(options.okClass); ) ) ))(fereastra);

Pagina de testare cu formulare - index.html

Pagina de testare este destul de simplă. Spațiul său principal este ocupat de codul html al formularelor demo în sine. Apelarea pluginului în sine pentru a crea validarea din mers, precum și lansarea validării manuale făcând clic pe un buton, durează doar câteva rânduri.

$(funcția () ( // Validarea prin mecanism window.validation.init(( container: ".form-1", submitHandler: function () ( alert("Validarea primului formular a avut succes!"); ) ) ); // Validare manuală disponibilă în orice moment $(".form-2 .save-button").on("clic", funcția () ( if(window.validation.isValid(( container: ".form-2) " ) )) ( alert("Validarea celei de-a doua forme a avut succes!"); ) )); ));

Validare formular în timp real Nume Email Adresa URL de confirmare a parolei Trimiteți formular Exemplu de validare manuală a formularului Nume E-mail Parolă (cifre, litere și spațiu) URL de confirmare a parolei Formate de dată AAAA-LL-ZZ și ZZ.LL.AAAA Trimiteți formularul

Acum, salvați toate fișierele din proiect, deschideți index.html în orice browser și treceți la testarea inițială a rezultatului.

Să ne uităm la rezultatul rulării unui script de validare folosind jQuery într-un proiect de testare

După ce deschideți fișierul, ar trebui să vedeți o pagină care arată astfel:

După cum puteți vedea, pe ecran vor fi afișate două formulare. Forma urmei va fi verificată pentru validare în timp real, de exemplu. de fiecare dată când introduceți câmpuri de text, precum și atunci când faceți clic pe butonul „trimite formular”. Formularul din dreapta va fi verificat manual doar atunci când faceți clic pe butonul „Trimiteți formularul”. În restul timpului, forma va rămâne neatinsă.

Acum, să ne asigurăm că validarea are loc în acele momente când este necesară și că formularele nu se afectează în niciun fel. Va arata cam asa:

După cum puteți vedea, formularul din stânga a fost validat din mers. Iar în formularul din stânga, validarea a avut loc doar făcând clic pe butonul „Trimite formularul”.

După ce ați terminat testarea inițială, trebuie să treceți din nou prin capacitățile și limitările stabilite la început:

Formularul este stocat într-un container arbitrar. - Terminat. Forma nu depinde de un anumit element. Procesează un container arbitrar
Validare atât din mers cât și manual. - Terminat. Validarea se poate face fie din mers, fie manual
Pluginul ar trebui să fie simplu - Terminat. Codul este foarte simplu. Configurarea formularelor nu a durat mai mult de 5 minute. A fost nevoie de doar câteva rânduri pentru a lansa pluginul
Poate fi extins oricând - Terminat. Adăugarea validatorilor este simplă. Poate fi adăugat atât la opțiunile implicite, cât și în timpul pornirii pluginului. Deoarece codul este simplu, adăugarea de funcționalități este la fel de ușoară.
Configurarea validatorilor ar trebui să fie universală și simplă - Terminat. Validatorii sunt specificati prin clase de stil.

Acum aveți un plugin jQuery ușor care poate fi folosit pentru a valida formulare personalizate din mers sau manual. În același timp, pluginul este ușor de extins atât din punct de vedere al numărului de verificări, cât și din punct de vedere al funcționalității suplimentare.

Laravel vine cu un sistem simplu, ușor de utilizat pentru validare (verificarea datelor de intrare în raport cu regulile) și primirea mesajelor de eroare - clasa de validare.

Cel mai simplu exemplu de validare $validator = Validator::make(array("name" => "Dale"), array("name" => "required|min:5"));

Primul parametru transmis metodei make sunt datele de testat. Al doilea parametru sunt regulile care ar trebui aplicate acestora.

Utilizarea tablourilor pentru a specifica reguli

Regulile multiple pot fi separate fie printr-o linie dreaptă (|), fie pot fi elemente de matrice individuale.

$validator = Validator::make(array("name" => "Dale"), array("name" => array("required", "min:5")));

Validarea mai multor câmpuri $validator = Validator::make(array("name" => "Dale", "password" => "badpassword", "email" => " [email protected]"), array ("nume" => "necesar", "parolă" => "obligatoriu|min:8", "email" => "obligatoriu|e-mail|unic"));

Odată ce o instanță Validator a fost creată, metoda eșuează (sau trece) poate fi utilizată pentru a efectua validarea.

Dacă ($validator->fails()) ( // Datele transmise nu au reușit verificarea)

Dacă validatorul găsește erori, puteți obține mesajele sale astfel:

$mesaje = $validator->mesaje();

De asemenea, puteți obține o serie de reguli, date care nu au reușit verificarea, fără mesajele în sine:

$failed = $validator->failed();

Verificarea fișierelor

Clasa Validator conține mai multe reguli inițiale pentru validarea fișierelor, cum ar fi size , mimes și altele. Pentru a efectua verificări asupra fișierelor, pur și simplu transferați fișierele împreună cu alte date.

Cârlig după validare

După finalizarea validării, Laravel vă poate rula funcția de închidere, în care puteți, de exemplu, să verificați ceva special sau să adăugați un fel de mesaj de eroare. Metoda after() este folosită pentru aceasta:

$validator = Validator::make(...); $validator->after(function($validator) ( if ($this->somethingElseIsInvalid()) ( $validator->errors()->add("câmp", "Ceva este în neregulă cu acest câmp!"); ) )); dacă ($validator->fails()) ( // )

Puteți adăuga mai multe după-uri dacă este necesar.

Validarea în controlori

Scrierea unui cod de validare complet de fiecare dată când trebuie să validați datele este incomod. Prin urmare, Laravel oferă mai multe soluții pentru a simplifica această procedură.

Controlerul de bază App\Http\Controllers\Controller include trăsătura ValidatesRequests, care conține deja metode de validare:

/** * Salvați postarea pe blog. * * @param Solicitare $request * @return Răspuns */ public function store(Solicitare $request) ( $this->validate($request, [ "title" => "necesar|unique|max:255", "body" => „necesar”, ]); // )

Dacă validarea trece, codul continuă să se execute. Dacă nu, se aruncă o excepție Illuminate\Contracts\Validation\ValidationException. Dacă nu prindeți această excepție, framework-ul o va prinde, va completa variabilele flash cu mesaje de eroare de validare și va redirecționa utilizatorul către pagina anterioară cu formularul - în sine!

În cazul unei solicitări AJAX, redirecționarea nu are loc; cadrul returnează un răspuns cu codul HTTP 422 și JSON cu erori de validare.

Codul de mai sus este similar cu acesta:

/** * Salvați postarea pe blog. * * @param Solicitare $request * @return Răspuns */ public function store(Solicitare $request) ( $v = Validator::make($request->all(), [ "title" => "necesar|unic|max :255", "body" => "necesar", ]); if ($v->fails()) ( return redirect()->back()->withErrors($v->errors()); ) // )

Schimbări de format de eroare

Dacă doriți să personalizați mesajele de eroare de validare care sunt stocate în variabilele flash de sesiune în timpul unei redirecționări, înlocuiți metoda formatValidationErrors din controlerul dvs.:

/** * (@inheritdoc) */ protected function formatValidationErrors(\Illuminate\Validation\Validator $validator) ( return $validator->errors()->all(); ) Validare interogare

Pentru a implementa scenarii de validare mai complexe, s-ar putea să vă fie convenabil să utilizați așa-numitele Cereri de formular. Acestea sunt clase speciale de solicitări HTTP care conțin logica de validare. Ei procesează cererea înainte ca aceasta să ajungă la controlor.

Pentru a crea o clasă de solicitare, utilizați comanda make:request artisan:

Php artisan make:request StoreBlogPostRequest

Clasa va fi creată în folderul app/Http/Requests. Adăugați regulile de validare necesare la metoda de reguli:

/** * Obțineți regulile de validare care se aplică cererii. * * @return array */ public function rules() ( return [ "title" => "necesar|unic|max:255", "body" => "necesar", ]; )

Pentru ca cadrul să intercepteze cererea înaintea controlorului, adăugați această clasă la argumentele metodei controlerului cerute:

Cu utilizarea corectă a validării interogărilor, puteți fi sigur că controlerele dvs. conțin întotdeauna numai date de intrare validate!

În cazul validării nereușite, cadrul completează variabilele flash cu erori de validare și returnează o redirecționare către pagina anterioară. În cazul unei solicitări AJAX, este returnat un răspuns cu codul 422 și JSON cu erori de validare.

Controlul accesului

Clasele Form Request conțin și o metodă de autorizare. În această metodă, puteți verifica dacă utilizatorul are permisiunea de a efectua această acțiune, actualizați o anumită resursă. De exemplu, dacă un utilizator încearcă să editeze un comentariu la o postare, el este autorul?

/** * Stabiliți dacă utilizatorul este autorizat să facă această solicitare. * * @return bool */ funcția publică autorizare() ( $commentId = $this->route("comentare"); return Comment::where("id", $commentId) ->where("user_id", Auth: :id())->există(); )

Observați apelul metodei route() de mai sus. Această metodă vă oferă acces la parametrii din url (în acest caz (comentar)) definiți în traseu:

Route::post("comentare/(comentare)");

Dacă metoda autorizare returnează false, cadrul generează un răspuns cu codul HTTP 403 și îl trimite imediat. Metoda controlerului nu este executată.

/** * Stabiliți dacă utilizatorul este autorizat să facă această solicitare. * * @return bool */ public function authorize() ( returneaza adevarat; )

Schimbări de format de eroare în variabilele Flash

/** * (@inheritdoc) */ protected function formatValidationErrors(\Illuminate\Validation\Validator $validator) ( return $validator->errors()->all(); ) Lucrul cu mesaje de eroare

După apelarea metodei mesaje a obiectului Validator, veți primi un obiect MessageBag, care are un set de metode utile pentru accesarea mesajelor de eroare.

Primirea primului mesaj pentru câmpul echo $messages->first("email"); Obținerea tuturor mesajelor pentru un câmp foreach ($messages->get("email") ca $message) ( // ) Obținerea tuturor mesajelor pentru toate câmpurile foreach ($messages->all() ca $message) ( // ) Validare pentru prezența unui mesaj pentru câmpul if ($messages->has("email")) ( // ) Primirea unei erori în formatul specificat echo $messages->first("email", "");

Notă: În mod implicit, postările sunt formatate pentru a se potrivi cu Twitter Bootstrap.

Preluarea tuturor mesajelor într-un format dat pentru fiecare ($messages->all("

:mesaj

") ca $message) ( // ) Erori și modele

După ce ați făcut validarea, veți avea nevoie de o modalitate simplă de a transmite erori șablonului. Laravel face acest lucru ușor de făcut. De exemplu, avem următoarele rute:

Route::get("register", function() ( return View::make("user.register"); )); Route::post("înregistrare", function() ($rules = matrice (...)); $validator = Validator::make(Input::all(), $rules); if ($validator->fails() )) ( return redirect("register")->withErrors($validator); ) ));

Rețineți că atunci când verificările eșuează, trecem obiectul Validator obiectului Redirect folosind metoda withErrors. Această metodă va stoca mesaje de eroare în variabile flash de sesiune unică, făcându-le astfel disponibile pentru următoarea solicitare.

Cu toate acestea, rețineți că nu transmitem View::make("user.register"); variabilele $errors la șablon. Laravel însuși verifică datele sesiunii pentru prezența variabilelor și le transmite automat șablonului dacă sunt disponibile. Astfel, este important să rețineți că variabila $errors va fi disponibilă pentru toate șabloanele dvs. în orice moment, la orice solicitare. . Acest lucru vă permite să presupuneți că variabila $errors este întotdeauna definită și poate fi utilizată în siguranță. Variabila $errors este o instanță a clasei MessageBag.

Deci, după redirecționare, puteți utiliza variabila $errors setată automat în șablon:

Numit MessageBag

Dacă aveți mai multe formulare pe pagină, atunci puteți selecta numele obiectului MessageBag în care vor fi returnate texte de eroare, astfel încât să le puteți afișa corect pentru formularul dorit.

Returnare redirecționare(„înregistrare”)->withErrors($validator, „login”);

Obțineți text de eroare din MessageBag cu numele de conectare:

Reguli de validare

Mai jos este o listă cu toate regulile disponibile și funcțiile acestora:

admis

Câmpul trebuie să fie în valoare da, pe sau 1 . Acest lucru este util pentru verificarea acceptării regulilor și licențelor.

active_url

Câmpul trebuie să fie o adresă URL validă, accesibilă prin funcția checkdnsrr.

după: Data

Câmpul trebuie să fie o dată ulterioară Data

alfa

Câmpul trebuie să conțină numai caractere alfabetice.

alpha_dash

Câmpul trebuie să conțină numai caractere alfabetice, numere, litere de subliniere (_) și cratime (-).

alpha_num

Câmpul trebuie să conțină numai caractere alfabetice și numere.

matrice

Câmpul trebuie să fie o matrice.

inainte de: Data

Câmpul trebuie să fie o dată anterioară Data. Șirurile sunt convertite în date folosind funcția strtotime.

între: min,max

Câmpul trebuie să aibă o dimensiune cuprinsă între min inainte de max. Șirurile, numerele și fișierele sunt tratate în mod similar cu regula de dimensiune.

boolean

Câmpul trebuie să fie boolean. Valorile permise sunt true , false , 1 , 0 , "1" și "0" .

confirmat

Valoarea câmpului trebuie să se potrivească cu valoarea câmpului cu acel nume, plus foo_confirmation . De exemplu, dacă câmpul pentru parolă este bifat, atunci câmpul password_confirmation care se potrivește cu valoarea trebuie să fie transmis la intrare.

Data

Câmpul trebuie să fie o dată validă conform funcției strtotime.

formatul datei: format

Câmpul trebuie să se potrivească cu formatul datei format conform funcției date_parse_from_format.

diferit: camp

Valoarea câmpului care se verifică trebuie să fie diferită de valoarea câmpului camp.

e-mail

Câmpul trebuie să fie o adresă de e-mail validă.

exista: masa,coloană

Câmpul trebuie să existe în tabelul de bază de date specificat.

Ușor de folosit:

"state" => "există:state"

Specificarea unui nume de câmp într-un tabel:

"state" => "există:state,abreviere"

De asemenea, puteți specifica mai multe condiții pentru a fi adăugate la interogarea „UNDE”:

"email" => "există:staff,email,account_id,1"

imagine

Fișierul încărcat trebuie să fie o imagine în format jpeg, png, bmp, gif sau svg.

în: foo,bar,...

Valoarea câmpului trebuie să fie una dintre următoarele ( foo, bar etc.).

întreg

Câmpul trebuie să aibă o valoare întreagă validă.

Câmpul trebuie să fie o adresă IP validă.

max: valoare

Valoarea câmpului trebuie să fie mai mică sau egală cu valoare

mime: foo,bar,...

Tipul MIME al fișierului încărcat trebuie să fie unul dintre cele enumerate.

Ușor de folosit:

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

min: valoare

Valoarea câmpului trebuie să fie mai mare decât valoare. Șirurile, numerele și fișierele sunt tratate în mod similar cu regula.

nu în: foo,bar,...

Valoarea câmpului nu trebuie să fie una dintre următoarele ( foo, bar etc.).

numeric

Câmpul trebuie să aibă o valoare numerică sau fracțională validă.

regex: model

Câmpul trebuie să se potrivească cu expresia regulată dată.

Avertisment: Când utilizați această regulă, poate fi necesar să enumerați alte reguli ca elemente de matrice, mai ales dacă expresia conține caracterul pipe (|).

necesar

Câmpul testat trebuie să fie prezent și să aibă o valoare nevidă.

necesar_dacă: camp,valoare,...

Câmpul testat trebuie să fie prezent și să aibă o valoare nevidă dacă celălalt câmp camp prezent și are oricare dintre semnificațiile valoare.

necesar_cu: foo,bar,...

Cel puțin unul dintre câmpurile enumerate este prezent și are o valoare nevide ( foo, bar etc.).

necesar_cu_toate: foo,bar,...

Câmpul testat trebuie să fie prezent și să aibă o valoare nevide, dar numai dacă toate câmpurile enumerate sunt prezente și au o valoare nevidă ( foo, bar etc.).

necesar_fara: foo,bar,...

Câmpul care se verifică trebuie să fie prezent și să aibă o valoare nevid, dar numai dacă cel puțin unul dintre câmpurile listate nu este prezent sau are o valoare goală ( foo, bar etc.).

necesar_fără_toate: foo,bar,...

Câmpul verificat trebuie să fie prezent și să aibă o valoare nevide, dar numai dacă toate câmpurile enumerate nu sunt prezente sau au valori goale ( foo, bar etc.).

la fel: camp

Câmpul trebuie să aibă aceeași valoare ca și câmpul camp.

mărimea: valoare

Câmpul trebuie să se potrivească valoare mărimea. Pentru șiruri, aceasta este lungimea, pentru numere este numărul, pentru fișiere este dimensiunea în kiloocteți.

fus orar

Câmpul trebuie să conțină un identificator de fus orar, unul dintre cele enumerate în funcția php timezone_identifiers_list

unic: masa,coloană,cu exceptia,idColumn

Valoarea câmpului trebuie să fie unică în tabelul de bază de date dat. Dacă nu este specificată coloana, va fi folosit numele câmpului.

Utilizare simplă „email” => „unique:utilizatori” Specificarea unui nume de câmp în tabelul „email” => „unique:users,email_address” Ignorarea unui anumit ID „email” => „unique:users,email_address,10” Adăugarea conditii suplimentare

De asemenea, puteți specifica mai multe condiții pentru a fi adăugate la interogarea „UNDE”:

"email" => "unic:utilizatori,adresa_e-mail,NULL,id,account_id,1"

În regula de mai sus, numai rândurile cu account_id egal cu 1 vor fi incluse în verificare.

url

Câmpul trebuie să fie o adresă URL validă.

Notă: este folosită funcția PHP filter_var

Reguli condiționate

Uneori trebuie să validați un anumit câmp numai atunci când este prezent în datele de intrare. Pentru a face acest lucru, adăugați regula uneori:

$v = Validator::make($date, array("email" => "uneori|necesar|email",));

În exemplul de mai sus, câmpul de e-mail va declanșa validarea numai atunci când există $data[„email”].

Reguli condiționale complexe

Uneori doriți ca un câmp să aibă o valoare numai dacă un alt câmp are o valoare, de exemplu, mai mare de 100. Sau este posibil să solicitați doar două câmpuri să aibă o valoare atunci când este specificat și un al treilea. Acest lucru este ușor de realizat prin reguli condiționate. Mai întâi creați un obiect Validator cu un set de reguli statice care nu se schimbă niciodată:

$v = Validator::make($date, array("email" => "necesar|e-mail", "jocuri" => "necesar|numeric",));

Acum să presupunem că aplicația dvs. este scrisă pentru colecționari de jocuri. Dacă se înregistrează un colecționar cu peste 100 de jocuri, atunci vrem să-i întrebăm de ce au nevoie de atâtea. De exemplu, pot avea un magazin sau poate doar le place să le colecteze. Deci, pentru a adăuga o astfel de regulă condiționată, folosim metoda Validator.

$v->uneori("motiv", "necesar|max:500", function($input) ( return $input->jocuri >= 100; ));

Primul parametru al acestei metode este numele câmpului pe care îl verificăm. Al doilea parametru este regula pe care vrem să o adăugăm dacă funcția de închidere transmisă (al treilea parametru) returnează true . Această metodă vă permite să creați cu ușurință reguli complexe de validare a intrărilor. Puteți chiar să adăugați aceleași reguli condiționate în mai multe câmpuri în același timp:

$v->uneori(array(„motiv”, „cost”), „necesar”, function($input) ( return $input->jocuri >= 100; ));

Notă: Parametrul $input transmis închiderii este un obiect Illuminate\Support\Fluent și poate fi folosit pentru a citi intrarea și fișierele inspectate.

Mesaje de eroare proprii

Puteți transmite propriile mesaje de eroare în locul celor implicite. Există mai multe moduri de a face acest lucru.

Transmiterea mesajelor dvs. către Validator $messages = array("required" => "Field:attribute trebuie completat.",); $validator = Validator::make($input, $reguli, $mesaje);

Notă: linia:atributul va fi înlocuit cu numele câmpului care este verificat. Puteți folosi și alte șiruri variabile.

Folosind alte variabile șir $messages = array("same" => "Valorile lui:attribute și:other trebuie să se potrivească.", "size" => "Câmpul:attribute trebuie să fie exact:size.", "între " => "Valoarea lui:attribute trebuie să fie de la:min la:max.", "in" => "Câmpul:attribute trebuie să aibă una dintre următoarele valori: :values",); Specificarea propriului mesaj pentru un anumit câmp

Uneori poate fi necesar să specificați mesajul pentru un câmp separat.

$messages = array("email.required" => "Trebuie să știm adresa ta de e-mail!",);

Specificarea propriilor mesaje în fișierul de localizare

De asemenea, este posibil să definiți mesaje de validare în fișierul de localizare în loc să le transmiteți direct Validatorului. Pentru a face acest lucru, adăugați mesaje la matricea personalizată a fișierului de localizare app/lang/xx/validation.php.

"custom" => array("email" => array("required" => "Trebuie să știm adresa ta de e-mail!",),),),

Reguli proprii de validare Înregistrați-vă propria regulă de validare

Laravel vine cu o mulțime de reguli utile din cutie, dar poate fi necesar să creați propriile reguli. O modalitate de a înregistra o regulă personalizată este prin metoda Validator::extend.

Validator::extend("foo", function($atribut, $valoare, $parametri) ( returneaza $valoare == "foo"; }); !}

Notă: numele regulii trebuie să fie în formatul_cu_liniere de subliniere.

Funcția de închidere trecută primește trei parametri: numele câmpului care este verificat $attribute , valoarea câmpului $valoare și matricea de parametri $parametri trecuți regulii.

În loc de o funcție, puteți trece o referință la o metodă de clasă la metoda extinde:

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

Rețineți că va trebui, de asemenea, să definiți un mesaj de eroare pentru noua regulă. Puteți face acest lucru fie trecându-l ca o matrice de șiruri de caractere către Validator, fie scriindu-l într-un fișier de localizare.

Extinderea clasei Validator

În loc să utilizați funcții de închidere pentru a extinde setul de reguli disponibile, puteți extinde clasa Validator în sine. Pentru a face acest lucru, creați o clasă care moștenește Illuminate\Validation\Validator . Puteți adăuga noi metode de validare pornind numele lor cu validate .