L'éditeur vous apprendra la séquence d'appel des espaces de noms

Dans l'article précédent, nous avons appris à accéder aux éléments internes de l'espace de noms. Si vous en avez besoin, veuillez lire "L'éditeur vous montrera comment accéder aux éléments internes de l'espace de noms (version php)". Cette fois nous allons vous présenter l'ordre des espaces de noms, vous pourrez vous y référer si nécessaire.

Regardons d’abord un petit exemple.

<?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" 的 "foo" 方法
              // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>

En regardant attentivement le petit exemple ci-dessus, que peut-on observer ? Dangdang, nous allons donner la réponse maintenant.

Lors de l'appel d'une fonction, si nous écrivons uniquement "foo()", la fonction dans l'espace de noms sera appelée en premier, puis la fonction globale sera appelée mais si c'est "foo() )", cela appellera uniquement la fonction globale. foo()”，先调用的命名空间中的函数，然后在调用全局函数；但如果是“foo()”，这就只调用全局函数了。

在类应用的时候，如果我们写了“new B();”，将会创建命名空间中定义的类"B"的一个对象，但如果未找到，则尝试自动装载类"AB"。

在调用另一个命名空间中的静态方法或命名空间函数的时候，如何我们写了“Bfoo()”，这表明我们将调用命名空间中的函数“foo()”；但如果写的是“B::foo();”就不一样了，他先调用命名空间中的函数“foo()”，但如果未找到，则尝试自动装载类"AB"。

在当前命名空间中的静态方法或函数的时候，如何我们写了“AB::foo();

Lors de l'application de la classe, si nous écrivons "new B();", un objet de classe "B" défini dans l'espace de noms sera créé, mais s'il n'est pas trouvé, essayez de charger automatiquement la classe "AB".

Lors de l'appel d'une méthode statique ou d'une fonction d'espace de noms dans un autre espace de noms, nous écrivons "Bfoo()", ce qui indique que nous appellerons la fonction dans l'espace de noms " foo()"; mais si vous écrivez "B::foo();" c'est différent. Il appelle d'abord la fonction "foo()" dans l'espace de noms, mais si elle n'est pas trouvée, une tentative est faite pour charger automatiquement la classe "AB".

• Lorsque nous écrivons une méthode ou une fonction statique dans l'espace de noms actuel, nous écrivons "AB::foo();", ce qui indique que nous appellerons la classe définie dans l'espace de noms "AA". La méthode "foo" de "B" charge automatiquement la classe "AAB" si elle n'est pas trouvée.
  Résumons maintenant.

• Les appels à des fonctions, classes et constantes pleinement qualifiées seront résolus au moment de la compilation. Par exemple, newaB 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().

• Tous les noms non qualifiés et 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, les appels à CDe() seront convertis en aBCDe().

• Les noms de classe non qualifiés sont convertis au moment de la compilation selon les règles d'importation actuelles (en remplaçant les noms d'importation courts par des noms complets). Par exemple, si l'espace de noms aBC est importé en tant que C, new C() sera converti en new aBC().

• Dans 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 suit :

• Trouver une fonction nommée ABfoo() dans l'espace de noms actuel

• Essayez de trouver 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) dans un espace de noms (tel que ab) sont résolus au moment de l'exécution. Voici le processus d'analyse pour appeler new c() et new de() : Analyse de new c() :

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

• Essayez le chargement automatique de la classe ABC.

• nouvelle analyse DE() :

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

• Essayez la classe de chargement automatique ABDE.

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

🎜🎜C'est tout. Si vous voulez savoir autre chose, vous pouvez cliquer ici. → →🎜Tutoriel vidéo php🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!