Der offensichtlichste Zweck von Namespaces ist es, das Problem doppelter Namen zu lösen. PHP erlaubt es nicht, dass zwei Funktionen oder Klassen denselben Namen haben; andernfalls tritt ein fataler Fehler auf. In diesem Fall kann das Problem einfach durch Vermeidung doppelter Namen gelöst werden, und einer der häufigsten Ansätze ist, sich auf ein Präfix zu einigen.

Beispiel: Das Projekt hat zwei Module: Artikel und Message Board, und jedes hat eine Comment-Klasse, die Benutzernachrichten verarbeitet. Später möchte ich vielleicht eine Statistikfunktionalität für alle Benutzernachrichten hinzufügen, z. B. die Gesamtzahl der Nachrichten ermitteln. An diesem Punkt wäre es ein guter Ansatz, die von ihren Comment-Klassen bereitgestellten Methoden aufzurufen, aber beide Comment-Klassen gleichzeitig einzubinden ist offensichtlich nicht akzeptabel – der Code wird einen Fehler verursachen. Eine der beiden Comment-Klassen woanders neu zu schreiben würde ebenfalls die Wartbarkeit verringern. In diesem Fall bleibt nur, die Klassennamen umzubauen. Ich habe mich auf eine Namensregel verständigt: den Modulnamen dem Klassennamen voranzustellen, etwa so: Article_Comment, MessageBoard_Comment.

Wie Sie sehen, werden die Namen sehr lang, was bedeutet, dass später bei der Verwendung von Comment mehr Code geschrieben werden muss (zumindest mehr Zeichen). Wenn außerdem in Zukunft mehr Integrationsfunktionen zu den Modulen hinzugefügt werden oder wenn die Module sich gegenseitig aufrufen, müssen die Namen immer dann refaktoriert werden, wenn Duplikate auftreten. Natürlich kann die Erkennung dieses Problems zu Beginn des Projekts und die Festlegung von Namensregeln es wirksam vermeiden. Eine andere Lösung ist die Verwendung von Namespaces.

Hinweis:In diesem Artikel erwähnte Konstanten: Seit PHP 5.3 kann das Schlüsselwort const außerhalb von Klassen verwendet werden. Sowohl const als auch define werden zum Deklarieren von Konstanten verwendet (ihre Unterschiede werden hier nicht erläutert), aber in einem Namespace hat define einen globalen Gültigkeitsbereich, während const für den aktuellen Namensraum gilt. Die in diesem Artikel erwähnten Konstanten beziehen sich auf Konstanten, die mit const deklariert wurden.

Grundlagen

Namensräume unterteilen Code in verschiedene Räume (Bereiche). Die Namen von Konstanten, Funktionen und Klassen (um es mir einfach zu machen, bezeichne ich sie im Folgenden als "Elemente") in den einzelnen Räumen beeinflussen sich nicht gegenseitig. Das ähnelt in etwa dem Konzept der "Kapselung", das wir oft erwähnen.

Um einen Namespace zu erstellen, musst du das Schlüsselwort namespace verwenden, so wie hier:

<?php
//创建一个名为'Article'的命名空间
namespace Article;
?>

Beachte, dass vor dem ersten Namespace in der aktuellen Skriptdatei kein Code stehen darf. Die folgenden Verwendungsweisen sind alle falsch:

Beispiel 1

//在脚本前面写了一些逻辑代码
<?php
$path = "/";
class Comment { }
namespace Article;
?>

Beispiel 2

</html>
<?php
namespace Article;
?>

Warum erwähne ich den ersten Namespace? Weil in derselben Skriptdatei mehrere Namespaces erstellt werden können.

Unten habe ich zwei Namespaces erstellt und nebenbei jedem Raum ein Element der Klasse Comment hinzugefügt:

<?php
//创建一个名为'Article'的命名空间
namespace Article;

//此Comment属于Article空间的元素
class Comment { }


//创建一个名为'MessageBoard'的命名空间
namespace MessageBoard;

//此Comment属于MessageBoard空间的元素
class Comment { }
?>

Elemente in verschiedenen Räumen können nicht direkt gegenseitig aufgerufen werden; die Namespace-Syntax muss verwendet werden:

<?php
namespace Article;
class Comment { }

namespace MessageBoard;
class Comment { }

//调用当前空间(MessageBoard)的Comment类
$comment = new Comment();

//调用Article空间的Comment类
$article_comment = new \Article\Comment();
?>

Wie du siehst, wird beim Aufruf der Klasse Comment im Article-Raum aus dem MessageBoard-Raum eine dateipfadähnliche Syntax verwendet:\Namespace-Name\Elementname

Abgesehen von Klassen ist die Verwendung bei Funktionen und Konstanten dieselbe. Unten habe ich neue Elemente für die beiden Räume erstellt und ihre Werte im MessageBoard-Raum ausgegeben.

<?php
namespace Article;

const PATH = '/article';

function getCommentTotal() {
    return 100;
}

class Comment { }


namespace MessageBoard;

const PATH = '/message_board';

function getCommentTotal() {
    return 300;
}

class Comment { }

//调用当前空间的常量、函数和类
echo PATH; ///message_board
echo getCommentTotal(); //300
$comment = new Comment();

//调用Article空间的常量、函数和类
echo \Article\PATH; ///article
echo \Article\getCommentTotal(); //100
$article_comment = new \Article\Comment();
?>

Und tatsächlich habe ich die Elementdaten aus dem Article-Raum erhalten.

Unter-Namespaces

Es ergibt Sinn, dass die Namespace-Aufrufsyntax wie ein Dateipfad ist; sie erlaubt es uns, Unter-Namespaces zu definieren, um die Beziehungen zwischen verschiedenen Räumen zu beschreiben.

Entschuldigung, ich habe vergessen zu erwähnen, dass die Article- und MessageBoard-Module eigentlich beide zum selben Blogprojekt gehören. Wenn wir Namespaces verwenden, um ihre Beziehung auszudrücken, sieht das so aus:

<?php
//我用这样的命名空间表示处于blog下的article模块
namespace Blog\Article;

class Comment { }


//我用这样的命名空间表示处于blog下的message board模块
namespace Blog\MessageBoard;

class Comment { }

//调用当前空间的类
$comment = new Comment();

//调用Blog\Article空间的类
$article_comment = new \Blog\Article\Comment();
?>

Außerdem können Unter-Namespaces über viele Ebenen hinweg definiert werden, zum Beispiel:Blog\Article\Archives\Date

Globaler Raum

Ich habe eine Skriptdatei common_inc.php mit einigen nützlichen Funktionen und Klassen darin:

<?php
function getIP() { }
class FilterXSS { }
?>

Wenn dieses Skript innerhalb eines Namensraums eingebunden wird, gehören die Elemente im Skript nicht zu diesem Namensraum. Wenn das Skript keine anderen Namensräume definiert, bleiben seine Elemente immer im globalen Namensraum:

<?php
namespace Blog\Article;

//引入脚本文件
include './common_inc.php';
$filter_XSS = new FilterXSS(); //出现致命错误:找不到Blog\Article\FilterXSS类
$filter_XSS = new \FilterXSS(); //正确
?>

Um Elemente im globalen Namensraum aufzurufen, fügen Sie einfach \ vor dem Elementnamen hinzu; andernfalls denkt der PHP-Parser, dass Sie ein Element im aktuellen Namensraum aufrufen möchten. Neben benutzerdefinierten Elementen gehören auch die integrierten Elemente von PHP zum globalen Namensraum.

Es ist erwähnenswert, dass Funktionen und Konstanten im globalen Namensraum tatsächlich nicht mit dem Backslash versehen werden müssen\und trotzdem normal aufgerufen werden können (ich verstehe nicht, warum PHP das so macht), aber um Elemente korrekt zu unterscheiden, ist es dennoch empfehlenswert, ihn beim Aufrufen von Funktionen hinzuzufügen.\

Terminologie der Namen

Bevor Sie Aliase und Importe besprechen, müssen Sie die Terminologie der drei Arten von Namen in Bezug auf Namensräume kennen und wissen, wie PHP sie auflöst. Die offizielle Dokumentation erklärt dies sehr gut, daher verwende ich sie direkt.

  • 1. Unqualifizierte Namen, oder Klassennamen ohne Präfix, zum Beispiel $comment = new Comment();. Wenn der aktuelle Namensraum Blog\Article ist, wird Comment als Blog\Article\Comment aufgelöst. Wenn der Code, der Comment verwendet, in keinem Namensraum enthalten ist (im globalen Namensraum), dann wird Comment als Comment aufgelöst.
  • 2. Qualifizierte Namen, oder Namen mit einem Präfix, zum Beispiel $comment = new Article\Comment();. Wenn der aktuelle Namensraum Blog ist, dann wird Comment als Blog\Article\Comment aufgelöst. Wenn der Code, der Comment verwendet, in keinem Namensraum enthalten ist (im globalen Namensraum), dann wird Comment als Comment aufgelöst.
  • 3. Vollqualifizierte Namen, oder Namen, die den globalen Präfixoperator enthalten, zum Beispiel $comment = new \Article\Comment();. In diesem Fall wird Comment immer als der wörtliche Name im Code aufgelöst, Article\Comment.

Tatsächlich kann man diese drei Arten von Namen mit einem Dateinamen (z. B. comment.php), einem relativen Pfadnamen (z. B. ./article/comment.php) und einem absoluten Pfadnamen (z. B. /blog/article/comment.php) vergleichen, was sie möglicherweise leichter verständlich macht.

Ich habe mehrere Beispiele verwendet, um sie zu veranschaulichen:

<?php
//创建空间Blog
namespace Blog;

class Comment { }

//非限定名称,表示当前Blog空间
//这个调用将被解析成 Blog\Comment();
$blog_comment = new Comment();

//限定名称,表示相对于Blog空间
//这个调用将被解析成 Blog\Article\Comment();
$article_comment = new Article\Comment(); //类前面没有反斜杆\

//完全限定名称,表示绝对于Blog空间
//这个调用将被解析成 Blog\Comment();
$article_comment = new \Blog\Comment(); //类前面有反斜杆\

//完全限定名称,表示绝对于Blog空间
//这个调用将被解析成 Blog\Article\Comment();
$article_comment = new \Blog\Article\Comment(); //类前面有反斜杆\


//创建Blog的子空间Article
namespace Blog\Article;

class Comment { }
?>

Tatsächlich habe ich die ganze Zeit unqualifizierte Namen und vollqualifizierte Namen verwendet; jetzt können sie endlich mit ihren richtigen Namen bezeichnet werden.

Aliase und Importe

Aliase und Importe können als Abkürzung für den Aufruf von Namespace-Elementen angesehen werden. PHP unterstützt das Importieren von Funktionen oder Konstanten nicht.

Beide werden über den use-Operator implementiert:

<?php
namespace Blog\Article;

class Comment { }


//创建一个BBS空间(我有打算开个论坛)
namespace BBS;

//导入一个命名空间
use Blog\Article;
//导入命名空间后可使用限定名称调用元素
$article_comment = new Article\Comment();

//为命名空间使用别名
use Blog\Article as Arte;
//使用别名代替空间名
$article_comment = new Arte\Comment();

//导入一个类
use Blog\Article\Comment;
//导入类后可使用非限定名称调用元素
$article_comment = new Comment();

//为类使用别名
use Blog\Article\Comment as Comt;
//使用别名代替空间名
$article_comment = new Comt();
?>

Mir ist aufgefallen – was würde passieren, wenn beim Importieren eines Elements der aktuelle Namensraum ein Element mit demselben Namen enthält? Offensichtlich wäre das Ergebnis ein fataler Fehler.

<?php
namespace Blog\Article;

class Comment { }


namespace BBS;

class Comment { }

Class Comt { }


//导入一个类
use Blog\Article\Comment;
$article_comment = new Comment(); //与当前空间的Comment发生冲突,程序产生致命错误

//为类使用别名
use Blog\Article\Comment as Comt;
$article_comment = new Comt(); //与当前空间的Comt发生冲突,程序产生致命错误
?>

Dynamischer Aufruf

PHP stellt das Schlüsselwort namespace und die magische Konstante __NAMESPACE__ für den dynamischen Zugriff auf Elemente bereit. __NAMESPACE__ kann durch Kombinieren von Zeichenketten für den dynamischen Zugriff verwendet werden:

<?php
namespace Blog\Article;

const PATH = '/Blog/article';

class Comment { }


//namespace关键字表示当前空间
echo namespace\PATH; ///Blog/article
$comment = new namespace\Comment();

//魔法常量__NAMESPACE__的值是当前空间名称
echo __NAMESPACE__; //Blog\Article
//可以组合成字符串并调用
$comment_class_name = __NAMESPACE__ . '\Comment';
$comment = new $comment_class_name();
?>

Probleme beim Aufruf in Zeichenkettenform

Im obigen Beispiel für den dynamischen Aufruf haben wir eine dynamische Aufrufmethode in Zeichenkettenform gesehen. Wenn Sie diesen Ansatz verwenden möchten, sind zwei Punkte zu beachten.

1. Bei der Verwendung von doppelten Anführungszeichen können Sonderzeichen maskiert werden.

<?php
namespace Blog\Article;

class name { }

//我是想调用Blog\Article\name
$class_name = __NAMESPACE__ . "\name"; //但是\n将被转义为换行符

$name = new $class_name(); //发生致命错误
?>

2. Es wird nicht als qualifizierter Name betrachtet.

PHP bestimmt den Raum, in dem ein Element sich befindet, sowie die Import-Situation, beim Kompilieren des Skripts. Beim Parsen des Skripts können Aufrufe in String-Form jedoch nur als unqualifizierte Namen oder vollqualifizierte Namen betrachtet werden und können niemals qualifizierte Namen sein.

<?php
namespace Blog;

//导入Common类
use Blog\Article\Common;
//我想使用非限定名称调用Blog\Article\Common
$common_class_name = 'Common';
//实际会被当作非限定名称,也就表示当前空间的Common类,但我当前类没有创建Common类
$common = new $common_class_name(); //发生致命错误:Common类不存在

//我想使用限定名称调用Blog\Article\Common
$common_class_name = 'Article\Common';
//实际会被当作完全限定名称,也就表示Article空间下的Common类,但我下面只定义了Blog\Article空间而不是Article空间
$common = new $common_class_name(); //发生致命错误:Article\Common类不存在


namespace Blog\Article;

class Common { }
?>

Zusammenfassung

Ich habe gerade erst angefangen, etwas über PHP-Namespaces zu lernen, daher kann ich nicht einfach ungeprüfte Ratschläge geben. Persönlich denke ich, dass Namespaces sowohl in ihrer Rolle als auch in ihrer Funktionalität sehr mächtig sind; beim Schreiben von Plugins oder Allzweckbibliotheken muss man sich keine Gedanken mehr über doppelte Namen machen. Wenn ein Projekt jedoch bereits einen gewissen Fortschritt erreicht hat und Sie das Problem doppelter Namen durch das Hinzufügen von Namespaces lösen müssen, denke ich, dass der Aufwand nicht geringer sein wird als das Umbenennen von Namen. Ich muss auch zugeben, dass seine Syntax einem Projekt eine gewisse Komplexität verleiht, daher sollte es von Anfang an gut geplant und eine Namenskonvention festgelegt werden.

Original-URL: https://www.cnblogs.com/kuyuecs/p/3556421.html