RobotLoader: Caricamento automatico delle classi
************************************************

<div class=perex>

RobotLoader è uno strumento che consente il caricamento automatico delle classi per l'intera applicazione, comprese le librerie di terze parti.

- Eliminate tutte le dichiarazioni `require`
- Vengono caricati solo gli script necessari
- Non richiede convenzioni di denominazione rigide per le directory o i file
- Estremamente veloce
- Nessun aggiornamento manuale della cache, tutto viene eseguito automaticamente
- Libreria matura, stabile e ampiamente utilizzata

</div>

Possiamo quindi dimenticarci di questi blocchi di codice già noti:

```php
require_once 'Utils/Page.php';
require_once 'Utils/Style.php';
require_once 'Utils/Paginator.php';
//...
```


Installazione .[#toc-installation]
----------------------------------

È possibile scaricare RobotLoader come un [singolo file standalone `RobotLoader.php` |https://github.com/nette/robot-loader/raw/standalone/src/RobotLoader/RobotLoader.php], da includere con `require` nel proprio script, e godere immediatamente di un comodo caricamento automatico per l'intera applicazione.

```php
require '/path/to/RobotLoader.php';

$loader = new Nette\Loaders\RobotLoader;
//...
```

Se state costruendo un'applicazione usando [Composer |best-practices:composer], potete installarlo tramite:

```shell
composer require nette/robot-loader
```


Utilizzo .[#toc-usage]
----------------------

Analogamente a come il robot di Google effettua il crawling e l'indicizzazione delle pagine web, [RobotLoader |api:Nette\Loaders\RobotLoader] esamina tutti gli script PHP e annota le classi, le interfacce, i tratti e gli enum che ha trovato. Quindi memorizza i risultati nella cache per utilizzarli nelle richieste successive. È sufficiente specificare quali directory deve attraversare e dove memorizzare la cache:

```php
$loader = new Nette\Loaders\RobotLoader;

// Directory da indicizzare per RobotLoader (incluse le sottodirectory)
$loader->addDirectory(__DIR__ . '/app');
$loader->addDirectory(__DIR__ . '/libs');

// Impostare la cache sulla directory "temp".
$loader->setTempDirectory(__DIR__ . '/temp');
$loader->register(); // Attivare RobotLoader
```

E questo è tutto, da questo momento in poi non abbiamo più bisogno di usare `require`. Fantastico!

Se RobotLoader incontra un nome di classe duplicato durante l'indicizzazione, lancerà un'eccezione e ne darà notifica. RobotLoader aggiorna automaticamente la cache quando deve caricare una classe sconosciuta. Si consiglia di disattivare questa funzione sui server di produzione, vedere [Cache |#Caching].

Se si desidera che RobotLoader salti alcune directory, utilizzare `$loader->excludeDirectory('temp')` (può essere chiamato più volte o passare più directory).

Per impostazione predefinita, RobotLoader segnala gli errori nei file PHP lanciando un'eccezione `ParseError`. Questa può essere soppressa usando `$loader->reportParseErrors(false)`.


Applicazione Nette .[#toc-nette-application]
--------------------------------------------

All'interno dell'applicazione Nette, dove `$configurator` è utilizzato in `Bootstrap.php`, è possibile impostare RobotLoader in questo modo:

```php
$configurator = new Nette\Bootstrap\Configurator;
//...
$configurator->setTempDirectory(__DIR__ . '/../temp');
$configurator->createRobotLoader()
	->addDirectory(__DIR__)
	->addDirectory(__DIR__ . '/../libs')
	->register();
```


Analizzatore di file PHP .[#toc-php-files-analyzer]
---------------------------------------------------

RobotLoader può essere usato anche solo per trovare classi, interfacce, tratti ed enum nei file PHP **senza** usare la funzione di caricamento automatico:

```php
$loader = new Nette\Loaders\RobotLoader;
$loader->addDirectory(__DIR__ . '/app');

// Esegue la scansione delle directory per classi/interfacce/tratti/enum
$loader->rebuild();

// Restituisce un array di coppie classe => nome file
$res = $loader->getIndexedClasses();
```

Anche con questo tipo di utilizzo, è possibile utilizzare la cache. In questo modo si garantisce che i file invariati non vengano ricanalizzati:

```php
$loader = new Nette\Loaders\RobotLoader;
$loader->addDirectory(__DIR__ . '/app');

// Imposta la cache sulla directory 'temp'
$loader->setTempDirectory(__DIR__ . '/temp');

// Esegue la scansione delle directory utilizzando la cache
$loader->refresh();

// Restituisce un array di coppie classe => nome file
$res = $loader->getIndexedClasses();
```


Caching .[#toc-caching]
-----------------------

RobotLoader è molto veloce perché utilizza in modo intelligente la cache.

Durante lo sviluppo, quasi non ci si accorge che è in esecuzione in background. Aggiorna continuamente la sua cache, considerando che le classi e i file possono essere creati, cancellati, rinominati, ecc. E non esegue una nuova scansione dei file invariati.

Su un server di produzione, invece, si consiglia di disattivare gli aggiornamenti della cache utilizzando `$loader->setAutoRefresh(false)` (in un'applicazione Nette, questo avviene automaticamente), perché i file non cambiano. Allo stesso tempo, è necessario **pulire la cache** quando si carica una nuova versione sull'hosting.

La scansione iniziale dei file, quando la cache non esiste ancora, può naturalmente richiedere un certo tempo per le applicazioni più grandi. RobotLoader ha una prevenzione integrata contro la "fuga dalla cache":https://en.wikipedia.org/wiki/Cache_stampede.
Si tratta di una situazione in cui un gran numero di richieste simultanee su un server di produzione attiverebbe RobotLoader e, poiché la cache non esiste ancora, tutti inizierebbero a scansionare i file, sovraccaricando il server.
Fortunatamente, RobotLoader funziona in modo tale che solo il primo thread indicizza i file, crea la cache e gli altri attendono e poi utilizzano la cache.


PSR-4 .[#toc-psr-4]
-------------------

Al giorno d'oggi, è possibile utilizzare [Composer per l'autocaricamento |best-practices:composer#autoloading], pur rispettando il sistema PSR-4. In parole povere, si tratta di un sistema in cui gli spazi dei nomi e i nomi delle classi corrispondono alla struttura delle directory e ai nomi dei file, ad esempio `App\Core\RouterFactory` sarà nel file `/path/to/App/Core/RouterFactory.php`.

RobotLoader non è legato a nessuna struttura fissa, quindi è utile in situazioni in cui non si vuole avere la struttura delle cartelle esattamente come gli spazi dei nomi di PHP, o quando si sviluppa un'applicazione che storicamente non usa tali convenzioni. È anche possibile utilizzare entrambi i caricatori insieme.


{{leftbar: nette:@menu-topics}}