qu'est-ce que l'espace de noms php ? Explication détaillée des exemples d'utilisation d'espaces de noms

PHP commence à prendre en charge l'espace de noms dans les versions postérieures à la 5.3.0. Qu'est-ce qu'un espace de noms ? D'une manière générale, un espace de noms est une façon d'encapsuler des choses. Ce concept abstrait se retrouve à de nombreux endroits.

Présentation des espaces de noms

En PHP, les espaces de noms sont utilisés pour résoudre les problèmes rencontrés lors de la création de code réutilisable tel que des classes ou des fonctions lors de l'écriture de bibliothèques de classes ou d'applications. :

Conflits de noms entre le code écrit par l'utilisateur et les classes/fonctions/constantes internes de PHP ou les classes/fonctions/constantes tierces.
Créer un nom alias (ou court) pour un nom d'identifiant très long (généralement défini pour atténuer le premier type de problème), améliorant ainsi la lisibilité du code source.
Les espaces de noms PHP fournissent un moyen de regrouper les classes, fonctions et constantes associées. Voici un exemple illustrant la syntaxe d'un espace de noms PHP :

Définir un espace de noms

Bien que tout code PHP légal puisse être inclus dans un espace de noms, mais uniquement trois types de code sont affectés par les espaces de noms, à savoir : les classes, les fonctions et les constantes. Les espaces de noms sont déclarés à l'aide du mot-clé namespace. Si un fichier contient un espace de noms, il doit déclarer l'espace de noms avant tout autre code. De plus, contrairement aux autres fonctionnalités du langage PHP, le même espace de noms peut être défini dans plusieurs fichiers, ce qui permet de diviser et de stocker le contenu du même espace de noms dans différents fichiers. Bien entendu, vous pouvez également définir plusieurs espaces de noms dans le même fichier.

namespace MyProject;
class MyClass
{
    #code...
}

Définir des sous-espaces de noms : tout comme la relation entre les répertoires et les fichiers, les espaces de noms PHP vous permettent également de spécifier des noms d'espaces de noms hiérarchiques. Par conséquent, les noms d'espaces de noms peuvent être définis de manière hiérarchique :

namespace MyProject\helper\http;
class MyClass
{
    #code...
}

Définir plusieurs espaces de noms dans le même fichier : Il existe deux manières de déclarer plusieurs espaces de noms dans le même fichier, mais dans la pratique de programmation réelle, c'est Il est fortement déconseillé de définir l'espace de noms Dogo dans le même fichier. Cette méthode est principalement utilisée pour combiner plusieurs scripts PHP dans le même fichier. La première méthode est répertoriée ci-dessous.

namespace MyProject\helper\http;
class MyClass
{
    #code...
}
namespace MyProject\helper\request;
class MyClass
{
    #code...
}

Cependant, il est fortement déconseillé d'utiliser cette méthode. Vous pouvez vous référer à la méthode de définition d'accolade suivante :

namespace MyProject\helper\http;
{
    class MyClass
    {
        #code...
    }
}
namespace MyProject\helper\request;
{
    class MyClass
    {
        #code...
    }
}

Les éléments de l'espace de noms PHP utilisent <. 🎜>

Avant de discuter de la façon d'utiliser les espaces de noms, vous devez comprendre comment PHP sait quels éléments d'espace de noms utiliser. Les noms de classe peuvent être référencés de trois manières :

un nom non qualifié ou un nom de classe sans préfixe, tel que $a=new foo( ou foo::staticmethod();. Si l'espace de noms actuel est

currentnamespace, foo sera résolu en currentnamespacefoo. Si le code utilisant foo est global et ne contient de code dans aucun espace de noms, foo sera résolu comme foo. Avertissement : Si une fonction ou une constante dans l'espace de noms n'est pas définie, la fonction ou le nom de constante non qualifié est résolu en un nom de fonction globale ou un nom de constante. Voir Utilisation des espaces de noms : noms de fonctions globales de secours/noms de constantes pour plus de détails.

Nom qualifié, ou nom incluant un préfixe, tel que $a = new subnamespacefoo(); ou subnamespacefoo::staticmethod();. Si l'espace de noms actuel est currentnamespace, foo sera résolu en currentnamespacesubnamespacefoo. Si le code utilisant foo est global, code non contenu dans aucun espace de noms, foo sera résolu en subnamespacefoo.

nom complet, ou un nom qui inclut le préfixe global

opérateur , par exemple, $a = new currentnamespacefoo(); ou currentnamespacefoo::staticmethod();. Dans ce cas, foo est toujours résolu en nom littéral currentnamespacefoo dans le code. Utilisation d'espaces de noms : Alias/Importer

Permettre aux noms externes pleinement qualifiés d'être référencés ou importés via des alias est une fonctionnalité importante des espaces de noms. Prise en charge des espaces de noms PHP Il existe deux manières d'utiliser des alias ou des importations : en utilisant des alias pour les noms de classe ou en utilisant des alias pour les noms d'espace de noms. En PHP, les alias sont implémentés via l'utilisation de l'opérateur.

Notez que PHP ne prend pas en charge les fonctions ou constantes importées.

namespace foo;
use My\Full\Classname as Another;
// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;
// 导入一个全局类
use \ArrayObject;

Règles de résolution de nom

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

Nom non qualifié Nom non qualifié : Un identifiant qui ne contient pas de délimiteur d'espace de noms dans son nom, tel que Foo

Nom qualifié Nom qualifié : un identifiant qui contient un délimiteur d'espace de noms dans son nom, tel que FooBar
Nom complet : un nom qui contient un nom délimiteur d'espace et les identifiants qui commencent par un délimiteur d'espace de noms, tel que FooBar. namespaceFoo est également un nom pleinement qualifié.
La résolution de nom suit les règles suivantes :

对完全限定名称的函数，类和常量的调用在编译时解析。例如 new \A\B 解析为类 A\B。
所有的非限定名称和限定名称（非完全限定名称）根据当前的导入规则在编译时进行转换。例如，如果命名空间 A\B\C 被导入为 C，那么对 C\D\e() 的调用就会被转换为 A\B\C\D\e()。
在命名空间内部，所有的没有根据导入规则转换的限定名称均会在其前面加上当前的命名空间名称。例如，在命名空间 A\B 内部调用 C\D\e()，则 C\D\e() 会被转换为 A\B\C\D\e() 。
非限定类名根据当前的导入规则在编译时转换（用全名代替短的导入名称）。例如，如果命名空间 A\B\C 导入为C，则 new C() 被转换为 new A\B\C() 。
在命名空间内部（例如A\B），对非限定名称的函数调用是在运行时解析的。例如对函数 foo() 的调用是这样解析的：
1) 在当前命名空间中查找名为 A\B\foo() 的函数
2) 尝试查找并调用 全局(global) 空间中的函数 foo()。
在命名空间（例如A\B）内部对非限定名称或限定名称类（非完全限定名称）的调用是在运行时解析的。下面是调用 new C() 及 new D\E() 的解析过程： new C()的解析:
在当前命名空间中查找A\B\C类。
尝试自动装载类A\B\C。

new D\E()的解析:
在类名称前面加上当前命名空间名称变成：A\B\D\E，然后查找该类。
尝试自动装载类 A\B\D\E。

为了引用全局命名空间中的全局类，必须使用完全限定名称 new \C()。

Example 名称解析示例

<?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 détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!