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

# Response

> I tipi di response di Laravel e come restituire da un controller la response appropriata.

## Cos'è una response

Un controller o una route devono restituire una qualche **response** al browser dell'utente.
Laravel offre un meccanismo semplice per restituire response di vari formati: stringhe, array, viste, redirect, JSON e altro.

## Response di base

### Restituire una stringa

La response più semplice è la restituzione di una stringa.
Laravel la converte automaticamente in una response HTTP appropriata.

```php theme={null}
Route::get('/', function () {
    return 'Hello World';
});
```

### Restituire un array

Se restituisci un array, Laravel lo converte automaticamente in JSON.

```php theme={null}
Route::get('/users', function () {
    return [
        ['id' => 1, 'name' => 'Rossi'],
        ['id' => 2, 'name' => 'Bianchi'],
    ];
});
```

<Info>
  Restituendo direttamente un modello Eloquent o una collezione, viene convertito automaticamente in JSON. È un pattern molto usato per creare API velocemente.
</Info>

### Restituire un modello Eloquent

```php theme={null}
use App\Models\User;

Route::get('/user/{user}', function (User $user) {
    return $user;
});
```

## Oggetto Response

Con l'helper `response()` puoi restituire una response con codice HTTP e header specifici.

```php theme={null}
Route::get('/home', function () {
    return response('Hello World', 200)
        ->header('Content-Type', 'text/plain');
});
```

Il primo argomento di `response()` è il body, il secondo il codice HTTP.

### Codici HTTP più usati

| Codice | Significato                                  |
| ------ | -------------------------------------------- |
| `200`  | OK (successo)                                |
| `201`  | Created (risorsa creata)                     |
| `204`  | No Content (nessun contenuto)                |
| `301`  | Moved Permanently (redirect permanente)      |
| `302`  | Found (redirect temporaneo)                  |
| `404`  | Not Found (non trovato)                      |
| `422`  | Unprocessable Entity (errore di validazione) |
| `500`  | Internal Server Error (errore del server)    |

## Response di una vista

Per mostrare un template Blade da un controller usa `view()`.
È la response più comune nelle applicazioni web.

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

namespace App\Http\Controllers;

use Illuminate\View\View;

class HomeController extends Controller
{
    public function index(): View
    {
        $users = [
            ['name' => 'Rossi', 'email' => 'rossi@example.com'],
            ['name' => 'Bianchi', 'email' => 'bianchi@example.com'],
        ];

        return view('users.index', ['users' => $users]);
    }
}
```

Il primo argomento di `view()` è il nome della vista, il secondo un array di dati da passare.

<Tip>
  Indicando come type hint del valore di ritorno `Illuminate\View\View` rendi chiara l'intenzione del codice.
</Tip>

### Controllo dettagliato con `response()->view()`

Se vuoi indicare anche codice e header usa `response()->view()`.

```php theme={null}
return response()
    ->view('errors.404', ['message' => 'Pagina non trovata'], 404);
```

## Redirect

### Redirect di base

L'helper `redirect()` restituisce una response di redirect.
Molto usato per inviare l'utente a un'altra pagina dopo l'invio di un form.

```php theme={null}
use Illuminate\Http\RedirectResponse;

Route::get('/old-page', function (): RedirectResponse {
    return redirect('/new-page');
});
```

Esempio d'uso in un controller.

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

namespace App\Http\Controllers;

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

class PostController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        // Logica di salvataggio del post...

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

### Redirect verso una route con nome

Con la funzione `route()` puoi indicare la destinazione tramite il nome della route senza scrivere direttamente l'URL.
Poiché non serve modificare il codice se l'URL cambia, la best practice è sfruttare le route con nome.

```php theme={null}
// Assegna un nome alla route
Route::get('/posts', [PostController::class, 'index'])->name('posts.index');
Route::get('/posts/{post}', [PostController::class, 'show'])->name('posts.show');
```

```php theme={null}
// Redirect verso la route con nome
return redirect()->route('posts.index');

// Passando parametri di route
return redirect()->route('posts.show', ['post' => $post->id]);
```

### Tornare alla pagina precedente

Con `back()` torni alla pagina in cui l'utente era prima.
Molto usato per il redirect in caso di errori di validazione.

```php theme={null}
return back();

// Torna mantenendo i dati di input
return back()->withInput();
```

### Redirect con messaggi flash

Con `with()` puoi allegare un messaggio in sessione al redirect.
Utile per mostrare un messaggio dopo il successo di un form.

```php theme={null}
return redirect('/posts')->with('success', 'Post creato.');
```

Mostra il messaggio nel template Blade.

```blade theme={null}
@if (session('success'))
    <div class="alert alert-success">
        {{ session('success') }}
    </div>
@endif
```

## Response JSON

Quando crei API usa `response()->json()` per restituire una response JSON.
Viene impostato automaticamente l'header `Content-Type: application/json`.

```php theme={null}
use Illuminate\Http\JsonResponse;

Route::get('/api/users', function (): JsonResponse {
    $users = [
        ['id' => 1, 'name' => 'Rossi'],
        ['id' => 2, 'name' => 'Bianchi'],
    ];

    return response()->json($users);
});
```

Puoi specificare anche il codice.

```php theme={null}
return response()->json(['message' => 'Creato'], 201);
```

Esempio d'uso in un controller.

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

namespace App\Http\Controllers;

use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function index(): JsonResponse
    {
        $users = User::all();

        return response()->json($users);
    }

    public function store(Request $request): JsonResponse
    {
        // Crea con i dati validati (dopo una form request o $request->validate())
        $user = User::create($request->validated());

        return response()->json($user, 201);
    }
}
```

<Info>
  Anche restituendo semplicemente un array o un modello Eloquent ottieni una response JSON, ma con `response()->json()` puoi controllare codice e header nel dettaglio.
</Info>

## Header della response

Con il metodo `header()` aggiungi header HTTP alla response.

```php theme={null}
return response('Hello World')
    ->header('Content-Type', 'text/plain')
    ->header('X-Custom-Header', 'MyValue');
```

Per impostare più header in un unico passaggio usa `withHeaders()`.

```php theme={null}
return response('Hello World')
    ->withHeaders([
        'Content-Type' => 'text/plain',
        'X-Custom-Header' => 'MyValue',
        'Cache-Control' => 'no-cache',
    ]);
```

## Esempio pratico: uso differenziato nei controller

Esempio che riassume l'uso delle response in base allo scopo.

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

    Route::get('/posts', [PostController::class, 'index'])->name('posts.index');
    Route::get('/posts/create', [PostController::class, 'create'])->name('posts.create');
    Route::post('/posts', [PostController::class, 'store'])->name('posts.store');
    Route::get('/posts/{post}', [PostController::class, 'show'])->name('posts.show');
    Route::delete('/posts/{post}', [PostController::class, 'destroy'])->name('posts.destroy');
    ```
  </Step>

  <Step title="Implementazione del controller">
    ```php theme={null}
    <?php

    namespace App\Http\Controllers;

    use App\Models\Post;
    use Illuminate\Http\RedirectResponse;
    use Illuminate\Http\Request;
    use Illuminate\View\View;

    class PostController extends Controller
    {
        // Elenco: restituisce una vista
        public function index(): View
        {
            $posts = Post::latest()->get();

            return view('posts.index', ['posts' => $posts]);
        }

        // Form di creazione: restituisce una vista
        public function create(): View
        {
            return view('posts.create');
        }

        // Salvataggio: restituisce un redirect
        public function store(Request $request): RedirectResponse
        {
            // Crea con dati validati (se usi una form request)
            $post = Post::create($request->validated());

            return redirect()
                ->route('posts.show', ['post' => $post->id])
                ->with('success', 'Post creato.');
        }

        // Dettaglio: restituisce una vista
        public function show(Post $post): View
        {
            return view('posts.show', ['post' => $post]);
        }

        // Eliminazione: restituisce un redirect
        public function destroy(Post $post): RedirectResponse
        {
            $post->delete();

            return redirect()
                ->route('posts.index')
                ->with('success', 'Post eliminato.');
        }
    }
    ```
  </Step>
</Steps>

<Tip>
  Nelle app web l'uso di `View` e `RedirectResponse` è fondamentale. Il pattern tipico è restituire `View` per le azioni di visualizzazione e `RedirectResponse` per le azioni di modifica (creazione, aggiornamento, eliminazione) dopo l'elaborazione.
</Tip>

## Prossimi passi

<Card title="Validazione" icon="check-circle" href="/it/validation">
  Rivedi come validare i dati di input prima di restituire la response.
</Card>


## Related topics

- [VoicevoxResponse - VOICEVOX for Laravel](/it/packages/laravel-voicevox/response.md)
- [Pacchetto core e driver personalizzati - Feedable](/it/packages/feedable/core.md)
- [Guida all'aggiornamento da Laravel 12 a 13](/it/blog/upgrade-12-to-13.md)
- [Introduzione al testing](/it/testing.md)
- [Trait Conditionable](/it/advanced/conditionable.md)