If you like to declare an __autoload function within a namespace or class, use the spl_autoload_register() function to register it and it will work fine.
Foire aux questions : ce que vous devez savoir des espaces de noms
Utilisation des espaces de noms : retour à l'espace global
[edit] Last updated: Fri, 25 May 2012
Utilisation des espaces de noms : retour à l'espace global
[edit] Last updated: Fri, 25 May 2012
Règles de résolutions de noms
(PHP 5 >= 5.3.0)
Dans le cadre des règles de résolution, il y a plusieurs définitions importantes :
-
Définitions pour les espaces de noms
- nom non qualifié
-
Ceci est un identifiant ne contenant pas un séparateur d'espace de noms. Par exemple : Foo
- nom qualifié
-
Ceci est un identifiant contenant un séparateur d'espace de noms. Par exemple : Foo\Bar
- Nom absolu
-
Ceci est un identifiant qui commence par un séparateur d'espace de noms. Par exemple : \Foo\Bar. namespace\Foo est aussi un nom absolu.
Les noms sont résolus en suivant les règles suivantes :
- Les appels à des espaces de noms absolus pour des fonctions, classes ou constantes sont résolus à la compilation. Par exemple, new \A\B utilise la classe A\B.
- Tous les noms qui ne sont pas absolus sont traduits durant la compilation à l'aide des règles d'importation. Par exemple, si le nom A\B\C est importé sous l'alias C, un appel à C\D\e() est traduit en un appel à A\B\C\D\e().
- Dans un nom de domaine, tous les noms qualifiés qui ne sont pas traduits à l'aide des règles d'importation sont préfixés avec l'espace de noms courant. Par exemple, si un appel à C\D\e() est effectué dans l'espace de noms A\B, il est traduit en A\B\C\D\e().
- Les classes non qualifiées sont traduites durant la compilation en fonction des règles d'importations (le nom complet remplace les noms courts). Par exemple, si l'espace de noms A\B\C est importé sous le nom C, new C() est remplacé par new A\B\C().
-
Dans un espace de noms, tel que A\B, les appels à des fonctions sans qualification
sont résolus à la compilation. Voici comment un appel à foo()
est résolu :
- Il recherche une fonction dans l'espace de noms courant : A\B\foo().
- Il essaie de trouver et appeler la fonction globale foo().
-
Dans un espace de noms, e.g. A\B, un appel
à une classe qualifiée ou non qualifiée (pas absolue) est résolu
à l'exécution. Voici comment un appel à new C()
ou à new D\E() est résolu.
Pour new C() :
- Il recherche une classe dans l'espace de noms courant : A\B\C.
- Il appelle l'autoload pour A\B\C.
- Il recherche une classe dans l'espace de noms courant : A\B\D\E.
- Il appelle l'autoload pour A\B\D\E.
Exemple #1 Exemples de résolutions d'espaces de noms
<?php
namespace A;
use B\D, C\E as F;
// appels de fonctions
foo(); // tente d'appeler la fonction "foo" dans l'espace de noms "A"
// puis appelle la fonction globale "foo"
\foo(); // appelle la fonction "foo" définie dans l'espace de noms global
my\foo(); // appelle la fonction "foo" définie dans l'espace de noms "A\my"
F(); // tente d'appeler la fonction "F" définie dans l'espace "A"
// puis tente d'appeler la fonction globale "F"
// référence de classes references
new B(); // crée un objet de la classe "B" définie dans l'espace de noms "A"
// si non trouvé, il essaie l'autoload sur la classe "A\B"
new D(); // crée un objet de la classe "D" définie dans l'espace de noms "B"
// si non trouvé, il essaie l'autoload sur la classe "B\D"
new F(); // crée un objet de la classe "E" définie dans l'espace de noms "C"
// si non trouvé, il essaie l'autoload sur la classe "C\E"
new \B(); // crée un objet de la classe "B" définie dans l'espace de noms global
// si non trouvé, il essaie l'autoload sur la classe "B"
new \D(); // crée un objet de la classe "D" définie dans l'espace de noms global
// si non trouvé, il essaie l'autoload sur la classe "D"
new \F(); // crée un objet de la classe "F" définie dans l'espace de noms global
// si non trouvé, il essaie l'autoload sur la classe "F"
// méthodes statiques et fonctions d'espace de noms d'un autre espace
B\foo(); // appelle la fonction "foo" de l'espace de noms "A\B"
B::foo(); // appelle la méthode "foo" de la classe "B" définie dans l'espace de noms "A"
// si la classe "A\B" n'est pas trouvée, il essaie l'autoload sur la classe "A\B"
D::foo(); // appelle la méthode "foo" de la classe "D" définie dans l'espace de noms "B"
// si la classe "B\D" n'est pas trouvée, il essaie l'autoload sur la classe "B\D"
\B\foo(); // appelle la fonction "foo" de l'espace de noms "B"
\B::foo(); // appelle la méthode "foo" de la classe "B" située dans l'espace de noms global
// si la classe "B" n'est pas trouvée, il essaie l'autoload sur la classe "B"
// méthodes statiques et fonctions d'espace de noms de l'espace courant
A\B::foo(); // appelle la méthode "foo" de la classe "B" de l'espace de noms "A\A"
// si la classe "A\A\B" n'est pas trouvée, il essaie l'autoload sur la classe "A\A\B"
\A\B::foo(); // appelle la méthode "foo" de la classe "B" de l'espace de noms "A"
// si la classe "A\B" n'est pas trouvée, il essaie l'autoload sur la classe "A\B"
?>
Foire aux questions : ce que vous devez savoir des espaces de noms
Utilisation des espaces de noms : retour à l'espace global
[edit] Last updated: Fri, 25 May 2012
Utilisation des espaces de noms : retour à l'espace global
[edit] Last updated: Fri, 25 May 2012
add a note
User Contributed Notes
Règles de résolutions de noms
kdimi
27-Oct-2010 12:35
safakozpinar at NOSPAM dot gmail dot com
21-Oct-2010 07:04
As working with namespaces and using (custom or basic) autoload structure; magic function __autoload must be defined in global scope, not in a namespace, also not in another function or method.
<?php
namespace Glue {
/**
* Define your custom structure and algorithms
* for autoloading in this class.
*/
class Import
{
public static function load ($classname)
{
echo 'Autoloading class '.$classname."\n";
require_once $classname.'.php';
}
}
}
/**
* Define function __autoload in global namespace.
*/
namespace {
function __autoload ($classname)
{
\Glue\Import::load($classname);
}
}
?>
sammaye
11-Jun-2010 10:24
I have noticed one problem with __autoload function. Say you have two namespaces, one is a sub of the other:
\Glue
\Glue\Import
Within that Import namespace you have a function auto() with the magic __autoload inside. No matter what you do that auto() will never traverse it's sub function meaning you will nevber get an __autoload function.
Even if you put the __autoload within a class within the namespace as such:
<?php
namespace Glue\Import;
class import{
private static $_AutoLoad = array();
private static $_Imported = array();
function load($sName){
if(! isset(self::$_AutoLoad[$sName]))
//throw new ImportError("Cannot import module with name '$sName'.");
echo("file with name '$sName' failed to load with path '".self::$_AutoLoad[$sName]."'");
if(! isset(self::$_Imported[$sName])){
self::$_Imported[$sName] = True;
return include_once(self::$_AutoLoad[$sName]);
}
}
function push($sName, $sPath){
self::$_AutoLoad[$sName] = $sPath;
}
function auto(){
function __autoload($sClass){
load($sClass);
}
}
}
?>
It will not work. Just something to keep in mind.
rangel
30-Jul-2009 06:48
The term "autoload" mentioned here shall not be confused with __autoload function to autoload objects. Regarding the __autoload and namespaces' resolution I'd like to share the following experience:
->Say you have the following directory structure:
- root
| - loader.php
| - ns
| - foo.php
->foo.php
<?php
namespace ns;
class foo
{
public $say;
public function __construct()
{
$this->say = "bar";
}
}
?>
-> loader.php
<?php
//GLOBAL SPACE <--
function __autoload($c)
{
require_once $c . ".php";
}
class foo extends ns\foo // ns\foo is loaded here
{
public function __construct()
{
parent::__construct();
echo "<br />foo" . $this->say;
}
}
$a = new ns\foo(); // ns\foo also loads ns/foo.php just fine here.
echo $a->say; // prints bar as expected.
$b = new foo; // prints foobar just fine.
?>
If you keep your directory/file matching namespace/class consistence the object __autoload works fine.
But... if you try to give loader.php a namespace you'll obviously get fatal errors.
My sample is just 1 level dir, but I've tested with a very complex and deeper structure. Hope anybody finds this useful.
Cheers!
rangel
30-Jul-2009 06:47
The term "autoload" mentioned here shall not be confused with __autoload function to autoload objects. Regarding the __autoload and namespaces' resolution I'd like to share the following experience:
->Say you have the following directory structure:
- root
| - loader.php
| - ns
| - foo.php
->foo.php
<?php
namespace ns;
class foo
{
public $say;
public function __construct()
{
$this->say = "bar";
}
}
?>
-> loader.php
<?php
//GLOBAL SPACE <--
function __autoload($c)
{
require_once $c . ".php";
}
class foo extends ns\foo // ns\foo is loaded here
{
public function __construct()
{
parent::__construct();
echo "<br />foo" . $this->say;
}
}
$a = new ns\foo(); // ns\foo also loads ns/foo.php just fine here.
echo $a->say; // prints bar as expected.
$b = new foo; // prints foobar just fine.
?>
If you keep your directory/file matching namespace/class consistence the object __autoload works fine.
But... if you try to give loader.php a namespace you'll obviously get fatal errors.
My sample is just 1 level dir, but I've tested with a very complex and deeper structure. Hope anybody finds this useful.
Cheers!