Maison >développement back-end >tutoriel php >PHP - introduction détaillée à l'utilisation des espaces de noms
PHP - introduction détaillée à l'utilisation des espaces de noms
- 王林avant
- 2019-08-28 16:01:422198parcourir
Pour les espaces de noms, les documents officiels l'ont expliqué en détail [Voir ]. J'ai fait quelques exercices et un résumé ici.
L'un des objectifs les plus clairs des espaces de noms est de résoudre le problème des noms en double. PHP ne permet pas à deux fonctions ou classes d'avoir le même nom, sinon une erreur fatale se produira. Dans ce cas, le problème peut être résolu à condition d'éviter la duplication de nom. La méthode la plus courante consiste à se mettre d'accord sur un préfixe.
Exemple : Il y a deux modules dans le projet : article et forum de messages. Chacun d'eux a une classe Comment qui gère les commentaires des utilisateurs. Plus tard, je souhaiterai peut-être ajouter des fonctions de statistiques d'informations pour tous les messages utilisateur. Par exemple, je souhaite obtenir le nombre de tous les messages. Pour le moment, c'est une bonne idée d'appeler les méthodes fournies par leurs commentaires, mais il n'est évidemment pas possible d'introduire leurs classes de commentaires respectives en même temps. Le code fera des erreurs, et la réécriture de n'importe quel commentaire à un autre endroit le fera également. réduire la maintenabilité. Pour le moment, je ne peux que reconstruire le nom de la classe. J'ai convenu d'une règle de dénomination, en ajoutant le nom du module devant le nom de la classe, comme ceci : Article_Comment, MessageBoard_Comment
Comme vous pouvez le voir, le nom devient très long, ce qui signifie que lorsque j'utiliserai Comment à l'avenir, j'écrirai plus de code (au moins plus de caractères). De plus, si vous souhaitez ajouter plus de fonctions d'intégration à chaque module à l'avenir, ou vous appeler mutuellement, vous devrez reconstruire les noms lorsque des noms en double apparaissent. Bien entendu, ce problème peut être évité en remarquant ce problème au début du projet et en spécifiant des règles de dénomination. Une autre solution pourrait consister à utiliser des espaces de noms.
Remarque :
Constantes mentionnées dans cet article : À partir de PHP5.3, le mot-clé const peut être utilisé en dehors de la classe. Const et Defin sont utilisés pour déclarer des constantes (leurs différences ne sont pas détaillées), mais dans un espace de noms, Defin agit globalement, tandis que const agit sur l'espace actuel. Les constantes que j'ai mentionnées dans l'article font référence à des constantes déclarées à l'aide de const.
Bases :
L'espace de noms divise le code en différents espaces (zones) et les constantes, fonctions et classes de chaque espace (pour être paresseux, (Ils sont appelés éléments ci-dessous) et leurs noms n'ont aucune influence les uns sur les autres. Cela ressemble un peu au concept d'« encapsulation » que l'on évoque souvent.
Pour créer un espace de noms, vous devez utiliser le mot-clé namespace
Le code est le suivant :
<?php //创建一个名为'Article'的命名空间 namespace Article; ?>
A noter qu'il ne peut y avoir de code devant le premier espace de noms du fichier de script actuel, les méthodes d'écriture suivantes sont erronées :
Le code est le suivant :
//在脚本前面写了一些逻辑代码
<?php
$path = "/";
class Comment { }
namespace Article;
?> ou comme suit :
//在脚本前面输出了一些字符 <html></html> <?php namespace Article; ?>
Pourquoi dit-on 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 ajouté un élément de classe Comment à chacun de ces deux espaces :
Le code est le suivant :
<?php
//创建一个名为'Article'的命名空间
namespace Article;
//此Comment属于Article空间的元素
class Comment { }
//创建一个名为'MessageBoard'的命名空间
namespace MessageBoard;
//此Comment属于MessageBoard空间的元素
class Comment { }
?>entre différents espaces Vous ne pouvez pas appeler directement d'autres éléments. Vous devez utiliser la syntaxe de l'espace de noms :
Le code est le suivant :
<?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 dans l'espace article dans l'espace MessageBoard, un Une syntaxe comme un chemin de fichier : Nom de l'espace Nom de l'élément
À l'exception des classes, l'utilisation des fonctions et des constantes est la même. Ci-dessous, je crée de nouveaux éléments pour les deux espaces et les affiche dans l'espace MessageBoard. .
Le code est le suivant :
<?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();
?>Sous-espace :
Il est logique que la syntaxe d'appel de l'espace de noms soit comme un chemin de fichier, elle nous permet pour personnaliser Les sous-espaces sont utilisés pour décrire les relations entre les espaces.
Désolé, j'ai oublié de mentionner que les deux modules article et message board sont en fait dans le même projet de blog. Si vous utilisez des espaces de noms pour exprimer leurs relations
<?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();
?>Espace public :
J'ai un fichier de script common_inc.php avec quelques fonctions utiles et une classe :
<?php
function getIP() { }
class FilterXSS { }
?>introduit ce script dans un espace de noms, et les éléments du script n'appartiendront pas à cet espace de noms. Si aucun autre espace de noms n'est défini dans ce script, ses éléments seront toujours dans l'espace public :
<?php namespace Blog\Article; //引入脚本文件 include './common_inc.php'; $filter_XSS = new FilterXSS(); //出现致命错误：找不到Blog\Article\FilterXSS类 $filter_XSS = new \FilterXSS(); //正确 ?>
La façon d'appeler l'espace public est de l'ajouter directement devant le nom de l'élément, sinon l'analyseur PHP penserai que je veux appeler l'élément sous l'espace actuel. En plus des éléments personnalisés, il y a aussi des éléments fournis avec PHP, qui appartiennent tous à l'espace public
Je dois mentionner qu'en fait, les fonctions et constantes de l'espace public peuvent être appelées normalement sans les ajouter (Je ne comprends pas pourquoi PHP fait ça) , mais afin de bien distinguer les éléments, il est recommandé d'ajouter
lors de l'appel de la fonction 3. Termes de nom
Avant de parler d'alias et importe, vous devez connaître les termes des trois noms d'espaces, ainsi que PHP Comment les analyser. La documentation officielle était très bonne, alors je l'ai simplement utilisée.
1.非限定名称，或不包含前缀的类名称，例如 $comment = new Comment();。如果当前命名空间是Blog\Article，Comment将被解析为Blog\Article\Comment。如果使用Comment的代码不包含在任何命名空间中的代码（全局空间中），则Comment会被解析为Comment。
2.限定名称，或包含前缀的名称，例如 $comment = new Article\Comment();。如果当前的命名空间是Blog，则Comment会被解析为Blog\Article\Comment。如果使用Comment的代码不包含在任何命名空间中的代码（全局空间中），则Comment会被解析为Comment。
3.完全限定名称，或包含了全局前缀操作符的名称，例如 $comment = new \Article\Comment();。在这种情况下，Comment总是被解析为代码中的文字名(literal name)Article\Comment。
其实可以把这三种名称类比为文件名（例如 comment.php）、相对路径名（例如 ./article/comment.php）、绝对路径名（例如 /blog/article/comment.php），这样可能会更容易理解。
我用了几个示例来表示它们：
<?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 { }
?>别名和导入
别名和导入可以看作是调用命名空间元素的一种快捷方式。PHP并不支持导入函数或常量。
它们都是通过使用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();
?>我注意到，如果导入元素的时候，当前空间有相同的名字元素将会怎样？显然结果会发生致命错误。
<?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发生冲突，程序产生致命错误
?>动态调用
PHP提供了namespace关键字和__NAMESPACE__魔法常量动态的访问元素，__NAMESPACE__可以通过组合字符串的形式来动态访问
<?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();
?>字符串形式调用问题：
上面的动态调用的例子中，我们看到了字符串形式的动态调用方式，如果要使用这种方式要注意两个问题
1、使用""时特殊字符可能被转义
<?php
namespace Blog\Article;
class name { }
//我是想调用Blog\Article\name
$class_name = __NAMESPACE__ . "\name"; //但是\n将被转义为换行符
$name = new $class_name(); //发生致命错误
?>2、不会认为是限定名称
PHP在编译脚本的时候就确定了元素所在的空间，以及导入的情况。而在解析脚本时字符串形式调用只能认为是非限定名称和完全限定名称，而永远不可能是限定名称
<?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 { }
?>总结
我对PHP的命名空间刚刚接触，也不能随便给一些没有实践的建议。我个人认为命名空间的作用和功能都很强大，如果要写插件或者通用库的时候再也不用担心重名问题。不过如果项目进行到一定程度，要通过增加命名空间去解决重名问题，我觉得工作量不会比重构名字少。也不得不承认它的语法会对项目增加一定的复杂度，因此从项目一开始的时候就应该很好的规划它，并制定一个命名规范。
更多相关问题请访问PHP中文网：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!