Diese Seite bei php.net
The PHP manual text and comments are covered by the Creative Commons Attribution 3.0 License © the PHP Documentation Group - Impressum - mail("TO:Reinhard Neidl",...)
Diese häufig gestellten Fragen (FAQ) wurden in zwei Abschnitte aufgeteilt: allgemeine Fragen und einige Implementierungsdetails, deren vollständiges Verständnis hilfreich sein kann.
Zuerst die allgemeinen Fragen.
Es gibt einige Implementierungsdetails von Namespaces, deren Verständnis hilfreich ist.
Nein. Namespaces haben keinerlei Einfluss auf bereits bestehenden Code oder irgendwelchen Code der noch geschrieben wird, der keine Namespaces verwendet. Sie können folgenden Code schreiben, wenn Sie dies wünschen:
Beispiel #1 Zugriff auf globale Klassen außerhalb eines Namespace
<?php
$a = new \stdClass;
?>
Dies ist äquivalent zu:
Beispiel #2 Zugriff auf globale Klassen außerhalb eines Namespace
<?php
$a = new stdClass;
?>
Beispiel #3 Zugriff auf interne Klassen in Namespaces
<?php
namespace foo;
$a = new \stdClass;
function test(\ArrayObject $typehintexample = null) {}
$a = \DirectoryIterator::CURRENT_AS_FILEINFO;
// erben von einer internen oder globalen Klasse
class MyException extends \Exception {}
?>
Beispiel #4 Zugriff auf interne Klassen, Funktionen oder Konstanten in Namespaces
<?php
namespace foo;
class MyClass {}
// verwendet eine Klasse des aktuellen Namensraumes als Type-Hint
function test(MyClass $typehintexample = null) {}
// eine andere Möglichkeit, eine Klasse des aktuellen Namensraums
// als Type-Hint zu verwenden
function test(\foo\MyClass $typehintexample = null) {}
// ableiten von einer Klasse aus dem aktuellen Namespace
class Extended extends MyClass {}
// Zugriff auf eine globale Funktion
$a = \globalfunc();
// Zugriff auf eine globale Konstante
$b = \INI_ALL;
?>
Namen, die mit einem \ beginnen, werden immer zu exakt dem aufgelöst wie sie aussehen. \mein\name ist also tatsächlich \mein\name und \Exception ist Exception.
Beispiel #5 Vollständig qualifizierte Namen
<?php
namespace foo;
$a = new \my\name(); // erzeugt ein Objekt der Klasse "my\name"
echo \strlen('hi'); // ruft die Funktion "strlen" auf
$a = \INI_ALL; // $a wird auf den Wert der Konstante "INI_ALL" gesetzt
?>
Namen, die einen Backslash beinhalten, aber nicht mit einem Backslash beginnen, wie z.B. mein\name, können auf zwei verschiedene Arten aufgelöst werden.
Falls es einen Import-Ausdruck gibt, der einen Alias für einen anderen Namen definiert, so dass dieser mein heißen soll, dann wird dieser Alias für das mein in mein\name angewandt.
Andernfalls wird der aktuelle Namespace vor mein\name vorangestellt.
Beispiel #6 Qualifizierte Namen
<?php
namespace foo;
use blah\blah as foo;
$a = new my\name(); // erzeugt ein Objekt der Klasse "foo\my\name"
foo\bar::name(); // ruft die statische Methode "name"
// der Klasse "blah\blah\bar" auf
my\bar(); // ruft die Funktion "foo\my\bar" auf
$a = my\BAR; // setzt $a auf den Wert der Konstante "foo\my\BAR"
?>
Klassennamen, die keinen Backslash beinhalten, wie z.B. name, können auf zwei Arten aufgelöst werden.
Falls es einen Import-Ausdruck gibt, der einen Alias für einen anderen Namen definiert, so dass dieser name heißen soll, dann wird dieser Alias angewandt.
Andernfalls wird der aktuelle Namespace name vorangestellt.
Beispiel #7 Unqualifizierter Klassennamen
<?php
namespace foo;
use blah\blah as foo;
$a = new name(); // erzeugt ein Objekt der Klasse "foo\name"
foo::name(); // ruft die statische Methode "name" der Klasse "blah\blah" auf
?>
Funktions- oder Konstantennamen, die keinen Backslash beinhalten, wie z.B. name, können auf zwei verschiedene Arten aufgelöst werden.
Zuerst wird der aktuelle Namespace dem name vorangestellt.
Wenn die Konstante oder Funktion name im aktuellen Namensraum nicht existiert, so wird die globale Konstante oder Funktion name verwendet, wenn sie existiert.
Beispiel #8 Unqualifizierte Funktions- oder Konstantennamen
<?php
namespace foo;
use blah\blah as foo;
const FOO = 1;
function my() {}
function foo() {}
function sort(&$a)
{
sort($a);
$a = array_flip($a);
return $a;
}
my(); // ruft "foo\my" auf
$a = strlen('hi'); // ruft die globale Funktion "strlen" auf, weil
// foo\strlen nicht existiert
$arr = array(1,3,2);
$b = sort($arr); // ruft die Funktion "foo\sort" auf
$c = foo(); // ruft die Funktion "foo\foo" auf - der Alias wird ignoriert
$a = FOO; // setzt $a auf den Wert der Konstante "foo\FOO" -
// der Alias wird ignoriert
$b = INI_ALL; // setzt $b auf den Wert der globalen Konstante "INI_ALL"
?>
Die folgende Kombination von Skripten ist gültig:
file1.php
<?php
namespace mein\zeug;
class MyClass {}
?>
anderes.php
<?php
namespace anderes;
class Ding {}
?>
file2.php
<?php
namespace mein\zeug;
include 'file1.php';
include 'anderes.php';
use anderes\Ding as MyClass;
$a = new MyClass; // erzeugt ein Objekt der Klasse "Ding"
// aus dem Namespace "anderes"
?>
Es gibt hier, trotzdem es eine Klasse MyClass im Namespace mein\zeug gibt, keinen Namenskonflikt, weil die Definition der Klasse MyClass sich in einer anderen Datei befindet. Das nächste Beispiel erzeugt hingegen einen fatal error wegen eines Namenskonflikts, weil MyClass in derselben Datei definiert wird, die auch den use-Ausdruck beinhaltet.
<?php
namespace mein\zeug;
use anderes\Ding as MyClass;
class MyClass {} // fatal error: Konflikt zwischen MyClass und import-Ausdruck
$a = new MyClass;
?>
PHP erlaubt das Verschachteln von Namespaces nicht.
<?php
namespace mein\zeug {
namespace verschachtelt {
class foo {}
}
}
?>
<?php
namespace mein\zeug\verschachtelt {
class foo {}
}
?>
Die einzigen Elemente, die von einem use-Ausdruck beeinflusst werden, sind Namespaces und Klassenamen. Um einen langen Konstanten- oder Funktionsnamen abzukürzen, kann dessen beinhaltender Namespace importiert werden.
<?php
namespace mein;
use sehr\langer\namespace\name;
$a = name\CONSTANT;
name\func();
?>
Es ist wichtig zu bemerken, dass ein Backslash in Strings als Escape-Zeichen verwendet wird und daher immer verdoppelt werden sollte, wenn er in einem String verwendet wird. Andernfalls besteht das Risiko ungewollter Auswirkungen:
Beispiel #9 Gefahren von Namespacenamen in Strings mit doppelten Anführungszeichen
<?php
$a = new "gefaehrlicher\name"; // \n ist in doppelten Anführungszeichen
// ein Zeilenumbruch!
$obj = new $a;
$a = new 'ueberhaupt\nicht\gefaehrlich'; // hier gibt es keine Probleme
$obj = new $a;
?>
Jeder Zugriff auf eine Konstante mit unqualifiziertem Namen, wie FOO, wird eine Notice erzeugen, welche erklärt, dass PHP angenommen hat, dass FOO der Wert der Konstante sei. Jede Konstante, qualifiziert oder vollständig qualifiziert, deren Name einen Backslash enthält, wird einen fatal error hervorrufen, wenn sie nicht gefunden wurde.
Beispiel #10 Undefinierte Konstanten
<?php
namespace bar;
$a = FOO; // notice - undefined constant "FOO" assumed "FOO";
$a = \FOO; // fatal error, undefined namespace constant FOO
$a = Bar\FOO; // fatal error, undefined namespace constant bar\Bar\FOO
$a = \Bar\FOO; // fatal error, undefined namespace constant Bar\FOO
?>
Jeder Versuch, eine Konstante in einem Namespace zu definieren, die eine der speziellen, eingebauten Konstanten ist, wird einen fatal error hervorrufen.
Beispiel #11 Spezielle Konstanten
<?php
namespace bar;
const NULL = 0; // fatal error;
const true = 'stupid'; // ebenfalls fatal error;
// etc.
?>
Diese Seite bei php.net