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

# Responses

> Uitleg over de soorten responses in Laravel en hoe je de juiste response teruggeeft vanuit een controller.

## Wat is een response

Controllers en routes moeten een **response** teruggeven aan de browser van de gebruiker.
Laravel biedt een eenvoudig mechanisme om responses in allerlei vormen terug te geven, zoals strings, arrays, views, redirects en JSON.

## Basisresponses

### Een string teruggeven

De eenvoudigste response is het teruggeven van een string.
Laravel zet deze automatisch om in een passende HTTP-response.

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

### Een array teruggeven

Als je een array teruggeeft, zet Laravel deze automatisch om naar JSON.

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

<Info>
  Als je een Eloquent-model of collectie rechtstreeks returnt, wordt deze automatisch omgezet naar JSON. Dit is een veelgebruikt patroon omdat je er heel eenvoudig een API mee bouwt.
</Info>

### Een Eloquent-model teruggeven

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

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

## Het Response-object

Met de `response()`-helper kun je een gedetailleerde response teruggeven waarin je de HTTP-statuscode en headers opgeeft.

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

Het eerste argument van `response()` is de body van de response, het tweede argument de HTTP-statuscode.

### Veelgebruikte HTTP-statuscodes

| Code  | Betekenis                               |
| ----- | --------------------------------------- |
| `200` | OK (geslaagd)                           |
| `201` | Created (resource succesvol aangemaakt) |
| `204` | No Content (geen inhoud)                |
| `301` | Moved Permanently (permanente redirect) |
| `302` | Found (tijdelijke redirect)             |
| `404` | Not Found (niet gevonden)               |
| `422` | Unprocessable Entity (validatiefout)    |
| `500` | Internal Server Error (serverfout)      |

## View-responses

Om vanuit een controller een Blade-template weer te geven gebruik je `view()`.
Dit is de meest voorkomende response in webapplicaties.

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

namespace App\Http\Controllers;

use Illuminate\View\View;

class HomeController extends Controller
{
    public function index(): View
    {
        $users = [
            ['name' => 'Tanaka', 'email' => 'tanaka@example.com'],
            ['name' => 'Suzuki', 'email' => 'suzuki@example.com'],
        ];

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

Het eerste argument van `view()` is de naam van de view, het tweede argument een array met data die je aan de view doorgeeft.

<Tip>
  Door `Illuminate\View\View` als return-typehint op te geven, maak je de bedoeling van je code duidelijker.
</Tip>

### Meer controle met `response()->view()`

Wil je ook een statuscode of headers meegeven, gebruik dan `response()->view()`.

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

## Redirects

### Basisredirect

De `redirect()`-helper geeft een redirect-response terug.
Je gebruikt deze vaak om de gebruiker na het versturen van een formulier naar een andere pagina te leiden.

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

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

Een voorbeeld van gebruik in een 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 om de post op te slaan...

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

### Redirecten naar een named route

Met de `route()`-functie kun je het redirect-doel opgeven via de routenaam in plaats van de URL zelf.
Zelfs als de URL verandert, hoef je niets aan te passen — het gebruik van named routes is dan ook een best practice.

```php theme={null}
// Geef de route een naam
Route::get('/posts', [PostController::class, 'index'])->name('posts.index');
Route::get('/posts/{post}', [PostController::class, 'show'])->name('posts.show');
```

```php theme={null}
// Redirect naar een named route
return redirect()->route('posts.index');

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

### Terug naar de vorige pagina

Met `back()` keert de gebruiker terug naar de pagina waar hij vandaan kwam.
Dit wordt vaak gebruikt bij een redirect na een mislukte validatie.

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

// Terugkeren met behoud van de invoerdata
return back()->withInput();
```

### Redirect met een flash-bericht

Met `with()` kun je bij een redirect een bericht in de sessie meegeven.
Handig om na een geslaagde formulierinzending een melding te tonen.

```php theme={null}
return redirect('/posts')->with('success', 'De post is aangemaakt.');
```

Het bericht toon je in een Blade-template:

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

## JSON-responses

Bij het bouwen van een API gebruik je `response()->json()` om een JSON-response terug te geven.
De header `Content-Type: application/json` wordt automatisch ingesteld.

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

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

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

Je kunt ook een statuscode opgeven.

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

Een voorbeeld van gebruik in een 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
    {
        // Aanmaken met gevalideerde data (na een form request of $request->validate())
        $user = User::create($request->validated());

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

<Info>
  Ook door simpelweg een array of Eloquent-model te returnen krijg je een JSON-response, maar met `response()->json()` heb je fijnmazige controle over statuscodes en headers.
</Info>

## Response-headers

Met de `header()`-methode voeg je HTTP-headers toe aan de response.

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

Wil je meerdere headers in één keer instellen, gebruik dan `withHeaders()`.

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

## Cookies

Om een cookie aan een response toe te voegen gebruik je `cookie()`. Wil je cookies verwijderen, dan kun je met `withoutCookie()` één cookie en met `withoutCookies()` meerdere cookies laten verlopen.

```php theme={null}
return response('Hello World')
    ->withoutCookie('name');

return response('Hello World')
    ->withoutCookies([
        'name',
        'email',
        'preferences',
    ]);
```

## Praktijkvoorbeeld: het juiste responsetype in een controller

Een voorbeeld dat laat zien welk responsetype je in welke situatie gebruikt.

<Steps>
  <Step title="Routes definiëren">
    ```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="Controller implementeren">
    ```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
    {
        // Overzicht: geeft een view terug
        public function index(): View
        {
            $posts = Post::latest()->get();

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

        // Aanmaakformulier: geeft een view terug
        public function create(): View
        {
            return view('posts.create');
        }

        // Opslaan: geeft een redirect terug
        public function store(Request $request): RedirectResponse
        {
            // Aanmaken met gevalideerde data (bij gebruik van een form request)
            $post = Post::create($request->validated());

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

        // Detailweergave: geeft een view terug
        public function show(Post $post): View
        {
            return view('posts.show', ['post' => $post]);
        }

        // Verwijderen: geeft een redirect terug
        public function destroy(Post $post): RedirectResponse
        {
            $post->delete();

            return redirect()
                ->route('posts.index')
                ->with('success', 'De post is verwijderd.');
        }
    }
    ```
  </Step>
</Steps>

<Tip>
  In webapps draait het vooral om het juiste gebruik van `View` en `RedirectResponse`. Het gangbare patroon is dat acties die iets tonen een `View` teruggeven, en acties die iets wijzigen (aanmaken, bijwerken, verwijderen) na afloop een `RedirectResponse`.
</Tip>

## Volgende stap

<Card title="Validatie" icon="check-circle" href="/nl/validation">
  Bekijk hoe je invoerdata valideert voordat je een response teruggeeft.
</Card>


## Related topics

- [Laravel MCP](/nl/mcp.md)
- [Permission requests](/nl/packages/laravel-copilot-sdk/permission-request.md)
- [VoicevoxResponse - VOICEVOX for Laravel](/nl/packages/laravel-voicevox/response.md)
- [Core-package en eigen drivers - Feedable](/nl/packages/feedable/core.md)
- [HTTP-client](/nl/http-client.md)