> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Validazione

> Come validare i dati di input dei form usando le funzionalità di validazione di Laravel.

## Cos'è la validazione

La validazione consiste nel verificare che i dati inviati dall'utente soddisfino il formato e le condizioni attese.
Laravel offre una funzionalità di validazione semplice e potente tramite il metodo `validate` dell'oggetto request o tramite classi form request dedicate.

```mermaid theme={null}
flowchart TD
    A["Ricezione della richiesta HTTP"] --> B["Applicazione delle regole di validazione"]
    B --> C{{"Validazione<br>superata?"}}
    C -->|"Successo"| D["Recupero dei dati validati"]
    D --> E["Esecuzione della logica del controller"]
    E --> F["Response di successo"]
    C -->|"Fallita<br>(richiesta web)"| G["Redirect alla schermata precedente<br>Errori salvati in sessione"]
    C -->|"Fallita<br>(richiesta API)"| H["422 Unprocessable Entity<br>Response JSON con errori"]
```

## Validazione nel controller

### Uso di `$request->validate()`

Chiamare `$request->validate()` all'interno del metodo del controller è il modo più semplice di validare.
Se la validazione fallisce, Laravel reindirizza automaticamente l'utente alla schermata precedente e salva gli errori in sessione.

Definisci le route.

```php theme={null}
use App\Http\Controllers\PostController;

Route::get('/post/create', [PostController::class, 'create']);
Route::post('/post', [PostController::class, 'store']);
```

Crea il controller.

```php theme={null}
<?php

namespace App\Http\Controllers;

use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\View\View;

class PostController extends Controller
{
    public function create(): View
    {
        return view('post.create');
    }

    public function store(Request $request): RedirectResponse
    {
        $validated = $request->validate([
            'title' => 'required|string|max:255',
            'body'  => 'required|string',
            'email' => 'required|email',
        ]);

        // Salva il post con i dati validati...

        return redirect('/posts');
    }
}
```

Al metodo `validate` passi un array con nome del campo come chiave e regole come valore.
Puoi separare le regole con il pipe `|` o indicarle come array.

```php theme={null}
// Separazione con pipe
'title' => 'required|string|max:255',

// Formato array
'title' => ['required', 'string', 'max:255'],
```

### Regole di validazione principali

| Regola           | Descrizione                                                    |
| ---------------- | -------------------------------------------------------------- |
| `required`       | Il valore deve esistere e non essere vuoto                     |
| `string`         | Deve essere una stringa                                        |
| `email`          | Deve essere un'email valida                                    |
| `min:valore`     | Lunghezza minima della stringa o valore minimo del numero      |
| `max:valore`     | Lunghezza massima della stringa o valore massimo del numero    |
| `unique:tabella` | Il valore deve essere univoco nella tabella indicata           |
| `nullable`       | Consente anche il valore `null`                                |
| `integer`        | Deve essere un intero                                          |
| `boolean`        | Deve essere un valore booleano (`true`/`false`, `1`/`0`, ecc.) |
| `date`           | Deve essere una data valida                                    |
| `confirmed`      | Deve corrispondere al campo `nomecampo_confirmation`           |

<Info>
  Puoi consultare tutte le regole disponibili nella [documentazione ufficiale](https://laravel.com/docs/validation#available-validation-rules).
</Info>

### Uso dei dati validati

Il valore restituito da `validate` è un array che contiene solo i dati che hanno superato la validazione.
Puoi usarli in modo sicuro come dati affidabili.

```php theme={null}
$validated = $request->validate([
    'title' => 'required|string|max:255',
    'body'  => 'required|string',
]);

// $validated ha la forma ['title' => '...', 'body' => '...']
Post::create($validated);
```

## Visualizzazione degli errori in Blade

Se la validazione fallisce, Laravel rende automaticamente disponibile in tutte le viste la variabile `$errors`.
Se ne occupa il middleware `ShareErrorsFromSession` incluso nel gruppo `web`.

### Mostrare tutti gli errori in un elenco

```blade theme={null}
@if ($errors->any())
    <ul>
        @foreach ($errors->all() as $error)
            <li>{{ $error }}</li>
        @endforeach
    </ul>
@endif
```

### Mostrare gli errori per singolo campo

Con la direttiva `@error` puoi mostrare inline l'errore di un campo specifico.

```blade theme={null}
<label for="title">Titolo</label>

<input
    id="title"
    type="text"
    name="title"
    value="{{ old('title') }}"
    class="@error('title') is-invalid @enderror"
/>

@error('title')
    <div class="error-message">{{ $message }}</div>
@enderror
```

<Tip>
  Con `old('nomecampo')` puoi ripopolare il form con i valori inseriti dall'utente anche dopo un fallimento della validazione.
</Tip>

## Form request

### Cosa sono le form request

Quando la logica di validazione diventa complessa, è utile estrarla in classi "form request".
Una form request è una classe request personalizzata che raccoglie in un'unica classe la logica di validazione e di autorizzazione.

```mermaid theme={null}
flowchart TD
    A["Chiamata del metodo del controller"] --> B["Creazione dell'istanza FormRequest"]
    B --> C["Esecuzione del metodo authorize()"]
    C --> D{{"Autorizzazione OK?"}}
    D -->|"false"| E["Response 403 Forbidden"]
    D -->|"true"| F["Esecuzione del metodo rules()"]
    F --> G["Esecuzione della validazione"]
    G --> H{{"Validazione<br>superata?"}}
    H -->|"Fallita"| I["Response di errore<br>di validazione"]
    H -->|"Superata"| J["Esecuzione del metodo del controller"]
```

### Creazione di una form request

Genera una classe form request con il comando Artisan `make:request`.

```shell theme={null}
php artisan make:request StorePostRequest
```

Viene generato `app/Http/Requests/StorePostRequest.php`.

```php theme={null}
<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StorePostRequest extends FormRequest
{
    /**
     * Determina se l'utente ha il diritto di eseguire questa richiesta
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Restituisce le regole di validazione da applicare a questa richiesta
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        return [
            'title' => 'required|string|max:255',
            'body'  => 'required|string',
            'email' => 'required|email|unique:posts',
        ];
    }
}
```

### Metodo `rules()`

Restituisce le regole di validazione come array. Stesso formato dell'array passato a `validate` del controller.

### Metodo `authorize()`

Determina se l'utente è autorizzato a eseguire la richiesta.
Restituendo `true` l'autorizzazione è concessa; restituendo `false` viene restituita automaticamente una response 403.

Se vuoi consentire solo agli utenti autenticati puoi verificare con `auth()->check()`.
Nel tutorial è sufficiente restituire `true`.

<Warning>
  Se `authorize` restituisce `false`, il metodo del controller non viene eseguito e viene restituita una response 403 Forbidden.
</Warning>

### Iniezione nel controller

Basta indicare la form request come type hint del metodo del controller.
La validazione viene eseguita prima che il controller venga chiamato, quindi non serve scriverla nel metodo.

```php theme={null}
use App\Http\Requests\StorePostRequest;

class PostController extends Controller
{
    public function store(StorePostRequest $request): RedirectResponse
    {
        // Se sei qui, la validazione è già passata

        $validated = $request->validated();

        Post::create($validated);

        return redirect('/posts');
    }
}
```

Con `$request->validated()` ottieni solo i dati validati.

## Esempio pratico: creazione e salvataggio di un form di post

Il flusso completo dalla visualizzazione del form all'invio, validazione e salvataggio.

<Steps>
  <Step title="Definizione delle route">
    ```php theme={null}
    use App\Http\Controllers\PostController;

    Route::get('/posts/create', [PostController::class, 'create']);
    Route::post('/posts', [PostController::class, 'store']);
    ```
  </Step>

  <Step title="Creazione della form request">
    ```shell theme={null}
    php artisan make:request StorePostRequest
    ```

    ```php theme={null}
    public function rules(): array
    {
        return [
            'title' => 'required|string|max:255',
            'body'  => 'required|string',
        ];
    }

    public function authorize(): bool
    {
        return true;
    }
    ```
  </Step>

  <Step title="Implementazione del controller">
    ```php theme={null}
    use App\Http\Requests\StorePostRequest;
    use App\Models\Post;

    class PostController extends Controller
    {
        public function create(): View
        {
            return view('posts.create');
        }

        public function store(StorePostRequest $request): RedirectResponse
        {
            Post::create($request->validated());

            return redirect('/posts');
        }
    }
    ```
  </Step>

  <Step title="Creazione del template Blade">
    ```blade theme={null}
    {{-- resources/views/posts/create.blade.php --}}

    <h1>Nuovo post</h1>

    @if ($errors->any())
        <ul>
            @foreach ($errors->all() as $error)
                <li>{{ $error }}</li>
            @endforeach
        </ul>
    @endif

    <form method="POST" action="/posts">
        @csrf

        <div>
            <label for="title">Titolo</label>
            <input
                id="title"
                type="text"
                name="title"
                value="{{ old('title') }}"
            />
            @error('title')
                <span>{{ $message }}</span>
            @enderror
        </div>

        <div>
            <label for="body">Corpo</label>
            <textarea id="body" name="body">{{ old('body') }}</textarea>
            @error('body')
                <span>{{ $message }}</span>
            @enderror
        </div>

        <button type="submit">Pubblica</button>
    </form>
    ```
  </Step>
</Steps>

<Info>
  Nei form Blade includi sempre la direttiva `@csrf`. Senza il token CSRF Laravel restituisce l'errore 419.
</Info>

## Prossimi passi

<Card title="Richieste HTTP" icon="arrow-up-from-bracket" href="/it/requests">
  Rivedi come ottenere i dati usando l'oggetto request.
</Card>


## Related topics

- [Laravel Prompts](/it/prompts.md)
- [Laravel MCP](/it/mcp.md)
- [Test HTTP](/it/http-tests.md)
- [Regole di validazione personalizzate](/it/advanced/custom-validation-rules.md)
- [⚡Introduzione a Livewire 4 — creare UI reattive senza JavaScript](/it/blog/livewire-introduction.md)