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

# Laravel Folio

> Come implementare il routing file-based con Laravel Folio, dall'installazione al route model binding.

## Introduzione

Laravel Folio è un router basato sulle pagine che ti consente di definire le route semplicemente collocando file Blade.
A differenza della definizione tradizionale centrata su `routes/web.php`, riflette direttamente nell'URL la struttura del filesystem.

È particolarmente utile per siti orientati ai contenuti o per pannelli di amministrazione in cui vuoi aggiungere rapidamente pagine schermata per schermata.
Per aree che richiedono un controllo HTTP granulare, come le API, in pratica lo si affianca al routing tradizionale.

## Installazione

Per prima cosa aggiungi Folio con Composer.

```bash theme={null}
composer require laravel/folio
php artisan folio:install
```

`folio:install` registra il service provider di Folio.
Per impostazione predefinita la directory delle pagine è `resources/views/pages/`.
Se usi più directory di pagine o vuoi differenziare gli URI di base, configura `Folio::path()` e `uri()` nel metodo `boot` del service provider.

```php theme={null}
use Laravel\Folio\Folio;

Folio::path(resource_path('views/pages/guest'))->uri('/');

Folio::path(resource_path('views/pages/admin'))
    ->uri('/admin');
```

## Creazione delle route

Folio genera automaticamente l'URL dal nome del file Blade posto sotto la directory montata.

```text theme={null}
resources/views/pages/schedule.blade.php -> /schedule
```

```bash theme={null}
php artisan folio:list
```

### Route annidate

Annidando le directory, anche l'URL viene annidato con la stessa struttura.

```bash theme={null}
php artisan folio:page user/profile
# pages/user/profile.blade.php -> /user/profile
```

### Route index

`index.blade.php` viene mappato sulla root della sua directory.

```bash theme={null}
php artisan folio:page index
# pages/index.blade.php -> /

php artisan folio:page users/index
# pages/users/index.blade.php -> /users
```

## Parametri di route

Puoi ricevere segmenti di URL con `[]` nel nome del file.

```bash theme={null}
php artisan folio:page "users/[id]"
# pages/users/[id].blade.php -> /users/1
```

```blade theme={null}
<div>User {{ $id }}</div>
```

Per ricevere più segmenti usa `...`.

```bash theme={null}
php artisan folio:page "users/[...ids]"
# pages/users/[...ids].blade.php -> /users/1/2/3
```

```blade theme={null}
@foreach ($ids as $id)
    <li>User {{ $id }}</li>
@endforeach
```

## Route model binding

Se usi il nome del modello, come `[User].blade.php`, la risoluzione del modello avviene automaticamente.

```bash theme={null}
php artisan folio:page "users/[User]"
# pages/users/[User].blade.php -> /users/1
```

```blade theme={null}
<div>User {{ $user->id }}</div>
```

Per gestire anche i modelli soft-deleted, chiama `withTrashed()` all'interno della pagina.

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

use function Laravel\Folio\withTrashed;

withTrashed();
```

<Info>
  Scrivendo ad esempio `[Post:slug].blade.php`, puoi risolvere il modello anche con chiavi diverse da `id` (ad esempio `slug`).
</Info>

## Middleware

Per applicare un middleware solo a una pagina specifica, usa `middleware()` all'interno del template della pagina.

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

use function Laravel\Folio\middleware;

middleware(['auth', 'verified']);
```

Per applicarlo in blocco a più pagine, usa `Folio::path(...)->middleware()`.

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

use Laravel\Folio\Folio;

Folio::path(resource_path('views/pages'))->middleware([
    'admin/*' => ['auth', 'verified'],
]);
```

## Route con nome

Anche le pagine Folio possono avere un nome tramite `name()`.

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

use function Laravel\Folio\name;

name('users.index');
```

<Info>
  Definendo `name('users.show')` in una pagina individuale come `users/[User].blade.php`, puoi generare l'URL parametrizzato con `route('users.show', ['user' => $user])`.
</Info>

Con l'helper `route()` puoi generare l'URL a partire dal nome della route.

```php theme={null}
route('users.index');
route('users.show', ['user' => $user]);
```

## Corrispondenza tra file e URL

```mermaid theme={null}
graph LR
  A["pages/index.blade.php"] --> B["/"]
  C["pages/about.blade.php"] --> D["/about"]
  E["pages/users/[User].blade.php"] --> F["/users/1"]
```

## Confronto con il routing tradizionale

| Caratteristica          | Routing tradizionale               | Folio                                          |
| ----------------------- | ---------------------------------- | ---------------------------------------------- |
| Definizione delle route | `routes/web.php`                   | Automatica dal nome del file                   |
| Controller              | Necessario (o closure)             | Non necessario (direttamente in Blade)         |
| Casi d'uso adatti       | API, SPA, controllo HTTP complesso | Siti di contenuto, pannelli di amministrazione |

<Tip>
  Anche usando Folio, puoi ottimizzare le prestazioni in produzione abilitando la cache delle route con `php artisan route:cache`.
</Tip>


## Related topics

- [Struttura dell'applicazione da Laravel 11](/it/advanced/app-structure.md)
- [Laravel Boost](/it/boost.md)
- [Laravel Telescope](/it/telescope.md)
- [Laravel Bluesky](/it/packages/laravel-bluesky/index.md)
- [Laravel Octane](/it/octane.md)