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

# Richieste HTTP

> Come recuperare i dati delle richieste HTTP usando l'oggetto Illuminate\Http\Request di Laravel.

## Cos'è l'oggetto Request

`Illuminate\Http\Request` è la classe che consente di gestire in modo orientato agli oggetti le richieste HTTP ricevute dall'applicazione.
Ti dà accesso a tutte le informazioni contenute nella richiesta: dati del form, query string, file, header e altro.

## Iniezione della Request in un controller

Se annoti con il tipo `Illuminate\Http\Request` un metodo di un controller, il service container di Laravel inietta automaticamente l'istanza della request.

```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 per salvare l'utente...

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

Puoi usare il type hint allo stesso modo anche nelle closure delle route.

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

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

### Uso con i parametri di route

Se un metodo controller riceve anche parametri di route, scrivili dopo `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
{
    // Accedi ai dati della richiesta con $request e al parametro di route con $id

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

## Recupero dei dati della richiesta

### Ottenere tutti i dati di input

Con il metodo `all` recuperi tutti i dati di input come array.
Funziona sia con richieste da form HTML sia con richieste XHR.

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

### Ottenere un campo specifico

Il metodo `input` recupera il valore dall'intero payload della richiesta (query string inclusa), indipendentemente dal metodo HTTP.

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

Puoi indicare un valore predefinito nel secondo argomento se il valore non esiste.

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

Per gli input di tipo array accedi con la notazione dot.

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

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

### Ottenere la query string

Il metodo `query` recupera valori solo dalla query string (dopo il `?` nell'URL).

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

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

// Ottieni tutta la query string come array
$query = $request->query();
```

<Info>
  `input` considera sia il corpo della richiesta sia la query string, mentre `query` considera solo la query string.
  Usa `query` se vuoi distinguere i dati POST dai parametri URL.
</Info>

### Recupero tipizzato

Oltre a `input`, ci sono metodi per recuperare i valori specificando il tipo.

```php theme={null}
// Ottieni come stringa (istanza Stringable)
$name = $request->string('name')->trim();

// Ottieni come intero
$perPage = $request->integer('per_page');

// Ottieni come booleano ("1", "true", "on", "yes" → true)
$archived = $request->boolean('archived');

// Ottieni come array
$versions = $request->array('versions');

// Ottieni la data come istanza Carbon
$birthday = $request->date('birthday');
```

### Proprietà dinamiche

Puoi anche accedere ai campi come proprietà usando direttamente il loro nome.

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

<Tip>
  Con le proprietà dinamiche, Laravel cerca prima il valore nel payload della richiesta e, se non lo trova, nei parametri di route.
</Tip>

### Ottenere un sottoinsieme dei dati di input

Con `only` ed `except` puoi ottenere un sottoinsieme dei dati di input.

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

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

## Verifica della presenza di un input

Con il metodo `has` verifichi che il valore sia presente nella richiesta.

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

// Verifica che siano presenti tutte le chiavi
if ($request->has(['name', 'email'])) {
    // ...
}
```

Per verificare la presenza escludendo le stringhe vuote usa `filled`.

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

Se il valore non esiste oppure è una stringa vuota usa `isNotFilled`.

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

## Verifica del path e del metodo della richiesta

### Ottenere e verificare il path

```php theme={null}
// Ottieni il path (es. "foo/bar")
$uri = $request->path();

// Verifica se corrisponde a un pattern (puoi usare il wildcard *)
if ($request->is('admin/*')) {
    // ...
}

// Verifica se corrisponde a una route con nome
if ($request->routeIs('admin.*')) {
    // ...
}
```

### Ottenere l'URL

```php theme={null}
// URL senza query string
$url = $request->url();

// URL con query string
$urlWithQueryString = $request->fullUrl();
```

### Verifica del metodo HTTP

Con `isMethod` puoi verificare il metodo HTTP.

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

if ($request->isMethod('post')) {
    // Elabora solo richieste POST
}
```

## Upload di file

### Recuperare il file caricato

Con il metodo `file` ottieni il file caricato.
Viene restituita un'istanza di `Illuminate\Http\UploadedFile`.

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

// Puoi ottenerlo anche come proprietà dinamica
$file = $request->photo;
```

Per verificare se il file esiste usa `hasFile`.

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

### Salvataggio del file

Con il metodo `store` salvi il file nello storage.
Il nome del file viene generato automaticamente.

```php theme={null}
// Salva nella directory "images" del disk predefinito
$path = $request->photo->store('images');

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

Se vuoi specificare il nome del file usa `storeAs`.

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

<Warning>
  Quando accetti upload di file, valida sempre il tipo e la dimensione del file.
  Si consiglia di gestirli in modo sicuro tramite la validazione.
</Warning>

## Esempio pratico: ricezione dei dati di un form

Esempio di ricezione in un controller dei dati di un form di registrazione utente.

```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
    {
        // Ottieni i dati del form
        $name = $request->input('name');
        $email = $request->input('email');
        $password = $request->input('password');

        // Ottieni solo i dati necessari
        $data = $request->only(['name', 'email', 'password']);

        // Logica per creare l'utente...

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

Definisci la route corrispondente.

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

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

## Prossimi passi

<Card title="Middleware" icon="shield" href="/it/middleware">
  Ripassa come usare i middleware per filtrare le richieste.
</Card>


## Related topics

- [Middleware](/it/middleware.md)
- [Validazione](/it/validation.md)
- [Costruire una SPA con Inertia.js](/it/blog/inertia-introduction.md)
- [Test avanzati con Pest](/it/advanced/testing-pest.md)
- [Laravel Telescope](/it/telescope.md)