RobotLoader: Încărcarea automată a clasei
*****************************************

<div class=perex>

RobotLoader este un instrument care vă oferă confortul încărcării automate a claselor pentru întreaga dumneavoastră aplicație, inclusiv pentru bibliotecile de la terți.

- Eliminați toate declarațiile `require`
- Doar scripturile necesare vor fi încărcate
- Nu necesită convenții de denumire stricte pentru directoare sau fișiere
- Extrem de rapid
- Fără actualizări manuale ale cache-ului, totul se execută automat
- Bibliotecă matură, stabilă și utilizată pe scară largă

</div>

Astfel, putem uita de aceste blocuri de cod familiare:

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


Instalare .[#toc-installation]
------------------------------

Puteți descărca RobotLoader ca un [singur fișier independent `RobotLoader.php` |https://github.com/nette/robot-loader/raw/standalone/src/RobotLoader/RobotLoader.php], pe care îl includeți folosind `require` în scriptul dumneavoastră și vă bucurați instantaneu de o încărcare automată confortabilă pentru întreaga aplicație.

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

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

Dacă construiți o aplicație utilizând [Composer |best-practices:composer], îl puteți instala prin intermediul:

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


Utilizare .[#toc-usage]
-----------------------

Similar cu modul în care robotul Google răscolește și indexează paginile web, [RobotLoader |api:Nette\Loaders\RobotLoader] parcurge toate scripturile PHP și notează ce clase, interfețe, trăsături și enumerații a găsit. Apoi stochează rezultatele în memoria cache pentru a le utiliza în cererile ulterioare. Trebuie doar să specificați prin ce directoare trebuie să treacă și unde să stocheze memoria cache:

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

// Directoare pe care RobotLoader trebuie să le indexeze (inclusiv subdirectoare)
$loader->addDirectory(__DIR__ . '/app');
$loader->addDirectory(__DIR__ . '/libs');

// Setați memoria cache în directorul "temp".
$loader->setTempDirectory(__DIR__ . '/temp');
$loader->register(); // Activați RobotLoader
```

Și gata, din acest moment nu mai este nevoie să folosim `require`. Minunat!

Dacă RobotLoader întâlnește un nume de clasă duplicat în timpul indexării, va arunca o excepție și vă va notifica. De asemenea, RobotLoader actualizează automat memoria cache atunci când trebuie să încarce o clasă necunoscută. Vă recomandăm să dezactivați acest lucru pe serverele de producție, consultați [Caching |#Caching].

Dacă doriți ca RobotLoader să sară peste anumite directoare, utilizați `$loader->excludeDirectory('temp')` (poate fi apelat de mai multe ori sau poate trece mai multe directoare).

În mod implicit, RobotLoader raportează erorile din fișierele PHP prin aruncarea unei excepții `ParseError`. Acest lucru poate fi suprimat folosind `$loader->reportParseErrors(false)`.


Aplicația Nette .[#toc-nette-application]
-----------------------------------------

În cadrul aplicației Nette, unde `$configurator` este utilizat în `Bootstrap.php`, puteți configura RobotLoader în acest mod:

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


Analizator de fișiere PHP .[#toc-php-files-analyzer]
----------------------------------------------------

RobotLoader poate fi, de asemenea, utilizat pur și simplu pentru a găsi clase, interfețe, trăsături și enumerații în fișierele PHP **fără** a utiliza funcția de încărcare automată:

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

// Scanează directoarele pentru clase/interfețe/trăsături/enume
$loader->rebuild();

// Returnează o matrice de perechi clasă => nume de fișier
$res = $loader->getIndexedClasses();
```

Chiar și în cazul unei astfel de utilizări, puteți utiliza memoria cache. Acest lucru asigură că fișierele neschimbate nu vor fi scanate din nou:

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

// Setați memoria cache în directorul "temp
$loader->setTempDirectory(__DIR__ . '/temp');

// Scanează directoarele folosind memoria cache
$loader->refresh();

// Returnează o matrice de perechi clasă => nume de fișier
$res = $loader->getIndexedClasses();
```


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

RobotLoader este foarte rapid pentru că folosește în mod inteligent memoria cache.

În timpul dezvoltării, abia dacă veți observa că rulează în fundal. Își actualizează continuu memoria cache, având în vedere că clasele și fișierele pot fi create, șterse, redenumite etc. Și nu scanează din nou fișierele neschimbate.

Pe de altă parte, pe un server de producție, vă recomandăm să dezactivați actualizările cache-ului utilizând `$loader->setAutoRefresh(false)` (într-o aplicație Nette, acest lucru se întâmplă automat), deoarece fișierele nu se modifică. În același timp, este necesar să **curățați memoria cache** atunci când încărcați o nouă versiune la găzduire.

Scanarea inițială a fișierelor, atunci când memoria cache nu există încă, poate dura în mod natural un moment pentru aplicațiile mari. RobotLoader are încorporată o prevenire împotriva "cache stampede":https://en.wikipedia.org/wiki/Cache_stampede.
Aceasta este o situație în care un număr mare de solicitări simultane pe un server de producție ar declanșa RobotLoader și, deoarece memoria cache nu există încă, toate ar începe să scaneze fișiere, ceea ce ar supraîncărca serverul.
Din fericire, RobotLoader funcționează în așa fel încât doar primul fir indexează fișierele, creează memoria cache, iar restul așteaptă și apoi utilizează memoria cache.


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

În prezent, puteți utiliza [Composer pentru încărcare automată |best-practices:composer#autoloading], respectând în același timp PSR-4. Pe scurt, este un sistem în care spațiile de nume și numele claselor corespund structurii directoarelor și numelor de fișiere, de exemplu, `App\Core\RouterFactory` va fi în fișierul `/path/to/App/Core/RouterFactory.php`.

RobotLoader nu este legat de nicio structură fixă, deci este util în situațiile în care nu doriți ca structura directoarelor să fie concepută exact ca spațiile de nume PHP sau atunci când dezvoltați o aplicație care, din punct de vedere istoric, nu folosește astfel de convenții. De asemenea, este posibil să folosiți ambele încărcătoare împreună.


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