RobotLoader : Autoloading de classe
***********************************

<div class=perex>

RobotLoader est un outil qui vous permet de charger automatiquement des classes pour l'ensemble de votre application, y compris les bibliothèques tierces.

- Éliminez toutes les déclarations `require`
- Seuls les scripts nécessaires seront chargés
- Ne nécessite pas de conventions de nommage strictes pour les répertoires ou les fichiers
- Extrêmement rapide
- Pas de mise à jour manuelle du cache, tout s'exécute automatiquement
- Bibliothèque mature, stable et largement utilisée

</div>

Nous pouvons donc oublier ces blocs de code familiers :

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


Installation .[#toc-installation]
---------------------------------

Vous pouvez télécharger RobotLoader sous la forme d'un [seul fichier autonome `RobotLoader.php` |https://github.com/nette/robot-loader/raw/standalone/src/RobotLoader/RobotLoader.php], que vous incluez à l'aide de `require` dans votre script, et profiter instantanément d'un chargement automatique confortable pour l'ensemble de l'application.

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

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

Si vous construisez une application à l'aide de [Composer |best-practices:composer], vous pouvez l'installer via :

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


Utilisation .[#toc-usage]
-------------------------

De la même manière que le robot Google parcourt et indexe les pages web, [RobotLoader |api:Nette\Loaders\RobotLoader] parcourt tous les scripts PHP et note les classes, interfaces, traits et enums qu'il a trouvés. Il stocke ensuite les résultats dans le cache pour les utiliser lors de requêtes ultérieures. Il vous suffit de spécifier les répertoires qu'il doit parcourir et l'endroit où il doit stocker le cache :

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

// Répertoires à indexer par RobotLoader (y compris les sous-répertoires)
$loader->addDirectory(__DIR__ . '/app');
$loader->addDirectory(__DIR__ . '/libs');

// Définir la mise en cache dans le répertoire "temp".
$loader->setTempDirectory(__DIR__ . '/temp');
$loader->register(); // Activer RobotLoader
```

Et c'est tout, à partir de maintenant, nous n'avons plus besoin d'utiliser `require`. Génial !

Si RobotLoader rencontre un nom de classe dupliqué pendant l'indexation, il lèvera une exception et vous en informera. RobotLoader met également à jour automatiquement le cache lorsqu'il doit charger une classe inconnue. Nous recommandons de désactiver cette fonction sur les serveurs de production, voir [Caching |#Caching].

Si vous souhaitez que RobotLoader ignore certains répertoires, utilisez `$loader->excludeDirectory('temp')` (peut être appelé plusieurs fois ou passer plusieurs répertoires).

Par défaut, RobotLoader signale les erreurs dans les fichiers PHP en lançant une exception `ParseError`. Cette exception peut être supprimée en utilisant `$loader->reportParseErrors(false)`.


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

Dans l'application Nette, où `$configurator` est utilisé dans `Bootstrap.php`, vous pouvez configurer RobotLoader de cette façon :

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


Analyseur de fichiers PHP .[#toc-php-files-analyzer]
----------------------------------------------------

RobotLoader peut également être utilisé uniquement pour trouver des classes, des interfaces, des traits et des enums dans les fichiers PHP **sans** utiliser la fonction d'autoloading :

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

// Recherche les classes/interfaces/traits/enums dans les répertoires
$loader->rebuild();

// Retourne un tableau de paires classe => nom de fichier
$res = $loader->getIndexedClasses();
```

Même avec une telle utilisation, vous pouvez utiliser la mise en cache. Cela permet de s'assurer que les fichiers inchangés ne seront pas analysés à nouveau :

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

// Définit la mise en cache dans le répertoire "temp".
$loader->setTempDirectory(__DIR__ . '/temp');

// Analyse les répertoires en utilisant le cache
$loader->refresh();

// Retourne un tableau de paires classe => nom de fichier
$res = $loader->getIndexedClasses();
```


Mise en cache .[#toc-caching]
-----------------------------

RobotLoader est très rapide parce qu'il utilise intelligemment la mise en cache.

Pendant le développement, vous remarquez à peine qu'il fonctionne en arrière-plan. Il met continuellement à jour son cache, en tenant compte du fait que les classes et les fichiers peuvent être créés, supprimés, renommés, etc. Et il ne rescanne pas les fichiers inchangés.

Sur un serveur de production, en revanche, nous recommandons de désactiver les mises à jour du cache à l'aide de `$loader->setAutoRefresh(false)` (dans une application Nette, cela se fait automatiquement), car les fichiers ne changent pas. En même temps, il est nécessaire de **vider le cache** lors de l'envoi d'une nouvelle version à l'hébergement.

L'analyse initiale des fichiers, lorsque le cache n'existe pas encore, peut naturellement prendre un certain temps pour les grandes applications. RobotLoader dispose d'une prévention intégrée contre la "ruée vers le cache":https://en.wikipedia.org/wiki/Cache_stampede.
Il s'agit d'une situation dans laquelle un grand nombre de demandes simultanées sur un serveur de production déclencherait RobotLoader, et comme le cache n'existe pas encore, elles commenceraient toutes à analyser les fichiers, ce qui surchargerait le serveur.
Heureusement, RobotLoader fonctionne de telle manière que seul le premier thread indexe les fichiers, crée le cache, et que les autres attendent et utilisent ensuite le cache.


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

Aujourd'hui, vous pouvez utiliser [Composer pour l'autoloading |best-practices:composer#autoloading] tout en adhérant à PSR-4. En termes simples, il s'agit d'un système dans lequel les espaces de noms et les noms de classes correspondent à la structure des répertoires et aux noms de fichiers, par exemple, `App\Core\RouterFactory` sera dans le fichier `/path/to/App/Core/RouterFactory.php`.

RobotLoader n'est pas lié à une structure fixe, il est donc utile dans les situations où vous ne voulez pas que la structure du répertoire soit conçue exactement comme les espaces de noms PHP, ou lorsque vous développez une application qui n'utilise pas historiquement de telles conventions. Il est également possible d'utiliser les deux chargeurs ensemble.


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