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

> Leer hoe je met het Illuminate\Http\Request-object van Laravel de gegevens van een HTTP-request ophaalt.

## Wat is het Request-object?

`Illuminate\Http\Request` is de klasse waarmee je het HTTP-request dat je applicatie ontvangt objectgeoriënteerd verwerkt.
Je hebt toegang tot alle informatie in het request: formulierdata, querystrings, bestanden, headers en meer.

## Het request injecteren in een controller

Als je `Illuminate\Http\Request` type-hint in een controllermethode, injecteert de service container van Laravel automatisch de request-instantie.

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

        // Logica om de gebruiker op te slaan...

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

In een route-closure kun je op dezelfde manier type-hinten.

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

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

### Combineren met routeparameters

Ontvangt je controllermethode ook routeparameters, dan zet je de routeparameters na de `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
{
    // Via $request benader je de requestdata, via $id de routeparameter

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

## Requestdata ophalen

### Alle invoerdata ophalen

Met de `all`-methode haal je alle invoerdata op als array.
Dit werkt zowel voor requests vanuit een HTML-formulier als voor XHR-requests.

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

### Een specifiek veld ophalen

De `input`-methode haalt, ongeacht de HTTP-methode, een waarde op uit de volledige request-payload (inclusief de querystring).

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

Als tweede argument kun je een standaardwaarde opgeven voor als de waarde niet bestaat.

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

Array-invoer benader je met de puntnotatie.

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

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

### De querystring ophalen

De `query`-methode haalt alleen waarden op uit de querystring (het deel na `?` in de URL).

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

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

// Alle querystring-waarden ophalen als array
$query = $request->query();
```

<Info>
  `input` kijkt zowel naar de request-body als naar de querystring, terwijl `query` alleen naar de querystring kijkt.
  Wil je onderscheid maken tussen POST-data van een formulier en URL-parameters, gebruik dan `query`.
</Info>

### Getypeerd ophalen

Naast `input` zijn er ook methodes die invoerwaarden met een specifiek type ophalen.

```php theme={null}
// Ophalen als string (Stringable-instantie)
$name = $request->string('name')->trim();

// Ophalen als integer
$perPage = $request->integer('per_page');

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

// Ophalen als array
$versions = $request->array('versions');

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

### Dynamische properties

Je kunt een veldnaam ook rechtstreeks als property benaderen.

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

<Tip>
  Bij dynamische properties wordt eerst gezocht in de request-payload; wordt daar niets gevonden, dan wordt gezocht in de routeparameters.
</Tip>

### Een deel van de invoerdata ophalen

Met `only` en `except` haal je een subset van de invoerdata op.

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

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

## Controleren of invoer aanwezig is

Met de `has`-methode controleer je of een waarde in het request zit.

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

// Controleren of alle opgegeven sleutels aanwezig zijn
if ($request->has(['name', 'email'])) {
    // ...
}
```

Wil je weten of er een waarde aanwezig is die geen lege string is, gebruik dan `filled`.

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

Is de waarde afwezig of een lege string, dan gebruik je `isNotFilled`.

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

## Het pad en de methode van het request controleren

### Het pad ophalen en controleren

```php theme={null}
// Pad ophalen (bijvoorbeeld: "foo/bar")
$uri = $request->path();

// Controleren of het pad overeenkomt met een patroon (wildcard * is toegestaan)
if ($request->is('admin/*')) {
    // ...
}

// Controleren of het overeenkomt met een benoemde route
if ($request->routeIs('admin.*')) {
    // ...
}
```

### De URL ophalen

```php theme={null}
// URL zonder querystring
$url = $request->url();

// URL inclusief querystring
$urlWithQueryString = $request->fullUrl();
```

### De HTTP-methode controleren

Met `isMethod` controleer je de HTTP-methode.

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

if ($request->isMethod('post')) {
    // Alleen POST-requests verwerken
}
```

## Bestandsuploads

### Geüploade bestanden ophalen

Met de `file`-methode haal je een geüpload bestand op.
Je krijgt een `Illuminate\Http\UploadedFile`-instantie terug.

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

// Kan ook via een dynamische property
$file = $request->photo;
```

Om te controleren of er een bestand aanwezig is, gebruik je `hasFile`.

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

### Bestanden opslaan

Met de `store`-methode sla je een bestand op in de storage.
De bestandsnaam wordt automatisch gegenereerd.

```php theme={null}
// Opslaan in de directory "images" op de standaarddisk
$path = $request->photo->store('images');

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

Wil je zelf een bestandsnaam opgeven, gebruik dan `storeAs`.

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

<Warning>
  Accepteer je bestandsuploads, valideer dan altijd het bestandstype en de bestandsgrootte.
  We raden aan om dit veilig af te handelen met validatie.
</Warning>

## Praktijkvoorbeeld: formulierdata ontvangen

Een voorbeeld waarin je de data van een registratieformulier ontvangt in een controller.

```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
    {
        // Formulierdata ophalen
        $name = $request->input('name');
        $email = $request->input('email');
        $password = $request->input('password');

        // Alleen de benodigde data ophalen
        $data = $request->only(['name', 'email', 'password']);

        // Logica om de gebruiker aan te maken...

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

Definieer de bijbehorende route.

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

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

## Volgende stap

<Card title="Middleware" icon="shield" href="/nl/middleware">
  Bekijk opnieuw hoe je requests filtert met middleware.
</Card>


## Related topics

- [HTTP-client](/nl/http-client.md)
- [Request lifecycle](/nl/lifecycle.md)
- [HTTP-tests](/nl/http-tests.md)
- [Autorisatie (gates en policies)](/nl/authorization.md)
- [Een SPA bouwen met Inertia.js](/nl/blog/inertia-introduction.md)