# Caricamento dinamico di file e classi

La classe Zend_Loader include metodi per aiutare il caricamento dinamico di file.

## Zend_Loader contro require_once()

I metodi di `Zend_Loader` sono la scelta migliore se il nome del file da caricare è variabile. Per esempio, se è basato su un parametro immesso da un utente o l'argomento di un metodo. Se si sta caricando un file o una classe dove il nome è costante, non c'è alcun beneficio nell'utilizzo di `Zend_Loader` rispetto all'uso delle funzioni PHP tradizionali come `require_once()`.

## Caricamento di file

Il metodo statico `Zend_Loader::loadFile()` carica un file PHP. Il file caricato può contenere qualsiasi codice PHP. Questo metodo è un wrapper per la funzione PHP `include()`. Genera un'eccezione `Zend_Exception` in caso di errore ad esempio se il file specificato non esiste.

### Esempio del metodo loadFile()

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

Il parametro `$filename` specifica il nome del file da caricare, che non deve contenere alcuna indicazione di un percorso. Un controllo di sicurezza è eseguito su `$filename`. `$filename` può contenere unicamente caratteri alfanumerici, trattini ("-"), underscore ("_") o punti ("."). Nessuna di queste restrizioni è applicata al parametro `$dirs`.

Il parametro `$dirs` specifica le cartelle nelle quali cercare il file. Se `NULL`, la ricerca è eseguita solo nei percorsi contenuti in `include_path`. Se una stringa o un array, la ricerca è eseguita nella cartella o nelle cartelle specificate, quindi in `include_path`.

Il parametro `$once` è un booleano. Se `TRUE`, `Zend_Loader::loadFile()` utilizza la funzione PHP `include_once()` per caricare il file, altrimenti è utilizzata la funzione PHP `include()`.

## Caricamento di classi

Il metodo statico `Zend_Loader::loadClass($class, $dirs)` carica un file PHP ed esegue un controllo sull'esistenza della classe.

### Esempio del metodo loadClass()

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

La stringa che specifica la classe è convertita in un percorso relativo sostituendo i separatori di cartella ai caratteri di underscore ("_") ed appendendo l'estensione '.php'. Nell'esempio precedente 'Container_Tree' diventa 'Container\\Tree.php'.

Se `$dirs` è una stringa o un array, `Zend_Loader::loadClass()` esegue la ricerca nelle cartelle nell'ordine indicato. Il primo file trovato viene caricato. Se il file non esiste in `$dirs` allora la ricerca è eseguita in `include_path`.

Se il file non è trovato o la classe non esiste dopo il caricamento, `Zend_Loader::loadClass()` genera un'eccezione `Zend_Exception`.

Il metodo `Zend_Loader::loadFile()` è utilizzato per il caricamento del file, dunque il nome della classe può contenere solo caratteri alfanumerici, trattini ("-"), underscore ("_") o punti (".").

## Verifica del permesso di lettura di un file

Il metodo statico `Zend_Loader::isReadable($pathname)` restituisce `TRUE` se il file al percorso specificato esiste ed è leggibile, altrimenti `FALSE`.

### Esempio del metodo isReadable()

    <?php
    if (Zend_Loader::isReadable($filename)) {
        // fai qualcosa con $filename
    }

Il parametro `$filename` specifica il nome del file da verificare. Può contenere l'indicazione di un percorso. Questo metodo è un wrapper per la funzione PHP `is_readable()`. La funzione PHP non esegue la ricerca nelle cartelle indicate da `include_path`, contrariamente a `Zend_Loader::isReadable()`.

## Utilizzo dell'autoloader

La classe `Zend_Loader` contiene un metodo che è possibile registrare nella libreria PHP SPL autoloader. `Zend_Loader::autoload()` è il metodo di callback. Per comodità, `Zend_Loader` fornisce la funzione `registerAutoload()` per registrare automaticamente il proprio metodo `autoload()`. Se l'estensione `spl_autoload` non è presente nell'ambiente PHP, il metodo `registerAutoload()` genera un'eccezione `Zend_Exception`.

### Esempio di registrazione del metodo di callback autoloader

    <?php
    Zend_Loader::registerAutoload();

Dopo aver registrato il metodo di callback autoload del Framework Zend, è possibile referenziare le classi del framework senza la necessità di caricarle esplicitamente. Il metodo `autoload()` utilizza `Zend_Loader::loadClass()` in automatico ogni volta che una classe è referenziata.

Se si estende la classe `Zend_Loader` è possibile passare un parametro opzionale al metodo `registerAutoload()` per specificare la classe dalla quale registrare il metodo `autoload()`.

### Esempio di registrazione del metodo di callback autoloader di una classe estesa

A causa della semantica del referenziamento delle classi statiche in PHP, è necessario implementare il codice per entrambi i metodi `loadClass()` ed `autoload()`, ed il metodo `autoload()` deve chiamare `self::loadClass()`. Se il proprio metodo `autoload()` delega al metodo genitore la chiamata a `self::loadClass()`, allora chiama il metodo con lo stesso nome nella classe genitore, non nella sottoclasse.

    <?php
    class Mio_Loader 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('Mio_Loader');

E' possibile rimuovere un autoload callback. Il metodo `registerAutoload()` ha un secondo parametro opzionale, che corrisponde a `TRUE` per impostazione predefinita. Se il parametro ha valore `FALSE` allora il callback è rimosso dalla pila degli autoload SPL al posto di essere registrato.