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.

Route::get('/', function () {
    return 'Hello World';
});

​

Restituire un array

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

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

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

​

Restituire un modello Eloquent

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.

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

namespace App\Http\Controllers;

use Illuminate\View\View;

class HomeController extends Controller
{
    public function index(): View
    {
        $users = [
            ['name' => 'Rossi', 'email' => '[e-mail]'],
            ['name' => 'Bianchi', 'email' => '[e-mail]'],
        ];

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

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

Indicando come type hint del valore di ritorno Illuminate\View\View rendi chiara l’intenzione del codice.

​

Controllo dettagliato con response()->view()

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

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.

use Illuminate\Http\RedirectResponse;

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

Esempio d’uso in un controller.

<?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.

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

// 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.

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.

return redirect('/posts')->with('success', 'Post creato.');

Mostra il messaggio nel template Blade.

@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.

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.

return response()->json(['message' => 'Creato'], 201);

Esempio d’uso in un controller.

<?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);
    }
}

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

​

Header della response

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

return response('Hello World')
    ->header('Content-Type', 'text/plain')
    ->header('X-Custom-Header', 'MyValue');

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

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.

1. Definizione delle route

   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');
   
2. Implementazione del controller

   <?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.');
       }
   }
   

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.

​

Prossimi passi

Validazione

Rivedi come validare i dati di input prima di restituire la response.