Oggi più che mai è fondamentale che i dati delle applicazioni siano validi, accurati e soddisfino tutti i requisiti di sistema. Questo sistema risponde alla necessità di mantenere la coerenza dei dati e di evitare le vulnerabilità della sicurezza.

Laravel rende la convalida dei dati facile e intuitiva. Segue un’architettura MVC (Model View Controller) e richiede solo una conoscenza generale di PHP e dei concetti di programmazione orientata agli oggetti (OOP). Inoltre, Laravel offre diversi metodi per convalidare i dati in entrata.

Vediamo alcuni di questi approcci e come applicare le regole di convalida ai vostri dati.

Convalida dei dati semplificata in Laravel

Laravel fornisce diverse regole di convalida pronte all’uso per l’invio di dati da parte degli utenti della vostra applicazione tramite moduli. È possibile contrassegnare i campi di input come obbligatori, impostare una lunghezza minima o massima e richiedere inserimenti unici (non duplicati) e indirizzi e-mail validi. Il validator di Laravel verifica se l’input soddisfa queste regole o altre da voi specificate.

Le regole di validazione di Laravel includono:

  • required – I dati del campo non devono essere nulli o vuoti.
  • array – I dati del campo devono essere un array PHP.
  • bail – La regola di validazione smette di essere eseguita dopo aver riscontrato il primo errore di validazione.
  • email – I dati del campo devono essere un indirizzo e-mail valido.
  • unique – I dati del campo non devono avere duplicati nella tabella del database.

Tutti i metodi di validazione hanno pro e contro, ma la loro varietà permette di scegliere l’approccio migliore per le proprie esigenze. A seconda del metodo scelto, la convalida di Laravel può avvenire in diversi modi, con messaggi di errore manuali o automatici.

Il metodo più comune è code>validate, utilizzato per le richieste HTTP in entrata. Questo metodo è collegato ai dati della richiesta ed esegue le regole di validazione. È possibile separare le regole per ogni campo con delle virgole, come si vede nell’esempio seguente.

use Illuminate\Http\Request;
 
public function store (Request $request){
  $validated = $request->validate([
        'email' => ['required, unique:users, email, bail'],
        'name' => ['required'],
    ]);

}

In questo caso, email è un input obbligatorio, cioè non può essere nullo. Inoltre, deve essere unico nella tabella del database users, per evitare che lo stesso indirizzo e-mail venga registrato due volte. L’ultima regola impone che l’indirizzo e-mail sia valido. In caso contrario, il processo di convalida si interrompe. Il campo nome è obbligatorio ma non ha altre regole.

Se una regola di convalida di Laravel fallisce, viene generata automaticamente una risposta.

Nozioni di base sulla validazione

Per capire meglio i metodi di validazione, considerate il seguente esempio. Definirete una route per l’endpoint e creerete un controller per convalidare ed elaborare i dati della richiesta.

Per prima cosa, create un semplice endpoint che permetta agli utenti di memorizzare le loro email e password.

Definire la route

Le route di Laravel sono definite nel file routes/web.php per un’applicazione web o routes/api.php per un’API. Per questo esempio, usate il file api.php:

use App\Http\Controllers\UserController;
 
Route::post('/store', [UserController::class]);

Creare il controller

Eseguite questo comando di Artisan per creare il controller:

php artisan make:controller

UserController

Questo comando crea un file UserController.php nella cartella app/Http/Controllers.

Ora, definite un metodo store per convalidare i dati che entrano nell’endpoint del negozio prima di memorizzarli.

Questo esempio convaliderà i seguenti campi utilizzando queste regole:

  • email – Deve essere unico, deve essere un’email valida e deve essere obbligatorio
  • password – Deve avere una lunghezza minima, deve essere una password di conferma e deve essere necessaria
  • age – Deve essere un numero e deve essere obbligatorio
<?php

namespace App\Http\Controllers;
use Illuminate\Http\Request;
class UserController extends Controller
{
    /**
     * Store new user details.
     *
     */
    public function store(Request $request){
        $validated = $request->validate([
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ]);
        // After user data is validated, logic to store the data
    }

}

La regola confirmed permette di richiedere due volte un determinato campo per verificare che i dati siano accurati, come nel caso di utenti che inseriscono nuovamente la propria password durante la registrazione. Questa regola richiede un campo chiamato password_confirmation, i cui dati devono corrispondere al campo della password.

Visualizzare i messaggi di errore

Se i criteri di convalida sono soddisfatti, il codice continuerà a funzionare normalmente. Se la convalida fallisce, viene lanciata un’eccezione IlluminateValidationValidationException e viene restituita la risposta di errore appropriata.

L’esempio si basa su un’API che restituisce una risposta HTTP 422 Unprocessable Entity in formato JSON. Per le applicazioni web, il reindirizzamento all’URL precedente visualizzerebbe il messaggio di errore e i dati della richiesta verrebbero inviati alla sessione.

È possibile utilizzare la variabile $errors nelle viste per visualizzare gli errori restituiti:

@if ($errors->any())
    <div class="alert alert-danger">
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    </div>
@endif

Potete anche scegliere di visualizzare solo il primo errore o di fare un ciclo per visualizzarli tutti.

// Fetch all errors
$errors->all()

// Fetch only the first error
$errors->first()

Ripopolare i moduli

La ripopolazione dei moduli evita agli utenti di riscrivere le informazioni in modo che possano concentrarsi sulla correzione dell’errore. Nell’esempio di un indirizzo e-mail che non funziona, si può ripopolare il resto del modulo richiamando il vecchio valore del campo name.

$name = $request-> old('name')

//Blade helper
<input type="text" name="name" value="{{ old('name') }}">

Questa regola restituirebbe null nel caso in cui non ci sia stato un input precedente.

Convalida avanzata

Laravel offre un altro metodo per scrivere le convalide, chiamato richieste modulo. Una richiesta modulo è una classe di richiesta personalizzata che organizza le convalide e riduce il vostro controller.

Hanno una propria logica di validazione e autorizzazione adatta a grandi volumi di input e possono essere utilizzate per definire regole di validazione e personalizzare i messaggi di errore.

Per creare una richiesta modulo, eseguite questo comando di Artisan:

php artisan make:request StoreUserRequest

Questo comando crea un file StoreUserRequest.php nella cartella app/Http/Requests e contiene due metodi predefiniti:

  • rules restituisce le regole di convalida per i dati della richiesta.
  • authorize restituisce un boolean per indicare se l’utente ha il permesso di eseguire l’azione richiesta.

Convertite l’esempio precedente per utilizzare una richiesta modulo.

<?php

namespace App\Http\Requests;
use Illuminate\Foundation\Http\FormRequest;
class StoreUserRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     *
     * @return bool
     */
    public function authorize()
    {
        // Add logic to check if the user is authorized to submit this data.
        return true;
    }
    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, mixed>
     */
    public function rules()
    {
        return [
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ];
    }

}

Per personalizzare i messaggi di errore di queste regole, potete sovrascrivere il metodo messages della classe FormRequest.

/**

     * Get the error messages for the defined validation rules.
     *
     * @return array
     */
    public function messages()
    {
        return [
            'email.required' => 'An email address is required',
            'email.email' => 'The email address must be valid',
            'password.confirmed'=>'Re-type your password as 
password_confirmation, passwords does not match'
        ];

    }

Nota: il nome dei dati e la regola di convalida sono separati da un punto (.) prima dei dati del messaggio.

Convalida personalizzata

Per creare una convalida personalizzata, potete utilizzare la facade Validator invece di validate. L’istanza del validator contiene due argomenti: i dati da convalidare e un array di regole di convalida. Questi due argomenti vengono passati al metodo ::make della facade del validator, generando una nuova istanza del validator.

use Illuminate\Http\Request; 

public function store (Request $request){
        $validator = Validator::make($request->all(),[
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ]);
        if ($validator->fails()) {
            // Return errors or redirect back with errors
            return $validator->errors();
        }
 
        // Retrieve the validated input...
        $validated = $validator->validated();
        // Continue logic to store the data

    }

Se volete aggiungere un indirizzamento automatico, potete eseguire il metodo validate su un’istanza di validator preesistente. Se la validazione fallisce, una richiesta XHR produce una risposta JSON con 422 Unprocessable Entity come codice di stato, oppure l’utente viene reindirizzato immediatamente.

$validator = Validator::make($request->all(),[
'email' => 'required|unique:users|email',
'password' => 'required|min:7|confirmed'
])->validate();

È anche possibile personalizzare i messaggi di errore passando a Validate::make method un terzo parametro chiamato messages:

$validator = Validator::make($request->all(),[
            'email' => 'required|unique:users|email',
            'age' => 'required|numeric',
            'password' => 'required|min:7|confirmed'
        ], $messages = [
            'required' => 'The :attribute field is required.',
]);

Nota: :attribute viene sostituito dal nome del campo da convalidare.

Riepilogo

L’esecuzione della convalida dei dati è fondamentale per mantenere il vostro set di dati pulito, corretto e completo. La convalida dei dati permette di eliminare gli errori nei dati che potrebbero potenzialmente danneggiare o influenzare il vostro progetto. La convalida diventa sempre più importante quando si lavora in scala e con grandi quantità di dati.

Laravel consente numerosi approcci flessibili per garantire l’integrità e l’accuratezza dei dati che passano attraverso la vostra applicazione. Potete realizzare complicate logiche di validazione con metodi predefiniti e personalizzabili, rendendo la vostra base di codice ben strutturata e più facilmente riutilizzabile.

Inviate le vostre applicazioni Laravel più velocemente con i servizi di hosting di Kinsta.

Jeremy Holcombe Kinsta

Content & Marketing Editor at Kinsta, WordPress Web Developer, and Content Writer. Outside of all things WordPress, I enjoy the beach, golf, and movies. I also have tall people problems ;).