Regeln für Namensauflösung

(PHP 5 >= 5.3.0, PHP 7)

Hier einige wichtige Definitionen für die Zwecke der Namensauflösungsregeln:

Unqualifizierter Name: Dies ist ein Bezeichner ohne einen Namespaceseparator, z.B. Foo
Qualifizierter Name: Dies ist ein Bezeichner mit einem Namespaceseparator, z.B. Foo\Bar
Vollständig qualifizierter Name: Dies ist ein Bezeichner mit einem Namespaceseparator, der mit einem Namespaceseparator beginnt, z.B. \Foo\Bar. Der Namespace namespace\Foo ist ebenfalls ein vollständig qualifizierter Name.
Relativer Name: Dies ist ein Bezeicher, der mit namespace beginnt, wie etwa namespace\Foo\Bar.

Namen werden gemäß den folgenden Regeln aufgelöst:

Vollständig qualifizierte Namens werden immer zu dem Namen ohne führenden Namensraumtrenner aufgelöst. \A\B wird z.B. zu A\B aufgelöst.
Relative Namen werden immer zu dem Namen aufgelöst, in dem namespace durch den aktuellen Namensraum ersetzt wurde. Taucht der Namen im globalen Geltungsbereich auf, wird das namespace\-Präfix entfernt. Beispielsweise wird namespace\A innerhalb des Namensraums X\Y zu X\Y\A aufgelöst. Derselbe Name im globalen Geltungsbereich wird zu A aufgelöst.
Für qualifizierte Namen wird das erste Segment des Namens gemäß der aktuellen Klassen-/Namensraum-Importtabelle übersetzt. Wird beispielsweise der Namensraum A\B\C als C importiert, wird der Name C\D\E zu A\B\C\D\E übersetzt.
Wenn für qualifizierte Namen keine Importregel zutrifft, wird der aktuelle Namensraum dem Namen vorangestellt. Beispielsweise wird der Name C\D\E innerhalb des Namensraums A\B zu A\B\C\D\E aufgelöst.
Für unqualifizierte Namen wird der Name gemäß der aktuellen Importtabelle für die betreffende Symboltabelle übersetzt. Das bedeutet, dass klassenartige Namen gemäß der Klassen-/Namensraum-Importtabelle, Funktionsnamen gemäß der Funktions-Importtabelle und Konstantennamen gemäß der Konstanten-Importtabelle übersetzt werden. Beispielsweise wird nach use A\B\C; eine Verwendung wie etwa new C() zum Namen A\B\C() aufgelöst. Analog wird nach use function A\B\fn; eine Verwendung wie etwa fn() zum Namen A\B\fn aufgelöst.
Wenn für unqualifizierte Namen keine Importregel zutrifft, und sich der Name auf ein klassenartiges Symbol bezieht, wird der aktuelle Namensraum vorangestellt. Beispielsweise wird new C() innerhalb des Namensraums A\B zum Namen A\B\C aufgelöst.
Wenn für unqualifizierte Namen keine Importregel zutrifft, und sich der Name auf eine Funktion oder Konstante bezieht, und der Code sich außerhalb des globalen Geltungsbereichs befindet, wird der Name zur Laufzeit aufgelöst. Angenommen der Code befindet sich im Namensraum A\B, wird im folgenden erläutert, wie der Aufruf einer Funktion foo() aufgelöst wird:
1. Zuerst wird nach der Funktion im aktuellen Namespace gesucht: A\B\foo().
2. Es wird versucht, die Funktion foo() im globalen Namensraum zu finden und aufzurufen.

Beispiel #1 Illustration der Namensauflösung


<?php
namespace A;
use B\D, C\E as F;

// Funktionsaufrufe

foo();      // versucht zuerst die Funktion "foo" im Namespace "A" aufzurufen
            // danach wird die globale Funktion "foo" aufgerufen

\foo();     // ruft die Funktion "foo" im globalen Namensraum auf

my\foo();   // ruft die Funktion "foo" im Namespace "A\my" auf

F();        // versucht zuerst die Funktion "F" im Namespace "A" aufzurufen,
            // danach wird die globale Funktion "F" aufgerufen

// Klassenreferenzen

new B();    // erzeugt ein Objekt der Klasse "B" im Namespace "A"
            // wenn diese Klasse nicht bekannt ist, so wird versucht per
            //  Autoload die Klasse "A\B" zu laden

new D();    // gemäß den Importregeln wird ein Objekt der Klasse "D"
            //  aus dem Namenspace "B" erzeugt
            // wenn diese Klasse nicht bekannt ist, so wird versucht per
            //  Autoload die Klasse "B\D" zu laden

new F();    // gemäß den Importregeln wird ein Objekt der Klasse "E"
            //  aus dem Namespace "C" erzeugt
            // wenn diese Klasse nicht bekannt ist, so wird versucht per
            //  Autoload die Klasse "C\E" zu laden

new \B();   // erzeugt ein Objekt der Klasse "B" aus dem globalen Namensraum
            // wenn diese Klasse nicht bekannt ist, so wird versucht per
            //  Autoload die Klasse "B" zu laden

new \D();   // erzeugt ein Objekt der Klasse "D" aus dem globalen Namensraum
            // wenn diese Klasse nicht bekannt ist, so wird versucht per
            //  Autoload die Klasse "D" zu laden

new \F();   // erzeugt ein Objekt der Klasse "F" aus dem globalen Namensraum
            // wenn diese Klasse nicht bekannt ist, so wird versucht per
            //  Autoload die Klasse "F" zu laden

// statische Methoden und Funktionen mit Namespace aus anderen Namespaces

B\foo();    // ruft die Funktion "foo" aus dem Namensraum "A\B" auf

B::foo();   // ruft die Methode "foo" der Klasse "B" im Namensraum "A" auf
            // wenn die Klasse "A\B" nicht bekannt ist, so wird versucht
            //  die Klasse "A\B" mittels Autoload zu laden

D::foo();   // ruft gemäß den Importregeln die Methode "foo" der Klasse "D"
            //  im Namensraum "B" auf
            // wenn die Klasse "B\D" nicht bekannt ist, so wird versucht
            //  die Klasse "B\D" mittels Autoload zu laden

\B\foo();   // ruft die Funktion "foo" im Namespace "B" auf

\B::foo();  // ruft die Methode "foo" der Klasse "B" im
           //   globalen Namensraum auf
            // wenn die Klasse "B" nicht bekannt ist, so wird versucht
            //  die Klasse "B" mittels Autoload zu laden

// statische Methoden und Funktionen mit Namespace aus den gleichen Namespaces

A\B::foo();   // ruft die Methode "foo" der Klasse "B" aus dem Namespace "A\A" auf
              // wenn die Klasse "A\A\B" nicht bekannt ist, so wird
              //  versucht die Klasse "A\A\B" mittels Autoload zu laden

\A\B::foo();  // ruft die Methode "foo" der Klasse "B" aus dem Namespace "A" auf
              // wenn die Klasse "A\B" nicht bekannt ist, so wird
              //  versucht die Klasse "A\B" mittels Autoload zu laden
?>