forked from nette/docs
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy path@home.texy
129 lines (83 loc) · 6.3 KB
/
@home.texy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
RobotLoader : Auto-chargement des classes
*****************************************
<div class=perex>
RobotLoader est un outil qui vous offre le confort du chargement automatique des classes pour l'ensemble de votre application, y compris les bibliothèques tierces.
- se débarrasser de tout `require`
- seuls les scripts nécessaires sont chargés
- ne nécessite pas de conventions strictes en matière de nom de répertoire ou de fichier
</div>
On peut donc oublier ces fameux blocs de code :
```php
require_once 'Utils/Page.php';
require_once 'Utils/Style.php';
require_once 'Utils/Paginator.php';
// ...
```
Installation .[#toc-installation]
---------------------------------
Téléchargez et installez le paquet en utilisant [Composer |best-practices:composer]:
```shell
composer require nette/robot-loader
```
Utilisation .[#toc-usage]
-------------------------
Tout comme le robot Google explore et indexe les sites Web, [RobotLoader |api:Nette\Loaders\RobotLoader] explore tous les scripts PHP et enregistre les classes et les interfaces qu'ils contiennent. Ces enregistrements sont ensuite sauvegardés dans le cache et utilisés lors de toutes les requêtes ultérieures. Il vous suffit de spécifier les répertoires à indexer et l'endroit où sauvegarder 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');
// utiliser le répertoire 'temp' pour le cache
$loader->setTempDirectory(__DIR__ . '/temp');
$loader->register(); // Exécution du RobotLoader
```
Et c'est tout. A partir de maintenant, vous n'avez plus besoin d'utiliser `require`. Super, n'est-ce pas ?
Lorsque RobotLoader rencontre un nom de classe en double pendant l'indexation, il lève une exception et vous en informe. RobotLoader met aussi automatiquement à jour le cache lorsqu'il doit charger une classe qu'il ne connaît pas. Nous recommandons de désactiver cette fonction sur les serveurs de production, voir [Mise en cache |#Caching].
Si vous voulez que RobotLoader saute certains répertoires, utilisez `$loader->excludeDirectory('temp')` (il peut être appelé plusieurs fois ou vous pouvez passer plusieurs répertoires).
Par défaut, RobotLoader signale les erreurs dans les fichiers PHP en lançant l'exception `ParseError`. Elle peut être désactivée via `$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 aussi être utilisé uniquement pour trouver des classes, des interfaces et des traits dans les fichiers PHP **sans utiliser la fonction de chargement automatique :
```php
$loader = new Nette\Loaders\RobotLoader;
$loader->addDirectory(__DIR__ . '/app');
// Recherche des classes, interfaces et traits 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 le cache. Ainsi, les fichiers non modifiés ne seront pas analysés à plusieurs reprises lors d'une nouvelle recherche :
```php
$loader = new Nette\Loaders\RobotLoader;
$loader->addDirectory(__DIR__ . '/app');
$loader->setTempDirectory(__DIR__ . '/temp');
// Analyse des répertoires en utilisant un 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 car il utilise intelligemment le cache.
Lorsque vous développez avec lui, vous n'avez pratiquement aucune idée qu'il fonctionne en arrière-plan. Il met continuellement à jour le cache car il sait que les classes et les fichiers peuvent être créés, supprimés, renommés, etc. Et il n'analyse pas de manière répétée les fichiers non modifiés.
En revanche, lorsqu'il est utilisé sur un serveur de production, nous recommandons de désactiver la mise à jour du cache à l'aide de `$loader->setAutoRefresh(false)` (cela se fait automatiquement dans l'application Nette), car les fichiers ne changent pas. En même temps, il est nécessaire de **nettoyer le cache** lors du téléchargement d'une nouvelle version sur l'hébergement.
Bien sûr, le balayage initial des fichiers, lorsque le cache n'existe pas encore, peut prendre quelques secondes pour les applications plus importantes. RobotLoader a 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 le serveur de production reçoit un grand nombre de demandes simultanées et, comme le cache de RobotLoader n'existe pas encore, elles commencent toutes à analyser les fichiers. Ce qui fait monter en flèche l'utilisation du CPU et du système de fichiers.
Heureusement, RobotLoader fonctionne de telle manière que pour plusieurs demandes simultanées, seul le premier thread indexe les fichiers, crée un cache, les autres attendent, puis utilisent le cache.
PSR-4 .[#toc-psr-4]
-------------------
Aujourd'hui, Composer peut être utilisé pour l'[autoloading |best-practices:composer#autoloading] en conformité avec PSR-4. En d'autres termes, il s'agit d'un système où les espaces de noms et les noms de classes correspondent à la structure des répertoires et aux noms de fichiers, c'est-à-dire que `App\Router\RouterFactory` est situé dans le fichier `/path/to/App/Router/RouterFactory.php`.
RobotLoader n'est lié à aucune structure fixe, il est donc utile dans les situations où il ne vous convient pas d'avoir une structure de répertoire conçue comme des espaces de noms en PHP, ou lorsque vous développez une application qui n'a historiquement pas utilisé de telles conventions. Il est également possible d'utiliser les deux chargeurs ensemble.
{{leftbar: nette:@menu-topics}}