Autoload Class con Namespace

[Fractals87]

Ciao a tutti,

Sono ad un dilemma con l'autoload tramite namespace.
Non riesco proprio a capire come deve funzionare.
Allora io ho creato la seguente struttura di cartelle e file

\test.php
\library\config\Configuration.php
\library\db\db.php

in test.php l'ho editato in questo modo :

use library/config;
$conf = new Configuration(); 

configuration.php

namespace library/config;

class Configuration{ 
 //metodi e proprietà
} 

Che sbaglio??
Grazie a tutti per l'aiuto

Ps. ho messo il backslash "/" perchè lo slash normale "\" veniva ignorato ma nel file c'è

[boots]

Prima di tutto, non mi è mai capitato di usare i namespaces con php, quindi prendi con le molle quello che scrivo...

Credo che il namespaces non c'entri con il loading dei file ... quello lo devi fare ugualmente.
I namespaces servono ad evitare conflitti con nomi, in caso includi classi/funzioni con lo stesso nome.

Quindi nel tuo caso dovresti fare:

test.php

include "library/config/Configuration.php";
use library/config as conf;

$conf = new conf/Configuration();

//o con il namespace esteso senza usare "use"

//$conf = new library/config/Configuration(); 

[Fractals87]

ok questo denota che non ho capito un cavolo... bene....
Pero utilizzando i namespace con l'autoload come verrebbe allora?
test.php

function __autoload($className) {
    $file = $className . '.php';
    if(file_exists($file)) {
        require_once $file;
    }
}

use library\conf\Configuration;
$conf = new Configuration('application.setting.ini'); 

configuration.php

<?php 
/*
 * Class per leggere il file e caricare il file di configurazione 
 */
namespace library\config;
class Configuration{ 

}

Ho fatto diverse prove con as o senza as ma nn riesco a trovare il file, anche utilizzando esempi in rete

[boots]

Da quel che ho capito, se vuoi usare una classe fuori dal suo namespace devi usare "use"
o il namespace completo

use library/conf/Configuration as conf;
$conf = new conf/Configuration('application.setting.ini'); 

Il problema con autoload è che non gli viene passato solo il nome della classe, ma anche il namespace (conf\Configuration)
Quindi devi prevedere questo quando implementi __autoload(), ad esempio

function __autoload($className) { 
    $parts = explode('//', $className);  // ci vanno i backslashes, 
    @include_once PATH-DOVE-TROVARE-IL-FILE.DS.$parts[count($parts)-1].'.php';
} 

Però, come puoi vedere, questo complica le cose se hai due classi con lo stesso nome ma in namespace diversi

use library/conf/Configuration as conf;
use library/xml/Configuration as xml;

$xml = new xml/Configuration(); 

autoload, quale configuration.php deve caricare ?

Quindi sarebbe meglio usare il namespace completo e fare un autoload

function __autoload($className) { 
    // Ti ricordo che viene passato anche il namespace
    $class_path = str_replace('//', DS, $className);
    @include_once PATH-DOVE-TROVARE-IL-FILE.DS.$class_path.'.php';
    // quindi dovresti avere, ad esempio PATH/library/xml/Configuration.php
}

$xml = new library/xml/Configuration(); 

Quindi dovresti valutare bene come organizzare autoload

[Santino83_02]

Usa composer per gestire il tuo progetto e l'autoloading, infondo devi solo aggiungere un phar, un file json e seguire una convenzione nella struttura

[Santino83_02]

dicevo, il concetto è lo stesso: alla funzione dell'autoload arriva il class name completo richiesto, dove completo si intende comprensivo di autoload. Quindi se scrivi

use My/Cool/Library/Foo

o fai

new My/Cool/Library/Foo();

o quant'altro, l'autoload ti manda come className My/Cool/Library/Foo. Ora, come per qualsiasi altro autoload normale, te devi mappare className ad una risorsa fisica, e per fare questo si prende in genere a riferimento il namespace e il nome della classe. esempio:

diciamo che abbiamo una cartella src/ che contiene tutte le nostre classi e namespaces. Vogliamo caricare la classe

My/Cool/Library/Foo

allora l'autoload andrà a caricare, ad esempio, il file:

src/My/Cool/Library/Foo.php

e via discorrendo. Uno standard a riguardo è la notazione PSR-0, dove sostanzialmente si mette come root del namespace il VendorName e poi i vari namespace e la struttura del folder rispecchia di conseguenza questo formato.

qui un articolo che dovrebbe essere chiarificatore in merito http://phpmaster.com/autoloading-and...sr-0-standard/

Facciamo un passo ulteriore:

usa composer per gestire il tuo progetto (http://getcomposer.org) per due motivi:

1) ti fornisce già lui un sistema di autoiloading al quale agganciare le tue classi ( vedi http://getcomposer.org/doc/01-basic-usage.md paragrafo "autoloading")

2) avendo composer, facilmente puoi integrare nel tuo progetto librerie di terze parti, potendo scegliere tra un bel catalogo di librerie https://packagist.org/

3) se non è già una standard, di fatto il suo utilizzo lo è o lo diventerà a breve, tanto vale impararlo ad usare (una sciocchezza) ed usarlo (ancora di più una siocchezza) piuttosto che riscrivere l'ennesimo autoloader (anche se volendo puoi sostituire quello di composer ed usare le sue informazioni solo per capire la mappatura tra namespace e struttura folder. cmq c'è l'esempio nella documentazione)

[Fractals87]

sinceramente inizio a sentirmi un pò stupido...
Ti dico che da questa mattina (innumerevoli prove fatte) sono riuscito a capire "COSA FOSSE" composer... ora me lo guardo per bene cosi da capire come funzionano i namespace e il relativo autoloader...
Comunque la prima prova fatta e aggiungerei fallita miseramente è stata la seguente :
dalla documentazione :

http://phpmaster.com/autoloading-an...psr-0-standard/

Ho detto figo utilizziamo un autoloader di "marca" (Symfony) attenendosi allo standard PSR-0

Ho creato cosi la mia struttura :
/test/
/test/test-autoloader.php
/test/library/Paolo/
/test/library/Paolo/config/
/test/library/Paolo/config/Configuration.php
/test/library/Symfony/
/test/library/Symfony/Component
/test/library/Symfony/Component/ClassLoader
/test/library/Symfony/Component/ClassLoader/UniversalClassLoader.php

test-autoloader.php

require_once "library/Symfony/Component/ClassLoader/UniversalClassLoader.php";
use Symfony\Component\ClassLoader\UniversalClassLoader;
$loader = new UniversalClassLoader();
//$loader->registerNamespace("Symfony\Component", "library/symfony/components");
//$loader->registerNamespace("Monolog", "path/to/monolog/src/");
//$loader->registerPrefix("Zend_", "path/to/zend/library");
$loader->registerNamespaces(array(
    "Paolo\config" => "library/Paolo/config",
    "Paolo\db" => "library/Paolo/database"
));
$loader->register();

$conf=new Itron\config\Configuration("/test/library/Paolo/config/application.setting.ini"); 

Configuration.php

namespace Itron\config;

class Configuration{ 
} 

Il loader me lo carica correttamente (per forza è incluso) ma ovviamente il conf mi da errori

Ora pero sono riuscito a utilizzare composer installando i pacchetti docrtine/common e monolog e domani farò un po di prove cercando di capire come funzionano per bene i namespace e come gli utilizza.
Ora pero dormo perchè nn ci credo più

Come sempre, grazie mille

[Santino83_02]

Purtroppo non ho il tempo questi giorni di farti un esempio, tra computer mezzo rotto e lavoro non ho modo. Cmq sempre meglio se ci arrivi da solo Notte notte

[boots]

Scusate, ma mi stanno venendo molti dubbi:

require_once "library/Symfony/Component/ClassLoader/UniversalClassLoader.php"; 
use SymfonyComponentClassLoaderUniversalClassLoader; 
$loader = new UniversalClassLoader(); 

Perchè funziona?

Mi spiego. Ho fatto questa prova:

test/prova.php
test/config/connection.php

connection.php

namespace config;
class Connection{
    // Metodi
} 

prova.php

include "config/connection.php";
use config;
$conf = new Connection(); 

Non funziona...con php 5.3.8 di dice

Warning: The use statement with non-compound name 'config' has no effect in C:\xampp\htdocs\test\prova.php on line 3

Da quel che ho capito, "use" serve solo a creare degli alias per namespace lunghi..
Quindi, anche cambiando in

include "config/connection.php";
use config as c;
$conf = new Connection(); 

Php non trova la classe Connection()...devo per foreza fare new c/Connection();

Quind la mia domanda è...perchè a Fractals
$loader = new UniversalClassLoader();
Funziona?

[Santino83_02]

no no fermo che fai casini

stesso tuo esempio:

test/test.php
test/config/Connection.php

questa è la classe Connection:

<?php
/* /test/config/Connection.php */

namespace config;

class Connection{

public function hello(){
 return 'World!';
}

}

esempio 1:

<?php

//test.php
include_once "./config/Connection.php";

//dichiaro di usare la classe del namespace
use \\config\\Connection; /* nota lo slash davanti a config! */

$connection = new Connection();
echo $connection->hello();

esempio 2:

<?php

include_once...

use \\config; //dichiaro l'uso del namespace, ma così ha più senso se usi un alias

$connection = new config\\Connection();
...

esempio 3, alias classe:

<?php

include_once ...

use \\config\\Connection as AnotherClass;

$connection = new AnotherClass();
...

esempio 4, alias del namespace:

<?php

include_once ...

use \\config as MyCoolNamespace;

$connection = new MyCoolNamespace\\Connection();

...

immagina ora che tu abbia il seguente namesapce:

My\\Cool\\Namespace\\Path

e la classe Connection:

<?php

namespace My\\Cool\\Namespace\\Path;

class Connection{ ... }

una cosa comoda dell'uso dell'alias per il namespace è questo:

<?php

include_once ....

use \\My\\Cool\\Namespace\\Path as DB;

$connection = new DB\\Connection();

eviti il naming collision, rendi il codice più chiaro e di immediata comprensione, aggiungi una froceria che fà molto cool.

cmq in php.net hai tutto il reference sui namespace: http://www.php.net/manual/en/language.namespaces.php