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

# HTTP-Requests

> Erläutert, wie Sie mit dem `Illuminate\Http\Request`-Objekt in Laravel HTTP-Request-Daten abrufen.

## Was ist das Request-Objekt

`Illuminate\Http\Request` ist die Klasse, mit der Sie eingehende HTTP-Anfragen objektorientiert verarbeiten.
Sie greifen darüber auf Formulardaten, Query-String, Dateien, Header und alle weiteren Bestandteile eines Requests zu.

## Request-Injection in Controllern

Wenn Sie in einer Controller-Methode `Illuminate\Http\Request` mit Type Hint deklarieren, injiziert der Service Container automatisch eine Instanz.

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

namespace App\Http\Controllers;

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

class UserController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        $name = $request->input('name');

        // Benutzer speichern...

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

Auch in Route-Closures können Sie den Type Hint verwenden.

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

Route::get('/', function (Request $request) {
    // ...
});
```

### Kombination mit Route-Parametern

Erwartet die Methode auch Routenparameter, listen Sie diese nach `Request`.

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

Route::put('/user/{id}', [UserController::class, 'update']);
```

```php theme={null}
public function update(Request $request, string $id): RedirectResponse
{
    // Zugriff auf Request-Daten via $request und auf den Routenparameter via $id

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

## Request-Daten abrufen

### Alle Eingaben abrufen

`all` gibt alle Eingabedaten als Array zurück.
Funktioniert für HTML-Formulare wie auch XHR-Requests.

```php theme={null}
$input = $request->all();
```

### Einzelne Felder abrufen

`input` ruft unabhängig von der HTTP-Methode Werte aus dem gesamten Payload ab (inkl. Query-String).

```php theme={null}
$name = $request->input('name');
```

Als zweites Argument geben Sie einen Default-Wert an.

```php theme={null}
$name = $request->input('name', 'Sally');
```

Auf Array-Eingaben greifen Sie mit Punkt-Notation zu.

```php theme={null}
$name = $request->input('products.0.name');

$names = $request->input('products.*.name');
```

### Query-String abrufen

`query` liest ausschließlich den Query-String (nach `?`).

```php theme={null}
$name = $request->query('name');

$name = $request->query('name', 'Helen');

// Gesamten Query-String als Array
$query = $request->query();
```

<Info>
  `input` deckt Body und Query-String ab, `query` nur den Query-String.
  Wenn Sie klar zwischen POST-Daten und URL-Parametern unterscheiden möchten, greifen Sie zu `query`.
</Info>

### Typisierter Abruf

Es gibt Methoden, die Eingaben direkt in einen Zieltyp umwandeln.

```php theme={null}
// Als String (Stringable-Instanz)
$name = $request->string('name')->trim();

// Als Integer
$perPage = $request->integer('per_page');

// Als Boolean ("1", "true", "on", "yes" → true)
$archived = $request->boolean('archived');

// Als Array
$versions = $request->array('versions');

// Datum als Carbon-Instanz
$birthday = $request->date('birthday');
```

### Dynamische Eigenschaften

Sie können Felder auch direkt als Eigenschaft ansprechen.

```php theme={null}
$name = $request->name;
```

<Tip>
  Bei dynamischen Eigenschaften wird zuerst im Request-Payload und danach in den Routenparametern gesucht.
</Tip>

### Teilmenge der Eingaben

Mit `only` und `except` erhalten Sie eine Teilmenge.

```php theme={null}
$input = $request->only(['username', 'password']);

$input = $request->except(['credit_card']);
```

## Existenz einer Eingabe prüfen

`has` prüft, ob ein Wert vorhanden ist.

```php theme={null}
if ($request->has('name')) {
    // ...
}

// Alle Schlüssel müssen vorhanden sein
if ($request->has(['name', 'email'])) {
    // ...
}
```

Für einen Wert, der nicht leer ist, verwenden Sie `filled`.

```php theme={null}
if ($request->filled('name')) {
    // ...
}
```

Kehrt die Prüfung um, verwenden Sie `isNotFilled`.

```php theme={null}
if ($request->isNotFilled('name')) {
    // ...
}
```

## Pfad und Methode prüfen

### Pfad ermitteln und prüfen

```php theme={null}
// Pfad abrufen (z. B. "foo/bar")
$uri = $request->path();

// Musterabgleich (mit Wildcard *)
if ($request->is('admin/*')) {
    // ...
}

// Abgleich anhand des Routennamens
if ($request->routeIs('admin.*')) {
    // ...
}
```

### URL abrufen

```php theme={null}
// URL ohne Query-String
$url = $request->url();

// URL mit Query-String
$urlWithQueryString = $request->fullUrl();
```

### HTTP-Methode prüfen

Mit `isMethod`.

```php theme={null}
$method = $request->method();

if ($request->isMethod('post')) {
    // Nur POST-Requests behandeln
}
```

## Datei-Uploads

### Hochgeladene Datei abrufen

`file` liefert die hochgeladene Datei als `Illuminate\Http\UploadedFile`.

```php theme={null}
$file = $request->file('photo');

// Auch als dynamische Eigenschaft
$file = $request->photo;
```

Prüfen, ob eine Datei vorhanden ist, mit `hasFile`.

```php theme={null}
if ($request->hasFile('photo')) {
    // ...
}
```

### Datei speichern

`store` speichert die Datei automatisch mit generiertem Namen.

```php theme={null}
// In das Verzeichnis "images" der Default-Disk
$path = $request->photo->store('images');

// Auf S3
$path = $request->photo->store('images', 's3');
```

Wollen Sie den Dateinamen selbst festlegen, nutzen Sie `storeAs`.

```php theme={null}
$path = $request->photo->storeAs('images', 'filename.jpg');
```

<Warning>
  Wenn Sie Datei-Uploads entgegennehmen, validieren Sie unbedingt Typ und Größe.
  Verwenden Sie Validierung für eine sichere Verarbeitung.
</Warning>

## Beispiel: Formulardaten empfangen

Ein Beispiel, das Daten eines Registrierungsformulars entgegennimmt.

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

namespace App\Http\Controllers;

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

class RegisterController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        // Formulardaten abrufen
        $name = $request->input('name');
        $email = $request->input('email');
        $password = $request->input('password');

        // Nur benötigte Felder
        $data = $request->only(['name', 'email', 'password']);

        // Benutzer erstellen...

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

Die zugehörige Route:

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

Route::post('/register', [RegisterController::class, 'store']);
```

## Nächste Schritte

<Card title="Middleware" icon="shield" href="/de/middleware">
  Frischen Sie den Einsatz von Middleware zum Filtern von Requests auf.
</Card>


## Related topics

- [Autorisierung (Gates und Policies)](/de/authorization.md)
- [SPAs mit Inertia.js entwickeln](/de/blog/inertia-introduction.md)
- [Validierung](/de/validation.md)
- [Macroable-Trait](/de/advanced/macroable.md)
- [Laravel Octane](/de/octane.md)