Share
In questa mini serie Nettuts +, creeremo un'applicazione web da zero, mentre ci immergiamo in un nuovo framework PHP che sta rapidamente prendendo piede, chiamato Laravel.
In questa lezione impareremo alcune utili funzioni di Laravel: i filtri e le librerie di convalida e di file.
Bentornati alle nostre applicazioni Web da Scratch con le serie Laravel! Nel secondo tutorial della nostra mini-serie, abbiamo imparato molto sull'implementazione ORM di Laravel:
Se non l'hai ancora visto, ti invito a controllare la prima e la seconda parte della mini-serie: renderà molto più facile seguirli, mentre costruiamo la nostra applicazione di test, Instapics, attraverso ogni parte.
Quindi iniziamo!
In poche parole, i filtri sono funzioni che possiamo eseguire su percorsi prima o dopo il ciclo di richiesta. È particolarmente utile per cose come l'autenticazione e la registrazione. Per registrare un filtro, dobbiamo aggiungere qualcosa come il seguente al application / routes.php file:
Accentsconagua
Route :: filter ('myfilter', function () // Cosa vuoi fare il filtro); Dopo aver registrato il filtro, dobbiamo collegarlo a un percorso, in questo modo:
Route :: any ('/', array ('before' => 'filter', function () // Cosa vuoi che la rotta faccia)); Nell'esempio sopra, il myfilter si innescherà su tutte le richieste alla pagina dell'indice (es. /). Diciamo che volevamo implementare un filtro di autenticazione per il cruscotto itinerario:
Route :: filter ('auth', function () if (Auth :: guest ()) return Redirect :: to ('home');); Route :: any ('dashboard', array ('before' => 'auth, function () return View :: make (' dashboard ');); Il codice sopra reindirizzerà tutte le richieste non autenticate a cruscotto percorso per il casa itinerario.
Di default, Laravel include due filtri, prima e dopo, che vengono eseguiti prima e dopo ogni richiesta su un'applicazione. Questi sono di solito dove si posizionano le cose, come la registrazione delle richieste, l'aggiunta di risorse globali o l'attivazione di eventi globali. Per esempio:
Route :: filter ('after', function ($ response) Log :: write ('request', 'Request finished on'. Date ('d M, Y - h: i: sA'). '. \ N \ nInformazioni più corrette: \ n '. var_export (Input :: get (), true));); Questo scrive a richiesta digitare il messaggio di registro nel registro dell'applicazione ed elenca qualsiasi input dalla richiesta.
Se ti ritrovi ad applicare lo stesso filtro a più percorsi, puoi farne uso Instradare i gruppi per raggrupparli tutti e ridurre la ripetizione del codice:
Route :: filter ('admin_auth', function () if (Auth :: guest () ||! Auth :: user () -> isAdmin ()) return Redirect :: to ('home'); ); Route :: group (array ('before' => 'admin_auth'), function () Route :: get ('admin', function () return View :: make ('admin');); : get ('useradmin', function () return View :: make ('useradmin'););); Per le applicazioni (come la nostra Instapics) che fanno uso di controller, possiamo applicare filtri usando il $ This-> filter () funzione nel costruttore del controller:
funzione pubblica __construct () $ this-> filter ('before', 'auth'); Questi filtri, come i percorsi, possono anche essere personalizzati per essere applicati solo a determinati verbi HTTP e azioni specifiche del controllore:
funzione pubblica __construct () // chiama 'log_download' filtro per tutti i download / file richieste GET $ this-> filter ('after', 'log_download') -> only (array ('file')) -> on (' ottenere'); // chiama il filtro 'auth_download' per tutte le richieste di download / *, tranne per l'azione 'queue' $ this-> filter ('before', 'auth_download') -> except (array ('queue')); La convalida integrata di Laravel facilita l'applicazione della convalida a qualsiasi matrice di valori, in particolare, l'input di modulo. Per fare ciò, è sufficiente creare due array:
// Ottenere il nostro input dalla libreria di input $ input = Input :: all (); // Crea le nostre regole di validazione $ rules = array ('email' => 'required | email | unique: users', 'password' => 'required'); // Ottenere un'istanza di convalida $ per il nostro controllo degli errori $ validation = Validator :: make ($ input, $ rules); // Controlla se la validazione è riuscita se ($ validation-> fail ()) // fai qualcosa con i messaggi di errore dagli errori $ validation $ validation->; Di seguito è riportato un elenco di regole di convalida che possono essere utilizzate con la libreria di convalida di Laravel. Come nell'esempio sopra, sei libero di mescolarli e abbinarli separandoli con una pipe ("|"):
necessario - il valore dovrebbe essere presente nell'array di input 'email' => 'richiesto'
alfa - il valore dovrebbe essere composto solo da caratteri alfabetici 'full_name' => 'alpha'
alpha_num - il valore dovrebbe essere composto solo da caratteri alfanumerici 'username' => 'alpha_num'
alpha_dash - il valore dovrebbe essere composto solo da caratteri alfanumerici, trattini e / o caratteri di sottolineatura 'user_name' => 'alpha_dash'
taglia - il valore dovrebbe essere solo di una determinata lunghezza, o dovrebbe essere uguale a se numerico 'api_key' => 'dimensione: 10'
'order_count' => 'size: 10'
fra - il valore è compreso tra un intervallo specificato 'order_count' => 'between: 1,100'
min - il valore è almeno il dato 'order_count' => 'min: 1'
max - il valore è uguale o inferiore al dato 'order_count' => 'max: 100'
numerico - il valore è numerico 'order_count' => 'numerico'
numero intero - il valore è un numero intero 'order_count' => 'intero'
nel - il valore è contenuto nel dato 'tshirt_size' => 'in: xsmall, piccolo, medio, grande, xlarge'
Non in - il valore non è nel dato 'tshirt_size' => 'not_in: xsmall, xlarge'
confermato - controllerà se il chiave_conferma esiste ed è uguale al valore 'password' => 'confermato'
Questo controllerà se il conferma password il valore esiste ed è uguale a parola d'ordine
accettato - questo controllerà se il valore è impostato su "sì" o 1. Utile per le caselle di controllo 'terms_of_service' => 'accettato'
stesso - il valore è uguale al valore dell'attributo specificato 'password' => 'same: confirm_password'
diverso - il valore dovrebbe essere diverso dal valore dell'attributo specificato 'password' => 'different: old_password'
incontro - il valore dovrebbe corrispondere all'espressione regolare data 'user_name' => 'corrisponde: / [a-zA-Z0-9] * /'
unico - controlla l'univocità del valore nella tabella data. 'user_name' => 'unique: users'
Una determinata colonna viene accettata anche se il nome della colonna non è uguale al nome dell'attributo.
// se la colonna nella tabella utenti è username, // possiamo fornire questo nel dato in questo modo: 'user_name' => 'unique: users, username'
Ci sono momenti in cui vogliamo verificare l'univocità, ma ignorare un certo record (di solito il record associato all'utente corrente). Possiamo farlo aggiungendo un terzo dato, che dovrebbe essere l'ID di quel record nella tabella.
// ID 10 è l'ID del record dell'utente corrente 'user_name' => 'unique: users, user_name, 10'
esiste - il valore dovrebbe esistere in una tabella 'categoria' => 'esiste: categorie'
Questo accetta anche un secondo dato se vogliamo cambiare il nome della colonna da verificare.
'category' => 'esiste: categorie, category_name'
prima - il valore dovrebbe essere una data prima della data specificata 'publish_date' => 'prima: 2012-07-14'
dopo - il valore dovrebbe essere una data dopo la data specificata 'publish_date' => 'dopo: 2012-07-14'
e-mail - il valore dovrebbe essere in un formato email valido 'subscriber_email' => 'email'
url - il valore è in un formato url valido 'github_profile' => 'url'
active_url - il valore è in un formato url valido E è attivo 'github_profile' => 'active_url'
mimi - controlla il tipo mime di un file caricato. Puoi usare qualsiasi valore di tipo mime dal config / mimes.php file 'avatar' => 'mimi: jpg, gif, png, bmp'
Immagine - il file dovrebbe essere un'immagine 'avatar' => 'immagine'
Puoi anche usare il max validatore qui per verificare la dimensione di un file in kilobyte
'avatar' => 'immagine | max: 100'
Una volta che chiami il Validator> fallisce () o Validator> passa () metodo, la libreria raccoglie tutti gli errori in una classe accessibile tramite Validator> errori. Sarai quindi in grado di recuperare questi errori con alcune funzioni nel errori classe. Laravel offre alcune interessanti funzionalità per automatizzare la gestione degli errori che si adatta alla maggior parte degli scenari POST / REDIRECT / GET:
class Register_Controller estende Base_Controller public $ restful = true; funzione pubblica get_index () return View :: make ('register.index'); public function post_index () $ rules = array ('email' => 'richiesto | email | unique: users', 'password' => 'confirmed'); $ validation = Validator :: make (Input :: get (), $ rules); if ($ validation-> failed ()) // Invia l'oggetto $ validation alla pagina reindirizzata return Redirect :: to ('register') -> with_errors ($ validation); Qui, usiamo il with_errors metodo per il Reindirizzare biblioteca. Questo automaticamente vincola il $ errori variabile nella vista per dove stiamo reindirizzando - in questo caso, il registro / index pagina:
Nel file di visualizzazione, usiamo il $ Errori:> ha () metodo per verificare se esiste un errore per quel campo specifico. Se lo fa, usiamo quindi il $ Errori:> get () metodo per visualizzare i messaggi di errore. Il secondo parametro in questo metodo può essere utilizzato per fornire un modello su come viene visualizzato il messaggio di errore.
Poiché la maggior parte delle persone vorrebbe cambiare i messaggi di errore di Laravel per adattarsi al marchio o alla lingua dell'applicazione, la libreria di convalida consente anche di personalizzare i messaggi di errore generati aggiungendo semplicemente in un $ messages matrice al Convalida :: fare chiamata di funzione:
$ rules = array ('email' => 'richiesto | email | unique: users', 'password' => 'confirmed'); $ messages = array ('email_required' => 'Si prega di fornire un indirizzo email', 'email_email' => 'Si prega di fornire un indirizzo email valido', 'email_unique' => 'L'indirizzo email che hai fornito è già in uso', ' password_confirmed '=>' La tua password non ha confermato la tua password. '); $ validation = Validator :: make (Input :: get (), $ rules, $ messages); Ci sono due modi per creare un $ messages array:
$ messages = array ('required' => 'Il campo: attribute è obbligatorio.', 'same' => 'The: attribute e: other deve match.', 'size' => 'L'attributo: deve essere esattamente: size. ',' between '=>' L'attributo: deve essere compreso tra: min -: max. ',' in '=>' L'attributo: deve essere uno dei seguenti:: valori ',); Ciò cambierà i messaggi di errore predefiniti per tutti i campi che hanno il richiesto, stesso, dimensione, tra e in regole. Qui, vediamo anche che Laravel usa segnaposto per sostituire determinati valori nel messaggio di errore. :attributo cambierà nell'attributo field (senza underscore) per cui è. :altro è usato per il stesso regola, che si riferisce all'altro attributo che deve corrispondere. :taglia si riferisce alla dimensione definita nei parametri delle regole. : min e : max è il minimo e il massimo, e :valori è la lista di valori che abbiamo specificato per il valore del campo.
$ messages = array ('email_required' => 'Si prega di fornire un indirizzo email', 'email_email' => 'Si prega di fornire un indirizzo email valido', 'email_unique' => 'L'indirizzo email che hai fornito è già in uso', ' password_confirmed '=>' La tua password non ha confermato la tua password. '); Email (obbligatorio è il messaggio di errore che viene utilizzato quando il e-mail attributo fallisce il necessario regola, email_email è il messaggio di errore che viene utilizzato quando il e-mail fallisce il e-mail regola, e così via.
Se ti ritrovi a ricreare costantemente gli stessi messaggi personalizzati, sarebbe più semplice specificare i messaggi di errore personalizzati a livello globale. Puoi farlo modificando il application / langauge / it / validation.php file e modificando il file costume array trovato lì:
... 'custom' => array ('email_required' => 'Si prega di fornire un indirizzo email', 'email_email' => 'Si prega di fornire un indirizzo email valido', 'email_unique' => 'L'indirizzo email che hai fornito è già in uso ',' password_confirmed '=>' La tua password non ha confermato la tua password. '); ... laravel di File la libreria rende facile gestire i caricamenti di file usando il Ingresso :: Carica metodo, che è un semplice wrapper per PHP move_uploaded_file funzione:
Input :: upload ('input_name', 'directory / to / save / file', 'filename.extension'); Per convalidare i caricamenti di file, è possibile utilizzare il Validator libreria che abbiamo discusso sopra in questo modo:
$ input = array ('upload' => Input :: file ('upload')); $ rules = array ('upload' => 'mimi: zip, rar | max: 500'); $ validator = Validator :: make ($ input, $ rules); Il File libreria ha anche alcuni metodi di manipolazione dei file, come:
// Ottieni un file $ data = File :: get ('path / file.extension'); // Scrivi un file File :: put ('percorso / file.estensione', $ dati); // Aggiunta a un file File :: append ('percorso / file.estensione', $ dati); Laravel fornisce anche alcune funzionalità generali relative ai file che possono essere utilizzate in tutto il codice. Ad esempio, il Estensione del file metodo restituisce l'estensione di un nome file stringa:
// Questo restituirà 'zip' File :: extension ('data.zip'); Il File :: è la funzione controlla se un file è di un certo tipo. Prendi nota che questo non controlla semplicemente l'estensione del file, ma usa il fileinfo Estensione PHP per leggere i contenuti effettivi del file. Questo è utile per determinare se un file è effettivamente di un tipo di file corretto:
// Restituisce true se il file è un file zip, false se altrimenti File :: is ('zip', 'percorso / file.zip'); Un elenco di estensioni compatibili può essere visto in application / config / mimes.php.
Parlando di tipi di mimo, puoi anche usare il File :: mimo funzione per ottenere i tipi mime di un'estensione. Il tipo mime restituito si basa sullo stesso mimes.php file:
// Questo restituirà l'immagine / png File :: mime ('png') Il File :: cpdir e il File :: rmdir i metodi possono copiare ed eliminare una directory, rispettivamente.
File :: cpdir ('directory / to / copy', 'destinazione / directory'); // File :: rmdir è un'eliminazione ricorsiva, quindi eliminerà tutti i file e le cartelle all'interno della directory. File :: rmdir ( 'directory / A / delete'); Ora che abbiamo imparato tutto filtri, il Validazione biblioteca e il File libreria, implementiamoli nella nostra applicazione, Instapics.
auth Filtro
Base_Controller Iniziamo assicurandoci che i nostri utenti possano vedere solo le pagine autenticate creando un auth filtro che viene eseguito prima di tutte le richieste. Poiché utilizziamo il routing basato su controller, dovremo configurare i nostri filtri nel nostro controller. Mettiamo i filtri nel __costruire metodo del Base_Controller per assicurarsi che il auth il filtro funziona su tutti i controller che lo estende. Mentre ci siamo, aggiungiamo un nonauth filtra anche per assicurarti che le persone possano visitare solo determinate pagine quando non sono autenticate:
class Base_Controller estende Controller public function __construct () // Assets Asset :: add ('jquery', 'js / jquery-1.7.2.min.js'); Asset :: add ('bootstrap-js', 'js / bootstrap.min.js'); Asset :: add ('bootstrap-css', 'css / bootstrap.min.css'); Asset :: add ('bootstrap-css-responsive', 'css / bootstrap-responsive.min.css', 'bootstrap-css'); Asset :: add ('style', 'css / style.css'); parent :: __ construct (); // Filters $ class = get_called_class (); switch ($ class) case 'Home_Controller': $ this-> filter ('before', 'nonauth'); rompere; caso 'User_Controller': $ this-> filter ('before', 'nonauth') -> only (array ('authenticate')); $ this-> filter ('before', 'auth') -> only (array ('logout')); rompere; default: $ this-> filter ('before', 'auth'); rompere; Qui definiamo che qualsiasi richiesta al casa il percorso richiederà un utente non autenticato, il che è positivo poiché è qui che si trova la schermata di accesso. Qualsiasi altra richiesta, tuttavia, imporrà automaticamente di richiedere un utente autenticato. Per il User_Controller, in realtà abbiamo due metodi separati che richiedono sia utenti non autenticati (autenticati) che utenti autenticati (logout), quindi utilizziamo il solo metodo per specificare a quali azioni del controller si applicano i filtri.
routes.php Ora aperto application / routes.php, che è dove definiremo il auth e nonauth filtri. Prendi nota che potresti già averne uno esistente auth definizione del filtro quindi basta sostituirla con quella che abbiamo di seguito:
Route :: filter ('auth', function () if (Auth :: guest ()) restituisce Redirect :: to ('home');); Route :: filter ('nonauth', function () if (Auth :: guest () == false) restituisce Redirect :: to ('dashboard');); Nel auth filtro, controlliamo se un utente è autenticato con il auth biblioteca. Se l'utente non è autenticato, li reindirizziamo a casa percorso in cui è la schermata di accesso, altrimenti, sono autorizzati a continuare. La stessa cosa con il nonauth filtro: controlla se l'utente è autenticato, se lo è, quindi reindirizza la persona sulla dashboard.
Ora che sappiamo qualcosa in più su come gestire i caricamenti di file in Laravel, iniziamo ad implementare uno di Instapics'Caratteristiche principali - caricamento di foto. Inizia creando una cartella chiamata applicazione / views / plugins cartella, e al suo interno crea un file di visualizzazione Blade chiamato upload_modal.blade.php. Incolla il seguente codice HTML:
Carica un nuovo Instapic
Annulla
Attiviamo questa forma modale con un pulsante: aggiungi questo application / views / layout / main.blade.php, dopo il .nav-crollo div:
@section ('post_navigation') @if (Auth :: check ()) @include ('plugins.loggedin_postnav') @endif @yield_section@section ( 'navigazione')
- Casa
@yield_section
Qui, includiamo un file di visualizzazione chiamato loggedin_postnav se l'utente ha effettuato l'accesso. Qui è dove aggiungeremo il pulsante per il modulo di caricamento modale. Nello stesso file, aggiungere questo dopo il .contenitore div:
@yield ( 'content')@section ('modals') @if (Auth :: check ()) @include ('plugins.upload_modal') @endif @yield_section
Questo è dove includiamo il upload_modal HTML. Ci assicuriamo che l'utente non abbia effettuato l'accesso prima di includere questo file HTML, poiché come il pulsante trigger, questo non sarebbe realmente necessario se l'utente non è autenticato.
Adesso crea application / views / plugins / loggedin_postnav.blade.php
Aggiorna la pagina e dovresti vedere il nuovo pulsante di caricamento: fai clic per vederlo funzionare!
Ora che abbiamo il nostro materiale di front-end funzionante, iniziamo a lavorare sulla parte back-end del modulo. Creare application / controller / photo.php, e inserire il seguente codice per il controller:
la classe Photo_Controller estende Base_Controller public function action_upload () $ input = Input :: all (); $ extension = File :: extension ($ input ['photo'] ['name']); $ directory = percorso ('pubblico'). 'uploads'. sha1 (Auth :: user () -> id); $ nomefile = sha1 (Auth :: user () -> id.time ()). ". $ extension"; $ upload_success = Input :: upload ('foto', $ directory, $ nomefile); if ($ upload_success) Session :: flash ('status_success', 'Caricamento riuscito nuovo Instapic'); else Session :: flash ('status_error', 'Si è verificato un errore durante il caricamento di Instapic - riprova.'); if ($ upload_success) $ photo = new Photo (array ('location' => URL :: to ('uploads'. 'sha1 (Auth :: user () -> id).' / '. $ nomefile) , 'description' => $ input ['description'])); Auth :: utente () -> foto () -> inserire ($ foto); return Redirect :: to ('dashboard'); Provalo: dovresti essere in grado di iniziare a caricare nuovi Instapics.
Aggiungiamo alcune regole di convalida a questo per assicurarci che l'utente invii solo le cose corrette. Aggiorna il controller con quanto segue:
la classe Photo_Controller estende Base_Controller public function action_upload () $ input = Input :: all (); if (isset ($ input ['description'])) $ input ['description'] = filter_var ($ input ['description'], FILTER_SANITIZE_STRING, FILTER_FLAG_NO_ENCODE_QUOTES); $ rules = array ('photo' => 'required | image | max: 500', // upload di foto deve essere un'immagine e non deve superare 500kb 'description' => 'required' // la descrizione è richiesta); $ validation = Validator :: make ($ input, $ rules); if ($ validation-> failed ()) return Redirect :: to ('dashboard') -> with_errors ($ validation); $ extension = File :: extension ($ input ['photo'] ['name']); $ directory = percorso ('pubblico'). 'uploads'. sha1 (Auth :: user () -> id); $ nomefile = sha1 (Auth :: user () -> id.time ()). ". $ extension"; $ upload_success = Input :: upload ('foto', $ directory, $ nomefile); if ($ upload_success) $ photo = new Photo (array ('location' => URL :: to ('uploads'. 'sha1 (Auth :: user () -> id).' / '. $ nomefile), 'description' => $ input ['description'])); Auth :: utente () -> foto () -> inserire ($ foto); Session :: flash ('status_success', 'Carica con successo il tuo nuovo Instapic'); else Session :: flash ('status_error', 'Si è verificato un errore durante il caricamento del tuo nuovo Instapic - riprova.'); return Redirect :: to ('dashboard'); Vedi come convalidiamo l'input? Ci assicuriamo che la foto sia presente, un'immagine e meno di 500kb. Ci assicuriamo inoltre che la descrizione sia presente dopo i servizi igienici. Tuttavia, non saremo in grado di vedere i nostri messaggi di errore, quindi risolviamolo aggiungendo un po 'di codice HTML per visualizzare i nostri messaggi di errore. Aperto application / views / layout / main.blade.php e aggiungi il seguente all'interno del .contenitore div:
@include ('plugins.status') @yield ('contenuto')
Adesso crea application / views / plugins / status.blade.php. Qui è dove verranno visualizzati i messaggi di errore effettivi. Aggiungeremo anche il supporto per i messaggi di stato basati sulla sessione (come quello che usiamo all'interno di $ upload_success controllare il Fotografie codice del controller):
@if (isset ($ errors) && count ($ errors-> all ())> 0)×@elseif (! is_null (Session :: get ('status_error'))))Oh Snap!
@foreach ($ errors-> all ('
- :Messaggio
') come $ messaggio) $ messaggio @endforeach×@endif @if (! is_null (Session :: get ('status_success'))))Oh Snap!
@if (is_array (Session :: get ('status_error'))))@foreach (Session :: get ('status_error') come $ errore)
@else Session :: get ('status_error') @endif- $ error
@endforeach×@finisci seSuccesso!
@if (is_array (Session :: get ('status_success'))))@foreach (Session :: get ('status_success') come $ successo)
@else Session :: get ('status_success') @endif- $ successo
@endforeach
Prova a causare errori nel modulo di caricamento ora inviando senza alcun file selezionato o senza una descrizione (poiché entrambi sono richiesti). Dovresti vedere i messaggi di errore visualizzati in cima:
Ora sappiamo come usare Laravel Validazione biblioteca, rivisitiamo il nostro primo modulo - il modulo di login e registrazione. Al momento, usiamo solo un eco per vedere che il login o la registrazione non sono riusciti - sostituiamolo con una corretta convalida. Aperto application / controller / user.php e aggiornalo in questo modo:
class User_Controller estende Base_Controller public function action_authenticate () $ email = Input :: get ('email'); $ password = Input :: get ('password'); $ new_user = Input :: get ('new_user', 'off'); $ input = array ('email' => $ email, 'password' => $ password); if ($ new_user == 'on') $ rules = array ('email' => 'richiesto | email | unique: users', 'password' => 'required'); $ validation = Validator :: make ($ input, $ rules); if ($ validation-> failed ()) return Redirect :: to ('home') -> with_errors ($ validation); prova $ user = new User (); $ utente-> email = $ email; $ user-> password = Hash :: make ($ password); $ User-> save (); Auth :: login ($ user); return Redirect :: to ('dashboard'); catch (Exception $ e) Session :: flash ('status_error', 'Si è verificato un errore durante la creazione di un nuovo account - riprova.'); return Redirect :: to ('home'); else $ rules = array ('email' => 'required | email | exists: users', 'password' => 'required'); $ validation = Validator :: make ($ input, $ rules); if ($ validation-> failed ()) return Redirect :: to ('home') -> with_errors ($ validation); $ credentials = array ('username' => $ email, 'password' => $ password); if (Auth :: attempt ($ credentials)) return Redirect :: to ('dashboard'); else Session :: flash ('status_error', 'La tua email o password non è valida - per favore riprova.'); return Redirect :: to ('home'); public function action_logout () Auth :: logout (); Redirect :: a ( 'casa / index'); Dal momento che abbiamo reso i nostri rendering dei messaggi di stato in modo modulare, non abbiamo nemmeno bisogno di scrivere alcun codice HTML aggiuntivo per vedere i messaggi di errore in azione! Provalo!
Nel terzo tutorial del nostro laravel serie, abbiamo imparato:
