Note 009 Espace de noms PHP - Partie 2

Règles de résolution de nom

Avant d'expliquer les règles de résolution de nom, examinons quelques définitions importantes :

Définition de nom d'espace de noms

Nom non qualifié

Un identifiant dont le nom ne contient pas de séparateur d'espace de noms, tel que Foo

Nom qualifié Nom qualifié

Un identifiant dont le nom contient un séparateur d'espace de noms, tel que FooBar

Nom complet

Un identifiant dont le nom contient un délimiteur d'espace de noms et commence par un délimiteur d'espace de noms, tel que FooBar. namespaceFoo est également un nom pleinement qualifié.

La résolution de noms suit les règles suivantes :

Les appels aux fonctions, classes et constantes avec des noms complets sont résolus au moment de la compilation. Par exemple, le nouveau AB se résout en classe AB.

Tous les noms non qualifiés et les noms qualifiés (noms non pleinement qualifiés) sont convertis au moment de la compilation selon les règles d'importation en vigueur. Par exemple, si l'espace de noms ABC est importé en tant que C, alors les appels à CDe() sont convertis en ABCDe().

Au sein d'un espace de noms, tous les noms qualifiés qui ne sont pas convertis conformément aux règles d'importation auront le nom actuel de l'espace de noms ajouté en préfixe. Par exemple, si CDe() est appelé dans l'espace de noms AB, CDe() sera converti en ABCDe().

Les noms de classes non qualifiés sont convertis au moment de la compilation selon les règles d'importation actuelles (les noms complets sont utilisés à la place des noms d'importation courts). Par exemple, si l'espace de noms ABC est importé en tant que C, new C() est converti en new ABC() .

Au sein d'un espace de noms (par exemple AB), les appels de fonction vers des noms non qualifiés sont résolus au moment de l'exécution. Par exemple, un appel à la fonction foo() est analysé comme ceci : 1. Recherchez une fonction nommée ABfoo() dans l'espace de noms actuel. 2. Essayez de rechercher et d'appeler la fonction foo() dans l'espace global.

Les appels à des noms non qualifiés ou à des classes de noms qualifiés (noms non pleinement qualifiés) à l'intérieur d'un espace de noms (par exemple AB) sont résolus au moment de l'exécution. Voici le processus d'analyse d'appel de new C() et new DE() :

Analyse de new C() :

Recherchez la classe ABC dans l'espace de noms actuel.

Essayez de charger automatiquement la classe ABC.

Analyse du nouveau DE() :

Ajoutez le nom de l'espace de noms actuel devant le nom de la classe pour devenir : ABDE, puis recherchez la classe.

Essayez de charger automatiquement la classe ABDE.

Afin de faire référence à une classe globale dans l'espace de noms global, le nom complet new C() doit être utilisé.

<?php
namespace A;
use B\D, C\E as F;// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()
// 再尝试调用全局函数 "foo"
\foo();     // 调用全局空间函数 "foo" 
my\foo();   // 调用定义在命名空间"A\my"中函数 "foo" 
F();        // 首先尝试调用定义在命名空间"A"中的函数 "F" 
// 再尝试调用全局函数 "F"
// 类引用
new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象
// 如果未找到，则尝试自动装载类 "A\B"
new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
// 如果未找到，则尝试自动装载类 "B\D"
new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
// 如果未找到，则尝试自动装载类 "C\E"
new \B();   // 创建定义在全局空间中的类 "B" 的一个对象
// 如果未发现，则尝试自动装载类 "B"
new \D();   // 创建定义在全局空间中的类 "D" 的一个对象
// 如果未发现，则尝试自动装载类 "D"
new \F();   // 创建定义在全局空间中的类 "F" 的一个对象
// 如果未发现，则尝试自动装载类 "F"
// 调用另一个命名空间中的静态方法或命名空间函数

B\foo();    // 调用命名空间 "A\B" 中函数 "foo"
B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
// 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"
D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
// 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"
\B\foo();   // 调用命名空间 "B" 中的函数 "foo" 
\B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法
// 如果类 "B" 未找到，则尝试自动装载类 "B"
// 当前命名空间中的静态方法或函数

A\B::foo();   // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法
// 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"
\A\B::foo();  // 调用命名空间 "A\B" 中定义的类 "B" 的 "foo" 方法
// 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>

Ce qui précède est le contenu de la note 009 PHP Namespace - Part Two Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !