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

# Routing

> Come definire le route in Laravel, parametri di route e route con nome.

## Routing di base

La route più semplice di Laravel accetta un URI e una closure.
Puoi definire in modo semplice route e comportamento senza complessi file di configurazione.

```php theme={null}
use Illuminate\Support\Facades\Route;

Route::get('/greeting', function () {
    return 'Hello World';
});
```

### File di route predefiniti

Tutte le route Laravel sono definite nei file di route della directory `routes/`.
Questi file vengono caricati automaticamente da Laravel in base alla configurazione di `bootstrap/app.php`.

```mermaid theme={null}
flowchart LR
    A["Richiesta in arrivo"] --> B{{"Tipo di richiesta"}}
    B -->|"Per browser<br>sessione / CSRF"| C["routes/web.php<br>gruppo middleware web"]
    B -->|"Per API<br>stateless"| D["routes/api.php<br>gruppo middleware api"]
    B -->|"Comandi CLI"| E["routes/console.php<br>definizioni comandi Artisan"]
    C --> F["Controller / Closure"]
    D --> F
    E --> G["Command handler"]
```

In `routes/web.php` definisci le route destinate al browser.
Alle route di questo file si applica il gruppo di middleware `web`, che fornisce sessione, protezione CSRF e cifratura dei cookie.

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

Route::get('/user', [UserController::class, 'index']);
```

### Route API

Se la tua applicazione espone un'API stateless, puoi abilitare il routing API con il comando Artisan `install:api`.

```shell theme={null}
php artisan install:api
```

Il comando `install:api` installa [Laravel Sanctum](/it/sanctum) e crea il file `routes/api.php`.
Sanctum fornisce una guard di autenticazione tramite API token semplice e robusta, adatta a consumatori API di terze parti, SPA e applicazioni mobili.

```php theme={null}
Route::get('/user', function (Request $request) {
    return $request->user();
})->middleware('auth:sanctum');
```

Le route di `routes/api.php` sono stateless e vi si applica il [gruppo di middleware](/it/middleware) `api`.
Inoltre, a tutte le route viene applicato automaticamente il prefisso URI `/api`, quindi non serve aggiungerlo manualmente.
Per cambiare il prefisso, modifica il file `bootstrap/app.php` dell'applicazione.

```php theme={null}
->withRouting(
    api: __DIR__.'/../routes/api.php',
    apiPrefix: 'api/admin',
    // ...
)
```

### Metodi HTTP disponibili

Il router permette di registrare route per tutti i metodi HTTP.

```php theme={null}
Route::get($uri, $callback);
Route::post($uri, $callback);
Route::put($uri, $callback);
Route::patch($uri, $callback);
Route::delete($uri, $callback);
Route::options($uri, $callback);
```

Per route che rispondono a più metodi HTTP usa `match` o `any`.

```php theme={null}
Route::match(['get', 'post'], '/', function () {
    // ...
});

Route::any('/', function () {
    // ...
});
```

<Info>
  Nei form HTML che accettano `POST`, `PUT`, `PATCH` o `DELETE` nei file di route `web`, includi sempre la direttiva `@csrf`.
  In caso contrario la richiesta viene rifiutata.
</Info>

## Route che restituiscono una vista

Se una route restituisce solo una vista, puoi usare `Route::view` per scrivere in modo conciso.

```php theme={null}
Route::view('/welcome', 'welcome');

// Passa dati alla vista
Route::view('/welcome', 'welcome', ['name' => 'Taylor']);
```

## Parametri di route

### Parametri obbligatori

Per ottenere dinamicamente parti dell'URL usa i parametri di route.
Racchiudi i parametri tra `{}` e ricevili come argomenti della callback della route.

```php theme={null}
Route::get('/user/{id}', function (string $id) {
    return 'ID utente: ' . $id;
});
```

Puoi definire anche più parametri.

```php theme={null}
Route::get('/posts/{post}/comments/{comment}', function (string $postId, string $commentId) {
    return "Commento {$commentId} del post {$postId}";
});
```

<Warning>
  I parametri di route non possono contenere il carattere `/`.
</Warning>

### Parametri opzionali

Per rendere opzionale un parametro, aggiungi `?` in fondo al suo nome e imposta un valore predefinito per l'argomento corrispondente.

```php theme={null}
Route::get('/user/{name?}', function (?string $name = null) {
    return $name ?? 'Ospite';
});

Route::get('/user/{name?}', function (?string $name = 'Ospite') {
    return $name;
});
```

### Vincoli sui parametri tramite espressioni regolari

Con il metodo `where` puoi vincolare il formato dei parametri con espressioni regolari.

```php theme={null}
Route::get('/user/{id}', function (string $id) {
    // ...
})->where('id', '[0-9]+');

Route::get('/user/{name}', function (string $name) {
    // ...
})->where('name', '[a-zA-Z]+');
```

I pattern più comuni possono essere scritti anche con metodi comodi.

```php theme={null}
Route::get('/user/{id}/{name}', function (string $id, string $name) {
    // ...
})->whereNumber('id')->whereAlpha('name');
```

## Route con nome

Con le route con nome puoi fare riferimento a una route tramite il suo nome quando generi URL o effettui redirect.

```php theme={null}
Route::get('/user/profile', function () {
    // ...
})->name('profile');
```

### Generazione dell'URL a partire dal nome della route

Per generare un URL dal nome di una route usa l'helper `route`.

```php theme={null}
// Genera l'URL
$url = route('profile');

// Genera l'URL con parametri
$url = route('user.show', ['id' => 1]);
```

### Redirect

```php theme={null}
return redirect()->route('profile');
```

## Gruppi di route

Raggruppa le route correlate per condividere impostazioni comuni come middleware, controller e prefissi.

```mermaid theme={null}
flowchart TD
    A["Richiesta HTTP"] --> B["Router"]
    B --> C{{"Esiste una route<br>corrispondente?"}}
    C -->|"No"| D["Risposta 404"]
    C -->|"Sì"| E["Verifica i middleware della route"]
    E --> F{{"Passa i<br>middleware?"}}
    F -->|"Rifiutata"| G["Redirect /<br>Risposta di errore"]
    F -->|"Passata"| H["Esecuzione del controller /<br>della closure"]
    H --> I["Generazione della risposta"]
    I --> J["Invio al client"]
```

### Middleware

```php theme={null}
Route::middleware(['auth'])->group(function () {
    Route::get('/dashboard', function () {
        // Accessibile solo agli utenti autenticati
    });

    Route::get('/account', function () {
        // Accessibile solo agli utenti autenticati
    });
});
```

### Controller

Puoi raggruppare le route che usano lo stesso controller.

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

Route::controller(OrderController::class)->group(function () {
    Route::get('/orders', 'index');
    Route::post('/orders', 'store');
    Route::get('/orders/{id}', 'show');
});
```

### Prefisso

Puoi anteporre un prefisso comune all'URI delle route.

```php theme={null}
Route::prefix('admin')->group(function () {
    Route::get('/users', function () {
        // Accessibile su /admin/users
    });
    Route::get('/posts', function () {
        // Accessibile su /admin/posts
    });
});
```

## Elenco delle route

Per elencare tutte le route definite, usa il comando Artisan.

```shell theme={null}
php artisan route:list
```

Per includere anche le informazioni sui middleware:

```shell theme={null}
php artisan route:list -v
```

Per mostrare solo le route che iniziano con un URI specifico:

```shell theme={null}
php artisan route:list --path=user
```

## Prossimi passi

<Card title="Viste" icon="eye" href="/it/views">
  Impara a creare viste e a passare dati da un controller.
</Card>


## Related topics

- [Laravel Socialite (autenticazione social)](/it/socialite.md)
- [Ciclo di vita della richiesta](/it/lifecycle.md)
- [Aggiornamenti Laravel di marzo 2026](/it/blog/changelog/202603.md)
- [FAQ sulla nuova struttura dell'app da Laravel 11](/it/advanced/app-structure-faq.md)
- [Code e job](/it/queues.md)