La fonction la plus évidente des espaces de noms est de résoudre le problème des noms en double. PHP ne permet pas que deux fonctions ou classes aient le même nom ; sinon, une erreur fatale se produira. Dans ce cas, le problème peut être résolu en évitant simplement les noms en double, et l'une des approches les plus courantes consiste à convenir d'un préfixe.
Exemple : le projet comporte deux modules : article et forum, et chacun possède une classe Comment qui gère les messages des utilisateurs. Plus tard, je pourrais vouloir ajouter des fonctionnalités de statistiques pour tous les messages des utilisateurs, comme obtenir le nombre total de messages. À ce stade, ce serait une bonne approche d'appeler les méthodes fournies par leurs classes Comment, mais inclure les deux classes Comment en même temps n'est manifestement pas acceptable — le code produira une erreur. Réécrire l'une ou l'autre des classes Comment ailleurs réduirait également la maintenabilité. Dans ce cas, la seule option est de refactoriser les noms de classes. J'ai convenu d'une règle de nommage : ajouter le nom du module au début du nom de classe, comme ceci : Article_Comment, MessageBoard_Comment.
Comme vous pouvez le voir, les noms deviennent très longs, ce qui signifie que davantage de code devra être écrit lors de l'utilisation de Comment par la suite (au moins davantage de caractères). De plus, si d'autres fonctionnalités d'intégration sont ajoutées aux modules à l'avenir, ou si les modules s'appellent mutuellement, les noms devront être refactorisés chaque fois que des doublons se produisent. Bien sûr, remarquer ce problème au début du projet et spécifier des règles de nommage peut l'éviter efficacement. Une autre solution consiste à envisager d'utiliser des espaces de noms.
Remarque :Constantes mentionnées dans cet article : à partir de PHP 5.3, le mot-clé const peut être utilisé en dehors des classes. const et define servent tous deux à déclarer des constantes (leurs différences ne sont pas détaillées ici), mais dans un espace de noms, define a une portée globale, tandis que const s'applique à l'espace courant. Les constantes que je mentionne dans cet article désignent les constantes déclarées à l'aide de const.
Bases
Les espaces de noms divisent le code en différents espaces (régions). Les noms des constantes, des fonctions et des classes (par paresse, je les appellerai « éléments » ci-dessous) dans chaque espace ne s'affectent pas mutuellement. Cela ressemble quelque peu au concept d'« encapsulation » que nous mentionnons souvent.
Pour créer un espace de noms, vous devez utiliser le mot-clé namespace, comme ceci :
<?php //创建一个名为'Article'的命名空间 namespace Article; ?>
Notez qu'il ne peut y avoir aucun code avant le premier espace de noms dans le fichier de script actuel. Les utilisations suivantes sont toutes incorrectes :
Exemple 1
//在脚本前面写了一些逻辑代码
<?php
$path = "/";
class Comment { }
namespace Article;
?>
Exemple 2
</html> <?php namespace Article; ?>
Pourquoi mentionner le premier espace de noms ? Parce que plusieurs espaces de noms peuvent être créés dans le même fichier de script.
Ci-dessous, j'ai créé deux espaces de noms et, au passage, ajouté un élément de classe Comment à chaque espace :
<?php
//创建一个名为'Article'的命名空间
namespace Article;
//此Comment属于Article空间的元素
class Comment { }
//创建一个名为'MessageBoard'的命名空间
namespace MessageBoard;
//此Comment属于MessageBoard空间的元素
class Comment { }
?>
Les éléments de différents espaces ne peuvent pas être appelés directement entre eux ; il faut utiliser la syntaxe des espaces de noms :
<?php
namespace Article;
class Comment { }
namespace MessageBoard;
class Comment { }
//调用当前空间(MessageBoard)的Comment类
$comment = new Comment();
//调用Article空间的Comment类
$article_comment = new \Article\Comment();
?>
Comme vous pouvez le voir, lors de l'appel de la classe Comment de l'espace Article depuis l'espace MessageBoard, une syntaxe semblable à un chemin de fichier est utilisée :\nom de l'espace de noms\nom de l'élément
En dehors des classes, l'utilisation est la même pour les fonctions et les constantes. Ci-dessous, j'ai créé de nouveaux éléments pour les deux espaces et affiché leurs valeurs dans l'espace MessageBoard.
<?php
namespace Article;
const PATH = '/article';
function getCommentTotal() {
return 100;
}
class Comment { }
namespace MessageBoard;
const PATH = '/message_board';
function getCommentTotal() {
return 300;
}
class Comment { }
//调用当前空间的常量、函数和类
echo PATH; ///message_board
echo getCommentTotal(); //300
$comment = new Comment();
//调用Article空间的常量、函数和类
echo \Article\PATH; ///article
echo \Article\getCommentTotal(); //100
$article_comment = new \Article\Comment();
?>
Et effectivement, j'ai obtenu les données des éléments depuis l'espace Article.
Sous-espaces de noms
Il est logique que la syntaxe d'appel des espaces de noms ressemble à un chemin de fichier ; elle nous permet de définir des sous-espaces de noms pour décrire les relations entre les différents espaces.
Désolé, j'ai oublié de mentionner que les modules Article et MessageBoard font en réalité tous deux partie du même projet de blog. Si nous utilisons des espaces de noms pour exprimer leur relation, cela ressemble à ceci :
<?php
//我用这样的命名空间表示处于blog下的article模块
namespace Blog\Article;
class Comment { }
//我用这样的命名空间表示处于blog下的message board模块
namespace Blog\MessageBoard;
class Comment { }
//调用当前空间的类
$comment = new Comment();
//调用Blog\Article空间的类
$article_comment = new \Blog\Article\Comment();
?>
De plus, les sous-espaces de noms peuvent être définis sur de nombreux niveaux, par exemple :Blog\Article\Archives\Date
Espace global
J'ai un fichier de script common_inc.php contenant quelques fonctions et classes utiles :
<?php
function getIP() { }
class FilterXSS { }
?>
Si ce script est inclus dans un espace de noms, les éléments du script n'appartiendront pas à cet espace de noms. Si le script ne définit aucun autre espace de noms, ses éléments resteront toujours dans l'espace global :
<?php namespace Blog\Article; //引入脚本文件 include './common_inc.php'; $filter_XSS = new FilterXSS(); //出现致命错误:找不到Blog\Article\FilterXSS类 $filter_XSS = new \FilterXSS(); //正确 ?>
Pour appeler des éléments de l'espace global, ajoutez simplement \ devant le nom de l'élément ; sinon, l'analyseur PHP pensera que vous voulez appeler un élément de l'espace courant. En plus des éléments personnalisés, les éléments intégrés de PHP appartiennent également à l'espace global.
Il convient de mentionner que, en fait, les fonctions et constantes dans l'espace global n'ont pas besoin de l'antislash ajouté\et peuvent toujours être appelées normalement (je ne comprends pas pourquoi PHP fait cela), mais afin de distinguer correctement les éléments, il est toujours recommandé de l'ajouter lors de l'appel de fonctions.\
Terminologie des noms
Avant de discuter des alias et des imports, vous devez connaître la terminologie des trois types de noms concernant les espaces, et comment PHP les résout. La documentation officielle l'explique très bien, je vais donc l'utiliser directement.
- 1. Noms non qualifiés, ou noms de classe sans préfixe, par exemple $comment = new Comment();. Si l'espace de noms actuel est Blog\Article, Comment sera résolu comme Blog\Article\Comment. Si le code utilisant Comment n'est contenu dans aucun espace de noms (dans l'espace global), alors Comment sera résolu comme Comment.
- 2. Noms qualifiés, ou noms avec un préfixe, par exemple $comment = new Article\Comment();. Si l'espace de noms actuel est Blog, alors Comment sera résolu comme Blog\Article\Comment. Si le code utilisant Comment n'est contenu dans aucun espace de noms (dans l'espace global), alors Comment sera résolu comme Comment.
- 3. Noms pleinement qualifiés, ou noms qui incluent l'opérateur de préfixe global, par exemple $comment = new \Article\Comment();. Dans ce cas, Comment est toujours résolu comme le nom littéral dans le code, Article\Comment.
En fait, vous pouvez comparer ces trois types de noms à un nom de fichier (par exemple, comment.php), un nom de chemin relatif (par exemple, ./article/comment.php) et un nom de chemin absolu (par exemple, /blog/article/comment.php), ce qui peut les rendre plus faciles à comprendre.
J'ai utilisé plusieurs exemples pour les illustrer :
<?php
//创建空间Blog
namespace Blog;
class Comment { }
//非限定名称,表示当前Blog空间
//这个调用将被解析成 Blog\Comment();
$blog_comment = new Comment();
//限定名称,表示相对于Blog空间
//这个调用将被解析成 Blog\Article\Comment();
$article_comment = new Article\Comment(); //类前面没有反斜杆\
//完全限定名称,表示绝对于Blog空间
//这个调用将被解析成 Blog\Comment();
$article_comment = new \Blog\Comment(); //类前面有反斜杆\
//完全限定名称,表示绝对于Blog空间
//这个调用将被解析成 Blog\Article\Comment();
$article_comment = new \Blog\Article\Comment(); //类前面有反斜杆\
//创建Blog的子空间Article
namespace Blog\Article;
class Comment { }
?>
En fait, j'ai utilisé des noms non qualifiés et des noms pleinement qualifiés depuis le début ; ils peuvent enfin être appelés par leurs noms propres.
Alias et importations
Les alias et les importations peuvent être considérés comme un raccourci pour appeler des éléments d'espace de noms. PHP ne prend pas en charge l'importation de fonctions ou de constantes.
Les deux sont implémentés via l'opérateur use :
<?php
namespace Blog\Article;
class Comment { }
//创建一个BBS空间(我有打算开个论坛)
namespace BBS;
//导入一个命名空间
use Blog\Article;
//导入命名空间后可使用限定名称调用元素
$article_comment = new Article\Comment();
//为命名空间使用别名
use Blog\Article as Arte;
//使用别名代替空间名
$article_comment = new Arte\Comment();
//导入一个类
use Blog\Article\Comment;
//导入类后可使用非限定名称调用元素
$article_comment = new Comment();
//为类使用别名
use Blog\Article\Comment as Comt;
//使用别名代替空间名
$article_comment = new Comt();
?>
J'ai remarqué — que se passerait-il si, lors de l'importation d'un élément, l'espace actuel possède un élément du même nom ? Évidemment, le résultat serait une erreur fatale.
<?php
namespace Blog\Article;
class Comment { }
namespace BBS;
class Comment { }
Class Comt { }
//导入一个类
use Blog\Article\Comment;
$article_comment = new Comment(); //与当前空间的Comment发生冲突,程序产生致命错误
//为类使用别名
use Blog\Article\Comment as Comt;
$article_comment = new Comt(); //与当前空间的Comt发生冲突,程序产生致命错误
?>
Invocation dynamique
PHP fournit le mot-clé namespace et la constante magique __NAMESPACE__ pour accéder dynamiquement aux éléments. __NAMESPACE__ peut être utilisé pour l'accès dynamique en combinant des chaînes :
<?php
namespace Blog\Article;
const PATH = '/Blog/article';
class Comment { }
//namespace关键字表示当前空间
echo namespace\PATH; ///Blog/article
$comment = new namespace\Comment();
//魔法常量__NAMESPACE__的值是当前空间名称
echo __NAMESPACE__; //Blog\Article
//可以组合成字符串并调用
$comment_class_name = __NAMESPACE__ . '\Comment';
$comment = new $comment_class_name();
?>
Problèmes avec l'invocation sous forme de chaîne
Dans l'exemple d'invocation dynamique ci-dessus, nous avons vu une approche dynamique sous forme de chaîne. Si vous souhaitez utiliser cette approche, deux points sont à noter.
1. Lorsque vous utilisez des guillemets doubles, des caractères spéciaux peuvent être échappés.
<?php
namespace Blog\Article;
class name { }
//我是想调用Blog\Article\name
$class_name = __NAMESPACE__ . "\name"; //但是\n将被转义为换行符
$name = new $class_name(); //发生致命错误
?>
2. Il ne sera pas considéré comme un nom qualifié.
PHP détermine l'espace où réside un élément, ainsi que la situation d'importation, lors de la compilation du script. Cependant, lors de l'analyse du script, les appels sous forme de chaîne ne peuvent être considérés que comme des noms non qualifiés ou des noms pleinement qualifiés, et jamais comme des noms qualifiés.
<?php
namespace Blog;
//导入Common类
use Blog\Article\Common;
//我想使用非限定名称调用Blog\Article\Common
$common_class_name = 'Common';
//实际会被当作非限定名称,也就表示当前空间的Common类,但我当前类没有创建Common类
$common = new $common_class_name(); //发生致命错误:Common类不存在
//我想使用限定名称调用Blog\Article\Common
$common_class_name = 'Article\Common';
//实际会被当作完全限定名称,也就表示Article空间下的Common类,但我下面只定义了Blog\Article空间而不是Article空间
$common = new $common_class_name(); //发生致命错误:Article\Common类不存在
namespace Blog\Article;
class Common { }
?>
Résumé
Je viens juste de commencer à apprendre les espaces de noms PHP, je ne peux donc pas donner à la légère des conseils non vérifiés. Personnellement, je pense que les espaces de noms sont très puissants tant par leur rôle que par leur fonctionnalité ; lorsque vous écrivez des plugins ou des bibliothèques généralistes, vous n'avez plus besoin de vous soucier des noms en double. Cependant, si un projet a progressé jusqu'à un certain point et que vous devez résoudre des problèmes de noms en double en ajoutant des espaces de noms, je pense que la charge de travail ne sera pas inférieure à une refactorisation des noms. Je dois aussi admettre que sa syntaxe ajoute un certain degré de complexité à un projet, il faudrait donc bien le planifier dès le début, et établir une convention de nommage.
URL d'origine : https://www.cnblogs.com/kuyuecs/p/3556421.html