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. L'espace de noms Foo est aussi un nom absolu.

Les noms sont résolus en suivant les règles suivantes :

1. 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.
2. 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().
3. 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().
4. 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().
5. 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 :
   1. Il recherche une fonction dans l'espace de noms courant : A\B\foo().
   2. Il essaie de trouver et appeler la fonction globale foo().
6. 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() :
   1. Il recherche une classe dans l'espace de noms courant : A\B\C.
   2. Il appelle l'autoload pour A\B\C.
   Pour new D\E():
   1. Il recherche une classe dans l'espace de noms courant : A\B\D\E.
   2. Il appelle l'autoload pour A\B\D\E.
   Pour référencer une classe globale dans l'espace de noms global, son nom absolu new \C() doit être utilisé.

<?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"
?>