OOP caricare classe automaticamente

[k.b]

Originariamente inviato da URANIO
Se ho capito quello che ti serve
include_once()

E' leggermente più lento di include però

Ma cosa c'entra con il caricare le classi automaticamente?

[URANIO]

Originariamente inviato da k.b
Ma cosa c'entra con il caricare le classi automaticamente?

Si, mi rendo conto che pensavo al mio modo di sviluppare in php, effettivamente non si capisce.

Io programmo in questo modo.
Ogni classe la metto in un singolo file .php o quasi.
Se ad esempio una classe estende o utilizza un'altra classe inserisco nel file un include_once del file della classe richiesta.
In questo modo nel momento in cui includo una classe per usarla ho tutti i riferimenti che mi servono senza ridondanze.

Non uso autoload perché non mi piace, una classe ha dei riferimenti e preferisco vederli chiaramente in testa al codice.

[k.b]

Originariamente inviato da URANIO
Si, mi rendo conto che pensavo al mio modo di sviluppare in php, effettivamente non si capisce.

Io programmo in questo modo.
Ogni classe la metto in un singolo file .php o quasi.
Se ad esempio una classe estende o utilizza un'altra classe inserisco nel file un include_once del file della classe richiesta.
In questo modo nel momento in cui includo una classe per usarla ho tutti i riferimenti che mi servono senza ridondanze.

Non uso autoload perché non mi piace, una classe ha dei riferimenti e preferisco vederli chiaramente in testa al codice.

Allora forse non e' il caso di intervenire in un thread in cui l'utente vuole proprio l'autoload ed ha esplicitamente detto "non vorrei mettere un include".

[URANIO]

Originariamente inviato da k.b
Allora forse non e' il caso di intervenire in un thread in cui l'utente vuole proprio l'autoload ed ha esplicitamente detto "non vorrei mettere un include".

Alla domanda fatta "Perchè non vuoi usare l'include", lui ha risposto
"perchè vorrei evitare di inserire codice ridondante in ogni nuovo file che creo."

Mi è sembrato di aiuto ricordare che esiste include_once, che immagino alla fine faccia quello di cui ha bisogno.

[eiyen]

Ma poi cosa intendiamo con "ridondante"... un semplice if che controlla se la classe c'è, altrimenti la carica, o cmq un require_once andrebbero bene? se no: perchè no?

[k.b]

Originariamente inviato da eiyen
Ma poi cosa intendiamo con "ridondante"... un semplice if che controlla se la classe c'è, altrimenti la carica, o cmq un require_once andrebbero bene? se no: perchè no?

Ridondante perche' devi scrivere un include per ogni classe, l'autoload lo configuri una volta e basta. Visto che PHP offre una funzione specifica proprio per questa cosa, usiamola.

[eiyen]

[divagazione...]
ah... perchè "ridondante" significa in realtà che c'è del codice "in più", mentre un controllo in ogni file non lo è di per sè (tanto è vero che con lo schema previsto se non lo si mette non funzionerebbe, quindi non sarebbe "ridondante", ma anzi necessario), se è funzionale allo scopo.

Se poi parliamo di "pulizia", anch'io suggerisco (come ho già fatto negli altri post) la possibilità del'autoload, ma per una cosa più precisa andrebbe rivista l'intera struttura. Sofismi, comunque.

[k.b]

Mi sono permesso di interpretare il termine "ridondante" in senso ampio perche pensavo qui parlassimo di PHP, non di semantica.

[eiyen]

Perfetto! Sei stato chiarissimo.

[daniele_dll]

Originariamente inviato da URANIO
Ripeto per sentito dire(letto), non uso più il PHP da tempo e non ho mai testato.
Usavo require_once per includere le classi.
Sul motivo della lentezza, non so, è una ricerca in memoria.
Il resto del discorso sul require non capisco perché lo tiri fuori.

require ed include fanno esattamente la stessa identica cosa, quello che cambia sono le modalità con cui danno errore in assenza di file, per questo l'ho tirato fuori ... sono letteralmente la stessa cosa

una ricerca in memoria, su 10 elementi, 15 elementi, è così veloce che non è fisicamente conteggiabile ... ammesso che usi una lista, perché se usa un hashtable ... la velocità di ricerca è O(1), che per dirla in modo molto banale per acquisire/verificare un dato è necessaria un solo accesso alla struttura dati (ovviamente nel caso in cui si verifica una collisione, dipende tutto dall'algoritmo implementato)

------

tornando all'autoloader, generalmente il mio autoloader fa qualcosa tipo

    public static function Initialize()
    {
        // Inizializza la lista delle path di ricerca e che la lista non è ancora stata riordinata
        self::$includePaths = array();
        self::$includePathsOrder = false;
        
        // Imposta le estensioni abilitate per l'autoload
        spl_autoload_extensions('.class.php');
        
        // Registra l'auto load per le classi
        spl_autoload_register('NemesiFW_Loader::_Autoload');
    }
    
    private static function _Autoload($ClassName)
    {
        // Verifica se la lista delle path di ricerca è stata riordinata o meno
        if (self::$includePathsOrder == true)
        {
            self::ReorderIncludePath();
        }
        
        // Costruisce il nome del file della classe
        $classFileName = str_replace('_', DIRECTORY_SEPARATOR, $ClassName) . '.class.php';
        $classFileNameParts = explode(DIRECTORY_SEPARATOR, $classFileName);
        $classFileNamePartsLength = count($classFileNameParts);
        $classPath = '';
        
        // Cerca il file nelle path di ricerca
        $classIncluded = false;
        foreach(self::$includePaths as $IncludePath)
        {
            // Verifica se il nome del file inizia con una parte del nome della directory
            // di ricerca
            $IncludePathParts = explode(DIRECTORY_SEPARATOR, $IncludePath['Path']);
            array_pop($IncludePathParts);
            $IncludePathPartsLength = count($IncludePathParts);
            $maxLoops = min($IncludePathPartsLength, $classFileNamePartsLength);
            
            $lengthToCut = 0;
            for($loop = 0; $loop < $maxLoops; $loop++)
            {
                if ($IncludePathParts[$IncludePathPartsLength - (1 + $loop)] != $classFileNameParts[$loop])
                {
                    break;
                }
                
                $lengthToCut += strlen($classFileNameParts[$loop]) + 1;
            }
            
            // Costruisce il nome del file
            $classPath = $IncludePath['Path'] . substr($classFileName, $lengthToCut);
            
            // Verifica se il componente esiste ed in caso lo include interrompendo il ciclo
            if (file_exists($classPath) === true)
            {
                require_once($classPath);
                $classIncluded = true;
                break;
            }
        }
        
        // Verifica se il componente è stato caricato
        if ($classIncluded == false)
        {
            // Lancia un errore
            self::Exception('Framework.Loader.ComponentMissingException',
                sprintf('Component %s missing', $ClassName), array('ClassName' => $ClassName));
        }
        else
        {
            if (class_exists($ClassName) == false)
            {
                self::Exception('Framework.Loader.ComponentDoesntIncludeClassException',
                    sprintf("Component %s doesn't include class %s", $classPath, $ClassName),
                    array('ClassName' => $ClassName));
            }
        }
        
        return false;
    }

PS: è ancora in riscrittura/rielaborazione, attualmente non supporta i namespace ... non per motivi particolari ma perché, per adesso, nel codice utilizzo gli underscore (_) nei nomi delle classi

di conseguenza quando scrivo ad esempio

Framework_Core_Registry::Get('chiave')

Lui in automatico mi include Framework_Core_Registry e visto che questa classe estende Framework_Core_Object in automatico viene inclusa (in realtà questa è l'unica classe che carico manualmente, insieme al gestore delle eccezioni, in quanto mi fa da tramite per gestire le eccezioni)