Namespaces verwenden: Grundlagen

(PHP 5 >= 5.3.0, PHP 7)

Bevor die Verwendung von Namespaces besprochen wird, ist es wichtig zu verstehen, woher PHP weiß, welches Element mit Namespace vom Code angefordert wird. Eine einfache Analogie kann zwischen PHP-Namensräumen und einem Dateisystem gesehen werden. Es gibt drei Möglichkeiten, mit denen man auf eine Datei in einem Dateisystem zugreifen kann:

Relative Dateinamen wie foo.txt. Dies wird zu aktuellesVerzeichnis/foo.txt aufgelöst, wenn aktuellesVerzeichnis das gerade geöffnete Verzeichnis ist. Wenn also das aktuelle Verzeichnis /home/foo ist, so wird dies als /home/foo/foo.txt aufgelöst.
Relative Pfade wie unterVerzeichnis/foo.txt. Dies wird zu aktuellesVerzeichnis/unterVerzeichnis/foo.txt aufgelöst.
Absolute Pfadangaben wie /main/foo.txt. Dies wird zu /main/foo.txt aufgelöst.

Das gleiche Prinzip kann auf Elemente mit Namespaces in PHP angewandt werden. Zum Beispiel kann eine Klasse auf drei Arten angesprochen werden:

Unqualifizierte Namen oder ein Klassenname ohne Präfix, wie etwa $a = new foo(); oder foo::staticmethod();. Falls der aktuelle Namespace aktuellerNamespace ist, so wird dies zu aktuellerNamespace\foo aufgelöst. Ist der Code globaler Code ohne Namespaces, so wird dies zu foo aufgelöst. Es gibt eine Ausnahme hierzu: Unqualifizierte Namen für Funktionen und Konstanten werden zu globalen Funktionen und Konstanten aufgelöst, wenn die Funktion oder Konstante im Namespace nicht definiert ist. Siehe auch Namespaces verwenden: Rückgriff auf globale Funktion/Konstante für weitere Details.
Qualifizierte Namen oder ein Klassenname mit Präfix, wie etwa $a = new unterNamespace\foo(); oder unterNamespace\foo::staticmethod();. Wenn der aktuelle Namespace aktuellerNamespace ist, so wird dies als aktuellerNamespace\unterNamespace\foo verstanden. Wenn der Code global und ohne Namespaces ist, so wird dies zu unterNamespace\foo aufgelöst.
Vollständig qualifizierte Namen oder Namen mit globalem Präfixoperator wie $a = new \aktuellerNamespace\foo(); oder \aktuellerNamespace\foo::staticmethod();. Dies wird immer wörtlich wie der im Code angegebene Name verstanden, also aktuellerNamespace\foo.

Hier ein Beispiel für die drei Schreibweisen in tatsächlichem Code:

file1.php


<?php
namespace Foo\Bar\subnamespace;

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

file2.php


<?php
namespace Foo\Bar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}

/* Unqualifizierter Name */
foo(); // wird als Funktion Foo\Bar\foo aufgelöst
foo::staticmethod(); // wird als Klasse Foo\Bar\foo und Methode staticmethod aufgelöst
echo FOO; // gibt die Konstante Foo\Bar\FOO aus

/* Qualifizierter Name */
subnamespace\foo(); // wird als Funktion Foo\Bar\subnamespace\foo aufgelöst
subnamespace\foo::staticmethod(); // wird als Klasse Foo\Bar\subnamespace\foo und
                                  // Methode staticmethod aufgelöst
echo subnamespace\FOO; // gibt die Konstante Foo\Bar\subnamespace\FOO aus

/* Vollständig qualifizierter Name */
\Foo\Bar\foo(); // wird als Funktion Foo\Bar\foo aufgelöst
\Foo\Bar\foo::staticmethod(); // wird als Klasse Foo\Bar\foo und Methode staticmethod aufgelöst
echo \Foo\Bar\FOO; // gibt die Konstante Foo\Bar\FOO aus
?>

Beachten Sie, dass für den Zugriff auf jede globale Klasse, Funktion oder Konstante auch ein vollständig qualifizierter Name verwendet werden kann, wie z.B. \strlen(), \Exception oder \INI_ALL.

Beispiel #1 Zugriff auf globale Klassen, Funktionen und Konstanten aus einem Namespace


<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = \strlen('hi'); // ruft die globale Funktion strlen auf
$b = \INI_ALL; // greift auf die globale Konstante INI_ALL zu
$c = new \Exception('error'); // erzeugt eine Neue Instanz der globalen
                              // Klasse Exception
?>