Einige Gedanken zu Namespaces, einem Schlüsselmerkmal von PHP! ! !

Wussten Sie, dass Namespaces hauptsächlich dazu dienen, das Problem möglicher Konflikte zwischen Klassen und Funktionen im Code zu lösen? Diese Funktion ist in anderen Sprachen schon seit langem verfügbar, aber PHP kam erst spät auf den Markt. Sein Erscheinen brachte PSR-4 hervor, das auch den Aufstieg von Composer hervorbrachte, daher ist es eine sehr wichtige Funktion.

Definition des Namespace

Ein Namespace ist ein Container. Dieser Container wird hauptsächlich zur Identifizierung der darunter liegenden Klassen und Funktionen verwendet. 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 eine vollständige Benennung eines Paketbereichs.

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

Drei Möglichkeiten, auf Namespace-IDs zu verweisen

(1) Der vollständig qualifizierte Name

ähnelt dem absoluten Pfad im Betriebssystem und ist ein vollständiger Pfad, sodass beim Verständnis keine Missverständnisse auftreten.
Zum Beispiel wird C im neuen ABC in die C-Klasse unter dem AB-Namespace aufgelöst.

(2) Qualifizierter Name

ähnelt einem relativen Pfad im 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) Unqualifizierter Name

ähnelt dem qualifizierten Namen, enthält jedoch keine Unternamensräume.
Wenn beispielsweise C() unter dem Namespace AB aufgerufen wird, ist der endgültig referenzierte Namespace ABC().

Veranschaulichen Sie die drei Referenzmethoden 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 daher auf eine interne oder benutzerdefinierte Klasse verweisen müssen In der Klasse müssen Sie den vollständigen qualifizierten Namen verwenden.

Nehmen wir ein einfaches Beispiel: Schreiben Sie zunächst einen Codeabschnitt (definiert unter dem Namespace) 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" ;
    }
}

Dann schreiben Sie einen Codeabschnitt test.php, der ebenfalls Code unter dem Namespace ist:

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 lang und zahlreich ist, ist die Verwendung besonders problematisch. Sie können daher das Schlüsselwort use verwenden, um Namespaces, Klassen, Konstanten, Funktionen usw. zu importieren. und verwenden Sie sie dann. Geben Sie direkt den vollständigen Namen an. Das Schlüsselwort alias kann importierte Klassen und Funktionen umbenennen.

Um beispielsweise das Schlüsselwort „use“ zu verwenden, befindet sich der 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 konkret Die Position und das Layout des Codes Mit anderen Worten: Der Code, der den Namespace verwendet, muss die Bibliotheksdateien (alle Dateien) selbst importieren. Es spielt keine Rolle, wie die Bibliotheksdateien in Python organisiert sind Paket, dann importiert der Python-Parser automatisch Dateien für Pakete oder alle Module. __init__.py
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 Bereich 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.

Empfohlenes Lernen: „

PHP-Video-Tutorial“

Das obige ist der detaillierte Inhalt vonEinige Gedanken zu Namespaces, einem Schlüsselmerkmal von PHP! ! !. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!