## Regeln für Namensauflösung

(PHP 5 >= 5.3.0, PHP 7, PHP 8)

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

Namespace-Namen-Definitionen
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 Bezeichner, der mit `namespace` beginnt, wie etwa `namespace\Foo\Bar`.

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

1. 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.
2. 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.
3. 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.
4. 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.
5. 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\foo;` eine Verwendung wie etwa `foo()` zum Namen `A\B\foo` aufgelöst.
6. 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.
7. 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
?>`
`↑` and `↓` to navigate • `Enter` to select • `Esc` to close • `/` to open