# Charger les fichiers et les classes dynamiquement

La classe `Zend_Loader` inclut des méthodes afin de vous aider à charger des fichiers dynamiquement.

## Zend_Loader contre require_once()

Les méthodes `Zend_Loader` sont les meilleures à utiliser si le nom de fichier que vous devez charger est variable. Par exemple, s'il est basé sur un paramètre de la saisie de l'utilisateur ou un argument de méthode. Si vous chargez un fichier ou une classe dont le nom est constant, il n'y a aucun avantage à l'utilisation de `Zend_Loader` sur l'utilisation de fonctions de PHP traditionnelles comme `require_once()`.

## Charger des fichiers

La méthode statique `Zend_Loader::loadFile()` charge un fichier PHP, qui peut contenir du code PHP arbitraire. Cette méthode enveloppe la fonction PHP `include()`, et retournera le booléen `FALSE` si le fichier n'existe pas.

### Exemple d'utilisation de la méthode loadFile()

    Zend_Loader::loadFile($filename, $dirs=null, $once=false);

L'argument `$filename` définit le nom du fichier à charger, et il ne doit contenir aucune information concernant son chemin d'accès. Une vérification de sécurité est effectuée sur `$filename`. Le fichier `$filename` ne peut contenir que des caractères alphanumérique, des tirets ("-"), des tirets-bas ("_") ou des points ("."). Aucune de ces restrictions ne s'applique à l'argument `$dirs`.

L'argument `$dirs` définit les dossiers où rechercher le fichier. Si `NULL`, la recherche s'effectuera uniquement dans les dossiers définis par la variable `include_path`. Si c'est une chaîne ou un tableau, le ou les répertoires spécifiés seront scannés, ainsi que les dossiers définis par la variable `include_path`.

L'argument `$once` est un booléen. Si `TRUE`, `Zend_Loader::loadFile()` utilise la fonction PHP `include_once()` pour charger le fichier sinon la fonction PHP `include()` est utilisée.

## Charger des classes

La méthode statique `Zend_Loader::loadClass($class, $dirs)` charge un fichier PHP et vérifie l'existence de la classe.

### Exemple d'utilisation de la méthode loadClass()

    Zend_Loader::loadClass('Container_Tree',
        array(
            '/home/production/mylib',
            '/home/production/myapp'
        )
    );

La chaîne spécifiant la classe est convertie en chemin relatif en remplaçant les tirets bas ("_") par le séparateur de dossier puis en ajoutant le bloc ".php". Dans l'exemple ci-dessus, "Container_Tree" devient "Container\\Tree.php".

Si `$dirs` est une chaîne ou un tableau, `Zend_Loader::loadClass()` va chercher dans les dossiers suivant l'ordre donné. Le premier fichier trouvé est chargé. Si le fichier n'existe pas dans les dossiers spécifiés `$dirs`, alors la recherche est effectuée dans `include_path` du PHP.

Si le fichier n'est pas trouvé ou que la classe n'existe pas après le chargement, `Zend_Loader::loadClass()` lèvera une exception `Zend_Exception`

`Zend_Loader::loadFile()` est utilisé pour le chargement, donc le nom de la classe ne peut contenir que des caractères alphanumériques et les caractères tiret ("-"), tiret bas ("_"), et point (".").

### Loading Classes from PHP Namespaces

Starting in version 1.10.0, Zend Framework now allows loading classes from PHP namespaces. This support follows the same guidelines and implementation as that found in the PHP Framework Interop Group PSR-0 reference implementation.

Under this guideline, the following rules apply:

- Each namespace separator is converted to a `DIRECTORY_SEPARATOR` when loading from the file system.

- Each "_" character in the CLASS NAME is converted to a `DIRECTORY_SEPARATOR`. The "_" character has no special meaning in the namespace.

- The fully-qualified namespace and class is suffixed with ".php" when loading from the file system.

As examples:

- `\Doctrine\Common\IsolatedClassLoader` => `/path/to/project/lib/vendor/Doctrine/Common/IsolatedClassLoader.php`

- `\namespace\package\Class_Name` => `/path/to/project/lib/vendor/namespace/package/Class/Name.php`

- `\namespace\package_name\Class_Name` => `/path/to/project/lib/vendor/namespace/package_name/Class/Name.php`

## Tester si un fichier est lisible

La méthode statique `Zend_Loader::isReadable($pathname)` retourne `TRUE` si le fichier existe dans le dossier spécifié et qu'il est lisible, sinon `FALSE`.

### Exemple d'utilisation de la méthode isReadable()

    if (Zend_Loader::isReadable($filename)) {
        // puis manipulation avec $filename
    }

L'argument `$filename` spécifie le nom du fichier à vérifier. Il peut contenir des informations concernant le chemin d'accès. Cette méthode enveloppe la fonction PHP `is_readable()`. La fonction PHP ne recherche pas le fichier spécifié dans les répertoires de l'`include_path`, contrairement à `Zend_Loader::isReadable()`.

## Utiliser l'autoloader

La classe Zend_Loader contient une méthode `Zend_Loader::autoload()` que vous pouvez inscrire dans le PHP SPL autoloader. Par commodité, `Zend_Loader` fournit la fonction `registerAutoload()` qui enregistre automatiquement sa méthode `autoload()`. Si l'extension `spl_autoload` n'est pas présente dans l'environnement PHP, alors la méthode `registerAutoload()` lèvera une `Zend_Exception`.

### Exemple d'inscription de la méthode de callback autoloader

    Zend_Loader::registerAutoload();

Après avoir inscrit le callback vers l'autoload de Zend Framework, vous pouvez appeler une classe de Zend Framework sans l'avoir explicitement chargé auparavant. La méthode autoload utilise automatiquement `Zend_Loader::loadClass()` quand vous appelez une classe.

Si vous avez étendu la classe `Zend_Loader`, vous pouvez passer un argument optionnel à `registerAutoload()`, pour spécifier la classe de laquelle vous souhaitez enregistrer la méthode `autoload()`.

### Exemple d'inscription de la méthode de callback autoloader d'une classe étendue

A cause de la sémantique de référencement des fonctions statiques en PHP, vous devez implémenter le code pour les méthodes `loadClass()` et `autoload()`, et la méthode `autoload()` doit appeler `self::loadClass()`. Si votre méthode `autoload()` délégue à son parent l'appel `self::loadClass()`, alors cela appellerait la méthode de même nom dans la classe parente et non dans la sous-classe.

    class Mon_Chargeur extends Zend_Loader
    {
        public static function loadClass($class, $dirs = null)
        {
            parent::loadClass($class, $dirs);
        }

        public static function autoload($class)
        {
            try {
                self::loadClass($class);
                return $class;
            } catch (Exception $e) {
                return false;
            }
        }}

    Zend_Loader::registerAutoload('Mon_Chargeur');

Vous pouvez effacer un callback d'autoload. `registerAutoload()` a un paramètre optionnel, qui est réglé à `TRUE` par défaut. S'il vaut `FALSE`, le callback de l'autoload est alors effacé de la pile des autoload SPL.