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.

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

Aufrufe von vollständig qualifizierten Funktionen, Klassen oder Konstanten werden zur Kompilierungszeit aufgelöst. new \A\B wird z.B. zur Klasse A\B aufgelöst.
Alle unqualifizierten und qualifizierten Namen (nicht vollständig qualifizierte Namen) werden gemäß den aktuellen Importen zur Kompilierungszeit übersetzt. Wenn zum Beispiel der namespace A\B\C als C importiert wurde, so wird ein Aufruf von C\D\e() zu A\B\C\D\e() übersetzt.
Innerhalb eines Namespace wird allen qualifizierten Namen, die noch nicht gemäß den Importregeln übersetzt wurden, der aktuelle Namespace vorangestellt. Wenn z.B. C\D\e() innerhalb des Namespace A\B aufgerufen wird, so wird dies zu A\B\C\D\e() übersetzt.
Unqualifizierte Klassennamen werden zur Kompilierungszeit gemäß der aktuellen Importregeln (vollständige Namen ersetzt durch kurze Aliasnamen) übersetzt. Z.B. wenn der Namespace A\B\C als C importiert wurde, so wird new C() zu new A\B\C() übersetzt.
Innerhalb eines Namespace (z.B. A\B) werden Aufrufe von unqualifizierten Funktionen zur Laufzeit aufgelöst. Der Aufruf der Funktion foo() wird wie folgt aufgelöst:
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.
Innerhalb eines Namespace (z.B. A\B) werden Aufrufe von unqualifizierten oder qualifizierten Klassennamen (nicht vollständig qualifizierte Klassennamen) zur Laufzeit aufgelöst. Der Aufruf von new C() oder new D\E() wird wir folgt aufgelöst. Für new C():
1. Zuerst wird nach der Klasse im aktuellen Namespace gesucht: A\B\C.
2. Es wird versucht, die Klasse A\B\C mittels Autoload zu laden.
Für new D\E():
1. Es wird nach der Klasse gesucht, indem der aktuelle Namespace vorangestellt wird: A\B\D\E.
2. Es wird versucht, die Klasse A\B\D\E mittels Autoload zu laden.
Um auf eine globale Klasse im globalen Namespace zuzugreifen, muss deren vollständig qualifizierter Name new \C() verwendet werden.

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