> ## 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

> Erläutert die verschiedenen Antworttypen in Laravel und wie Sie aus einem Controller die passende Antwort zurückgeben.

## Was ist eine Response

Controller und Routen müssen dem Browser eine **Antwort** liefern.
Laravel bietet einfache Wege, um Strings, Arrays, Views, Redirects, JSON und weitere Antwortformen zurückzugeben.

## Einfache Antworten

### String zurückgeben

Die einfachste Antwort ist ein String.
Laravel wandelt ihn automatisch in eine HTTP-Antwort um.

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

### Array zurückgeben

Ein zurückgegebenes Array wird von Laravel automatisch in JSON umgewandelt.

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

<Info>
  Auch Eloquent-Modelle oder -Collections werden direkt in JSON konvertiert. Ein häufig genutztes Muster für einfache APIs.
</Info>

### Eloquent-Modell zurückgeben

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

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

## Das Response-Objekt

Mit dem Helper `response()` geben Sie detailliert HTTP-Status und Header vor.

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

Das erste Argument ist der Body, das zweite der HTTP-Status.

### Häufig verwendete HTTP-Statuscodes

| Code  | Bedeutung                                    |
| ----- | -------------------------------------------- |
| `200` | OK (Erfolg)                                  |
| `201` | Created (Ressource angelegt)                 |
| `204` | No Content (kein Inhalt)                     |
| `301` | Moved Permanently (dauerhafte Weiterleitung) |
| `302` | Found (temporäre Weiterleitung)              |
| `404` | Not Found (nicht gefunden)                   |
| `422` | Unprocessable Entity (Validierungsfehler)    |
| `500` | Internal Server Error (Server-Fehler)        |

## View-Antwort

Um aus einem Controller eine Blade-View auszuliefern, verwenden Sie `view()`.
Das ist die häufigste Antwort in Webanwendungen.

```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]);
    }
}
```

Das erste Argument ist der View-Name, das zweite ein Array mit Daten.

<Tip>
  Mit dem Return-Typ-Hint `Illuminate\View\View` machen Sie die Absicht Ihres Codes explizit.
</Tip>

### Feineinstellung mit `response()->view()`

Möchten Sie auch Status und Header setzen, verwenden Sie `response()->view()`.

```php theme={null}
return response()
    ->view('errors.404', ['message' => 'Seite nicht gefunden'], 404);
```

## Redirects

### Einfacher Redirect

`redirect()` liefert eine Redirect-Response.
Häufig verwendet nach Formularübermittlungen.

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

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

Beispiel im 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
    {
        // Post speichern...

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

### Redirect zu einer benannten Route

Mit `route()` verweisen Sie über den Routennamen statt einer festen URL.
Best Practice, da sich URLs so ändern können, ohne dass Code angepasst werden muss.

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

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

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

### Zurück zur vorherigen Seite

Mit `back()` gelangt der Nutzer zur vorherigen Seite zurück.
Typisch nach fehlgeschlagener Validierung.

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

// Mit erhaltenen Eingaben
return back()->withInput();
```

### Redirect mit Flash-Nachricht

Mit `with()` legen Sie eine Nachricht in die Session ab.
Praktisch für Erfolgsmeldungen nach einer Formularsubmission.

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

Im Blade-Template zeigen Sie sie an:

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

## JSON-Antworten

Für APIs verwenden Sie `response()->json()`.
Der Header `Content-Type: application/json` wird automatisch gesetzt.

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

Auch mit Statuscode:

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

Im 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
    {
        // Mit validierten Daten erstellen (nach Form Request oder $request->validate())
        $user = User::create($request->validated());

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

<Info>
  Auch das einfache Rückgeben eines Arrays oder Eloquent-Modells liefert JSON. `response()->json()` gibt Ihnen jedoch feine Kontrolle über Status und Header.
</Info>

## Response-Header

Header ergänzen Sie mit `header()`.

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

Mehrere Header gleichzeitig setzen Sie mit `withHeaders()`.

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

## Praxisbeispiel: Kombinationen im Controller

Ein Beispiel, das die typischen Response-Varianten in einem Controller kombiniert.

<Steps>
  <Step title="Routen definieren">
    ```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 implementieren">
    ```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
    {
        // Übersicht: View
        public function index(): View
        {
            $posts = Post::latest()->get();

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

        // Erstellungs-Formular: View
        public function create(): View
        {
            return view('posts.create');
        }

        // Speichern: Redirect
        public function store(Request $request): RedirectResponse
        {
            // Mit validierten Daten anlegen (falls Form Request)
            $post = Post::create($request->validated());

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

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

        // Löschen: Redirect
        public function destroy(Post $post): RedirectResponse
        {
            $post->delete();

            return redirect()
                ->route('posts.index')
                ->with('success', 'Beitrag gelöscht.');
        }
    }
    ```
  </Step>
</Steps>

<Tip>
  In Web-Apps ist die klare Trennung zwischen `View` und `RedirectResponse` üblich. Anzeigen liefern `View`, verändernde Aktionen (Anlegen, Aktualisieren, Löschen) enden typischerweise mit einer `RedirectResponse`.
</Tip>

## Nächste Schritte

<Card title="Validierung" icon="check-circle" href="/de/validation">
  Erfahren Sie, wie Sie Eingaben validieren, bevor Sie eine Response ausliefern.
</Card>


## Related topics

- [VoicevoxResponse - VOICEVOX für Laravel](/de/packages/laravel-voicevox/response.md)
- [Core-Paket und eigene Treiber - Feedable](/de/packages/feedable/core.md)
- [Erste Analyse: Laravel Passkeys (passkeys-server + @laravel/passkeys)](/de/blog/passkeys-introduction.md)
- [Upgrade-Anleitung von Laravel 12 auf 13](/de/blog/upgrade-12-to-13.md)
- [Rate Limiting anpassen](/de/advanced/rate-limiting.md)