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();
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". 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. 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 :
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() :
Essayez le chargement automatique de la classe ABC.
nouvelle analyse DE() :
Essayez la classe de chargement automatique ABDE.
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!