spl_autoload o require_once

[oronze]

Ciao ragazzi, mi stavo cimentando a capire questa cosa.
Ho l'esigenza di caricare delle classi SOLO quando queste vengono chiamate. Mettiamo il caso che io abbia 100 classi e che, in base alle pagine della mia applicazioni ne carichi 5-6 per volta. Per non dovermi stare a sbattere ogni volta e ricordarmi di includere le classi necessarie andandomele a cercare nei vari percorsi ho pensato bene di crearmi questo file in modo da includere solo questo

$currentPath = dirname(__FILE__);
$brokenPath = explode('/', __FILE__);
$fileName = end($brokenPath);
spl_autoload_extensions('.php');
function carica($path){
    global $fileName;
    $c = $path;
    if ($handle = opendir($path)) {
        while (false !== ($e = readdir($handle))) {
            if ($e != "." && $e != ".." && $e != $fileName) {
                if(is_dir($c.'/'.$e)){
                    carica($c.'/'.$e);
                }
                else{
                    spl_autoload($e);
                }
            }
        }
        closedir($handle);
    }
}
carica($currentPath); 

In questo modo i file vengono "inclusi" solo quando vado a fare new MiaClasse(), anche quando vado a fare MiaClasse2::metodo() o cmq vengono incluse tutte le 100 classi presenti nei vari percorsi?

Spero di essere stato chiaro, in caso rispiego volentieri

[oronze]

Dopo aver effettuato svariate prove e aver sistemato il codice correggo le mie prime "dichiarazioni" in caso possa servire a qualcuno

$brokenPath = explode('/', __FILE__);
$fileName = end($brokenPath);
spl_autoload_extensions('.php');
function carica($class, $path=null){
    $path = (is_null($path))? dirname(__FILE__) : $path;
    global $fileName;
    if ($handle = opendir($path)) {
        while (false !== ($e = readdir($handle))) {
            if ($e != "." && $e != ".." && $e != $fileName) {
                if(is_dir($path.'/'.$e)){
                    carica($class, $path.'/'.$e);
                }
                elseif($e==$class.'.php'){
                    require_once $path.'/'.$class.'.php';
                }
                else{
                }
            }
        }
        closedir($handle);
    }
}
spl_autoload_register('carica'); 

Funziona invocando sia metodi statici che dinamici e le varie classi vengono caricate solo se richiesto.
Il codice che ho realizzato include solo per la prima volta la classe richiesta a partire dal percorso dove questo codice è dichiarato scorrendo ad albero i sottopercorsi...l'unico "problema" è che domani implementerò una simulazione di namespace in quanto, avendo una struttura del tipo

fileConAutoload.php
CARTELLA1
.....CARTELLA1a
.....CARTELLA1b
..........ClasseA.php
CARTELLA2
.....CARTELLA1a
..........ClasseA.php
.....CARTELLA1b

il codice non sa se la classeA che noi vogliamo che includa sia la prima o la seconda.
In ogni caso è un buon punto di partenza se a qualcuno possa mai servire.

[Secta]

Sinceramente a me non piace

Io sto usando i namespaces e con questi ed una adeguata organizzazione sul filesystem riesco a trovare le classi che mi occorrono e caricarle. Ma prima usavo una semplice array che conteneva al suo interno come chiavi il nome della classe e come valore il percorso sul filesystem. Molto semplice e veloce.

[oronze]

Originariamente inviato da Secta
Sinceramente a me non piace

Io sto usando i namespaces e con questi ed una adeguata organizzazione sul filesystem riesco a trovare le classi che mi occorrono e caricarle. Ma prima usavo una semplice array che conteneva al suo interno come chiavi il nome della classe e come valore il percorso sul filesystem. Molto semplice e veloce.

non ho capito mi potresti fare un esempio?
E come mai non ti piace il "caricamento al bisogno"?

[Secta]

A me piace il "caricamento al bisogno" (che in realtà si chiama "lazy loading", ossia pigro )... solo che non mi piace la tua soluzione. Come ti dicevo nel precedente post, puoi adottare una soluzione più semplice, efficace e veloce. Qualcosa del genere.

class autoload
{
    protected $classes    = array();
    protected $registered = false;
    
    public function __construct(array $classes)
    {
        $this->classes = $classes;
    }
    
    public function register()
    {
        if ($this->registered === false)
        {
            spl_autoload_register(array($this, 'autoload'));
        }
    }
    
    public function unregister()
    {
        if ($this->registered === true)
        {
            spl_autoload_unregister(array($this, 'autoload'));
        }
    }
    
    public function autoload($name)
    {
        if ($path = $this->getPath($name))
        {
            require_once $path;
        }
        
        // qui gestisci il caso in cui non trova la classe
    }
    
    public function getPath($name)
    {
        if (isset($this->classes[$name]))
        {
            return $this->classes[$name];
        }
        
        return false;
    }
    
    // la puoi ampliare aggiungendo dei metodi addClass, removeClass, hasClass... etc etc.
}


    $autoload = new autoload(array(
        'classe_a' => 'path/classe_a.php',
        'classe_b' => 'path/classe_b.php',
        'interf_x' => 'path/interf_x.php'
    ));

    $autoload->register();
    $autoload->unregister();
    $autoload->getPath('classe_a'); // nel caso ti servisse sapere dove sta una classe
    $autoload->autoload('classe_xyz'); // nel caso la volessi caricare da te 

Mi pare migliore, no? Certo, ogni volta che scrivi una classe devi aggiungerla all'array... ma non mi sembra una gran fatica

[oronze]

Originariamente inviato da Secta
A me piace il "caricamento al bisogno" (che in realtà si chiama "lazy loading", ossia pigro )... solo che non mi piace la tua soluzione. Come ti dicevo nel precedente post, puoi adottare una soluzione più semplice, efficace e veloce. Qualcosa del genere.

[...] 

Mi pare migliore, no? Certo, ogni volta che scrivi una classe devi aggiungerla all'array... ma non mi sembra una gran fatica

non è tutta sta gran fatica ma se cambi percorso della classe devi ricordarti di cambiare l'array, se sei in gruppo e ogni tizio sviluppa una classe differente, tutti devono ricordarsi di modificare il file, se porti in un server di produzione solo alcuni moduli dell'applicativo devi ricordarti di cambiare l'array, se tutti modificano il file si rischia di avere versioni differenti dello stesso e magari utilizzare uno non aggiornato o troppo aggiornato (insomma, discordante tra fase sviluppo e fase produzione)
La tua, come soluzione la trovo più elegante e leggibile ma meno pratica secondo me.

[Secta]

Se lavori in gruppo probabilmente utilizzi svn o similari (e se non lo fate dovreste)... quando fai il check out hai tutto aggiornato... se modifichi il percorso di una classe non costa nulla modificare l'array... e sopratutto in fase di sviluppo (dove le prestazioni contano fino a un certo punto) l'array la puoi tranquillamente recuperare dal filesystem UNA SOLA VOLTA e inviare al costruttore come argomento (come facevo io... una volta che tutto era finito le mettevo dentro la classe stessa). Quindi non vedo tutte queste problematiche che vedi tu

[oronze]

Originariamente inviato da Secta
Se lavori in gruppo probabilmente utilizzi svn o similari (e se non lo fate dovreste)... quando fai il check out hai tutto aggiornato... se modifichi il percorso di una classe non costa nulla modificare l'array... e sopratutto in fase di sviluppo (dove le prestazioni contano fino a un certo punto) l'array la puoi tranquillamente recuperare dal filesystem UNA SOLA VOLTA e inviare al costruttore come argomento (come facevo io... una volta che tutto era finito le mettevo dentro la classe stessa). Quindi non vedo tutte queste problematiche che vedi tu

io attualmente non sto facendo nulla...erano tutti se ipotetici ^_^ cercavo di capire i pro e i contro di un metodo e dell'altro. Poichè io ho programmato in java per un po', includermi i file di cui ho bisogno di volta in volta non mi pesa affatto...stavo solo approfondendo le mie conoscenze di PHP creando cose un po' più "evolute". E qui nasce un'altra domanda (non prenderla come polemica, voglio solo capire cosa potrebbe essere più conveniente) o meglio, un argomento di riflessione...ipotizziamo che io dai miei approfondimenti riesca a sviluppare un qualcosa di stabile e sicuro e che voglia renderla disponibile a chiunque
FrameworkMIO
...HTTP (classi con sottocartelle per gestire connessioni ftp)
...PDF (classi con sottocartelle per crearmi pdf)
...HTML (classi con sottocartelle per crearmi la UI)
etc...etc...
e che domani il signor PIPPO voglia utilizzarlo, per aggiungerci la sua funzionalità AUDIO è costretto a registrare ogni classe che si va a creare nell'autoload.php del framework oppure ad aggiungerla attraverso un qualche metodo della classe autolad. Un po' come fa il CMS drupal che per estenderlo ti "costringe" a creare dei file info, module, tpl, etc. etc....
la mia domanda attuale è: non conviene lasciare agli utenti la libertà di fare tutte le cavolate che vogliono senza starsi a preoccupare di rispettare delle regole più o meno rigide?
Ripeto, il tuo sistema lo trovo più pulito e soprattutto usa il paradigma ad oggetti ma lo vedo meno flessibile del mio.
In ogni caso ti ringrazio per il tempo che mi hai dedicato

[Secta]

Originariamente inviato da oronze
io attualmente non sto facendo nulla...erano tutti se ipotetici ^_^ cercavo di capire i pro e i contro di un metodo e dell'altro. Poichè io ho programmato in java per un po', includermi i file di cui ho bisogno di volta in volta non mi pesa affatto...stavo solo approfondendo le mie conoscenze di PHP creando cose un po' più "evolute". E qui nasce un'altra domanda (non prenderla come polemica, voglio solo capire cosa potrebbe essere più conveniente) o meglio, un argomento di riflessione...ipotizziamo che io dai miei approfondimenti riesca a sviluppare un qualcosa di stabile e sicuro e che voglia renderla disponibile a chiunque
FrameworkMIO
...HTTP (classi con sottocartelle per gestire connessioni ftp)
...PDF (classi con sottocartelle per crearmi pdf)
...HTML (classi con sottocartelle per crearmi la UI)
etc...etc...
e che domani il signor PIPPO voglia utilizzarlo, per aggiungerci la sua funzionalità AUDIO è costretto a registrare ogni classe che si va a creare nell'autoload.php del framework oppure ad aggiungerla attraverso un qualche metodo della classe autolad. Un po' come fa il CMS drupal che per estenderlo ti "costringe" a creare dei file info, module, tpl, etc. etc....
la mia domanda attuale è: non conviene lasciare agli utenti la libertà di fare tutte le cavolate che vogliono senza starsi a preoccupare di rispettare delle regole più o meno rigide?
Ripeto, il tuo sistema lo trovo più pulito e soprattutto usa il paradigma ad oggetti ma lo vedo meno flessibile del mio.
In ogni caso ti ringrazio per il tempo che mi hai dedicato

Traquillo nessuna polemica

Ma se l'utente vuole essere libero di fare tutte le cavolate che vuole probabilmente un framework o un cms non è la soluzione più adatta a lui... è evidente che se utilizzi codice scritto da altri devi rispettare determinate convenzioni e scelte di chi il codice l'ha appunto scritto ed ideato. Ma visto che fai un esempio pratico... ti rispondo che da un pò di tempo in php sono stati introdotti i namespaces... e come ti scrissi nel primo post, con questi è ancora più semplice organizzare sia il codice sul filesystem sia poterlo "richiamare al bisogno" (), quindi ti direi che la mia soluzione è ancora valida... ma una più valida è l'utilizzo dei namespaces

namespace Framework\Web\Ftp;

class xyftp
{} 

a te basta organizzare una struttara identica al namespaces sul filesystem e una volta che registri l'autoload provvedi a rintracciare il codice su di esso e a caricare la classe. Se aggiungi un pacchetto Http\Request... il namespaces diventerà Framework\Web\Http\Request... e userà la procedura di prima e sarà in grado di recuperare in automatico la classe da caricare. Con questa soluzione eviti di dover popolare l'array con le nuovi classi... ma come vedi devi sempre rispettare la convenzione di chi ha scritto il framework, ossia replicare su filesystem il namespaces. Quindi ti ripeto, se si usano codici di altri un minimo di convenzioni bisogna sempre rispettarli, ma se ci pensi non potrebbe essere altrimenti... o sbaglio?

Edit: mi sono accorto che nel codice racchiuso tra i tag php del forum, nella dichiarazione del ns non mi ha messo le backslashes, ma penso si capisca uguale