Beispiele für detaillierte Erläuterungen zur Verwendung von PHP-Namespaces

Namespace dient hauptsächlich dazu, das Problem möglicher Konflikte zwischen Klassen und Funktionen im Code zu lösen. In diesem Artikel werden Ihnen die wichtigsten Funktionen des PHP-Namespace vorgestellt, einschließlich der Definition des Namespace und anderer Wissenspunkte. Freunde, die ihn benötigen, können darauf verweisen.

Der Namespace dient hauptsächlich dazu, das Problem möglicher Konflikte zwischen Klassen und Klassen zu lösen Funktionen im Code, während andere Sprachen diese Funktion schon seit langem hatten, kam PHP erst spät auf den Markt, was auch den Aufstieg von Composer zur Folge hatte, daher ist es eine sehr wichtige Funktion .

Definition des Namespace

Ein Namespace ist ein Container, der hauptsächlich zur Identifizierung der darunter liegenden Klassen und Funktionen verwendet wird. Sobald ein Namespace definiert ist, gehört der darunter liegende Code zu diesem Namespace, daher sollte die Definition des Namespace ganz am Anfang des Codes stehen.

Für dasselbe Paket muss der Code im selben Namespace oder Sub-Namespace nicht in einer PHP-Datei definiert werden. Der Code im Sub-Namespace dient dazu, die Arbeit eines bestimmten Moduls abzuschließen Zusammengenommen wird es zu einem Paket-vollständigen Namespace.

Wenn der von Ihnen geschriebene Code keinen Namespace definiert, bedeutet dies, dass er zum globalen Namespace (Symbol) gehört, sodass Sie direkt auf Klassen oder Funktionen verweisen können (ohne das Symbol hinzuzufügen).

Drei Möglichkeiten, auf Namespace-IDs zu verweisen

(1) Der vollständig qualifizierte Name

ähnelt einem absoluten Pfad auf dem Betriebssystem ist der vollständige Pfad, sodass beim Verständnis keine Missverständnisse entstehen.

Zum Beispiel wird C im neuen ABC in die C-Klasse unter dem AB-Namespace aufgelöst.

(2) Der qualifizierte Name

ähnelt einem relativen Pfad auf dem Betriebssystem, er enthält einen Teil des Namens und verweist auf den aktuellen Namespace.

Wenn beispielsweise BC() unter Namespace A aufgerufen wird, ist der endgültig referenzierte Namespace ABC().

(3) Der nicht qualifizierte Name

ähnelt dem qualifizierten Namen, enthält jedoch keine Unternamensräume.

Wenn beispielsweise C() unter dem Namespace AB aufgerufen wird, ist der letztendlich referenzierte Namespace ABC().

Veranschaulichen Sie die drei Zitiermethoden anhand eines Beispiels:

namespace \Example;
require_once "fnction.php";
class ClassA {}
function Function() {}
//完全限定名称
\Example\Function();
\Example\B\Function(); 
//限定名称
B\Function(); //指向 \Example\B\Function();
//非限定名称
$test = new ClassA(); //resolves to \Example\ClassA
Function(); //指向 \Example\Function

Hinweis:

•Wenn innerhalb eines Namespace keine Definitionen von Funktionen und Konstanten im aktuellen Bereich gefunden werden, meldet PHP keinen Fehler. Suchen Sie stattdessen im globalen Namespace danach.

•Wenn innerhalb eines Namespace keine Klassendefinition im aktuellen Bereich gefunden wird, meldet PHP direkt einen Fehler und geht nicht zum globalen Bereich, um die entsprechende Klasse zu finden, wenn Sie also auf eine interne Klasse verweisen müssen Bei einer benutzerdefinierten Klasse oder einer benutzerdefinierten Klasse muss der vollständig qualifizierte Name verwendet werden.

Nehmen wir zunächst ein einfaches Beispiel. Schreiben Sie zunächst einen Code (im Namespace definiert) und nennen Sie ihn function.php:

namespace Foo\Bar\subnamespace;
const FOO = 1;
function foo() 
{
  return "foo\r\n";
}
class foo 
{
  static function staticmethod()
  {
    return __METHOD__ . "\r\n" ;
  }
  function foofunction()
  {
    return __METHOD__ . "\r\n" ;
  }
}

Schreiben Sie dann ein Stück Code test.php, bei dem es sich auch um Code unter dem Namensraum handelt:

namespace secondsp;
include 'function.php';
class foo
{
  function foofunction()
  {
    return __METHOD__ . "\r\n" ;
  }
}
function is_file($file)
{
  return true ;
}
//非限定名称:实例化secondsp\foo类对象
$obj = new foo; 
echo $obj->foofunction();
//实例化Foo\Bar\subnamespace\foo 类对象
$obj = new Foo\Bar\subnamespace\foo ;
echo $obj->foofunction();
//代码会报错，在命名空间内部，假如无法找到当前命名空间下的类，则会报错
//$obj = new ArrayObject(array(1)); 
$obj = new \ArrayObject(array(1)); 
//在命名空间内部，假如无法找到当前命名空间下的函数或者常量，则会寻找 native function
echo strlen("nihao");
 //引用当前命名空间下的函数
var_dump(is_file('nihao')); //True
//引用全局函数
var_dump(\is_file('nihao')); //False

import, alias

wenn Die zu verwendende Namespace-Hierarchie ist sehr lang und zahlreich, was die Verwendung besonders schwierig macht. Daher können Sie das Schlüsselwort use verwenden, um Namespaces, Klassen, Konstanten, Funktionen usw. zu importieren und diese dann zum direkten Verweisen zu verwenden die kompletten Namen. Das Schlüsselwort alias kann importierte Klassen und Funktionen umbenennen.

Beispielsweise zur Verwendung des Schlüsselworts use befindet sich dieser Code im globalen Namespace:

include 'function.php';
use Foo\Bar\subnamespace\foo ;
$obj = new foo;
echo $obj->foofunction();
use Foo\Bar\subnamespace\foo as aliasfunname;
$obj = new aliasfunname;
echo $obj->foofunction();
use Foo\Bar\subnamespace ; 
$obj = new subnamespace\foo ;
echo $obj->foofunction();
use Foo\Bar\subnamespace as aliasname;
$obj = new aliasname\foo ;
echo $obj->foofunction();
//由于调用代码并不在命名空间内，所以对于全局的类，无需引入使用
$obj = new ArrayObject(array(1)); 
//导入一个函数
use function Foo\Bar\subnamespace\foo  ;
echo foo();
use function Foo\Bar\subnamespace\foo as func;
echo func();
use const Foo\Bar\subnamespace\FOO;
//echo FOO;

Zusammenfassung:

•Im Gegensatz zu Python ist der Namespace in PHP ein semantisches Konzept und hat nichts mit der Position und dem Layout des spezifischen Codes zu tun. Mit anderen Worten: Der Code, der den Namespace verwendet, muss die Bibliotheksdatei selbst importieren (Alle Dateien), es spielt keine Rolle, wie die Bibliotheksdateien in Python organisiert sind. Wenn ein Modul oder Paket eine __init__.py-Datei enthält, führt der Python-Parser automatisch die Dateien des Pakets oder aller Module ein.

•Das Konzept des Bereichs in PHP ist sehr schwach und die globale Domäne und die lokale Domäne werden klar unterschieden. Beispielsweise können Variablen im globalen Raum nicht in Funktionen oder Klassen referenziert werden. Bei Namespaces ist die Situation anders. Wenn der Code, der den Namespace definiert, die Konstanten und Funktionen im entsprechenden Namespace nicht finden kann, verwendet er globale Konstanten und Funktionen, und wenn er die Klasse nicht im entsprechenden Namespace finden kann (einschließlich seiner eigenen Define-Klasse). ), meldet der Code direkt einen Fehler.

•Wenn Sie den Namespace über das Schlüsselwort use verwenden, müssen Sie ihn nicht über den vollständig qualifizierten Namen (Symbol) importieren, da PHP bereits davon ausgeht, dass der importierte Namespace ein vollständig qualifizierter Namespace ist.

•Konstanten, Funktionen, Klassen, Schnittstellen und andere Namespaces können über das Schlüsselwort use importiert werden.

• Namespace ist eine Sprachfunktion. Um eine effektivere Nutzung zu erreichen, sollte es eine Nutzungsspezifikation und einen automatischen Lademechanismus geben, nämlich die PSR-4-Spezifikation.

Das obige ist der detaillierte Inhalt vonBeispiele für detaillierte Erläuterungen zur Verwendung von PHP-Namespaces. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!