Uno de los propósitos más claros de los espacios de nombres es resolver el problema de los nombres duplicados. En PHP no se permite que dos funciones o clases tengan el mismo nombre, de lo contrario se produce un error fatal. En este caso, basta con evitar la duplicación de nombres para resolverlo; la práctica más común es acordar un prefijo.
Ejemplo: el proyecto tiene dos módulos: article y message board, cada uno con una clase Comment que maneja los mensajes de los usuarios. Después, puede que quiera añadir funciones de estadísticas para todos los mensajes de los usuarios, como obtener el número total de mensajes. En ese caso, llamar a los métodos proporcionados por sus clases Comment sería una buena práctica, pero introducir ambas clases Comment a la vez claramente no es posible: el código fallaría, y reescribir cualquiera de las clases Comment en otro lugar también reduciría la mantenibilidad. Entonces solo queda refactorizar los nombres de las clases. Acordé una regla de nomenclatura: anteponer el nombre del módulo al nombre de la clase, así: Article_Comment, MessageBoard_Comment
Se puede ver que los nombres se vuelven muy largos, lo que significa que al usar Comment en el futuro se escribirá más código (al menos más caracteres). Además, si más adelante se quieren añadir más funciones de integración entre los módulos, o hacer llamadas mutuas, cuando ocurran colisiones de nombres habrá que refactorizar los nombres. Por supuesto, si se presta atención a este problema al inicio del proyecto y se establecen reglas de nomenclatura, se puede evitar bien este problema. Otra solución es considerar el uso de espacios de nombres.
Nota:Constantes mencionadas en este artículo: desde PHP 5.3, la palabra clave const se puede usar fuera de las clases. Tanto const como define se utilizan para declarar constantes (no entraré en detalle sobre sus diferencias), pero en los espacios de nombres, define tiene un efecto global, mientras que const actúa sobre el espacio actual. Las constantes que menciono en el artículo se refieren a las declaradas con const.
Conceptos básicos
Los espacios de nombres dividen el código en diferentes espacios (regiones). Los nombres de las constantes, funciones y clases (por pereza, en adelante las llamaré "elementos") de cada espacio no se afectan entre sí. Esto es algo similar al concepto de "encapsulamiento" que solemos mencionar.
Para crear un espacio de nombres se necesita usar la palabra clave namespace, así:
<?php //创建一个名为'Article'的命名空间 namespace Article; ?>
Hay que tener en cuenta que no puede haber ningún código antes del primer espacio de nombres en el archivo de script actual. Las siguientes formas de escritura son incorrectas:
Ejemplo 1
//在脚本前面写了一些逻辑代码
<?php
$path = "/";
class Comment { }
namespace Article;
?>
Ejemplo 2
</html> <?php namespace Article; ?>
¿Por qué mencionar el primer espacio de nombres? Porque se pueden crear múltiples espacios de nombres en el mismo archivo de script.
A continuación creo dos espacios de nombres y, de paso, añado un elemento de clase Comment a cada uno de los dos espacios:
<?php
//创建一个名为'Article'的命名空间
namespace Article;
//此Comment属于Article空间的元素
class Comment { }
//创建一个名为'MessageBoard'的命名空间
namespace MessageBoard;
//此Comment属于MessageBoard空间的元素
class Comment { }
?>
No se pueden llamar directamente a elementos de otros espacios; es necesario usar la sintaxis de espacios de nombres:
<?php
namespace Article;
class Comment { }
namespace MessageBoard;
class Comment { }
//调用当前空间(MessageBoard)的Comment类
$comment = new Comment();
//调用Article空间的Comment类
$article_comment = new \Article\Comment();
?>
Se puede ver que, al llamar a la clase Comment del espacio article desde el espacio MessageBoard, se usa una sintaxis similar a una ruta de archivo:\NombreDelEspacio\NombreDelElemento
Además de las clases, el uso es el mismo para funciones y constantes. A continuación creo nuevos elementos para los dos espacios y muestro sus valores en el espacio 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();
?>
Y efectivamente obtuve los datos de los elementos del espacio Article.
Subespacios
La sintaxis de llamada de los espacios de nombres, similar a las rutas de archivo, tiene su razón de ser: nos permite definir subespacios personalizados para describir las relaciones entre los distintos espacios.
Disculpa, olvidé mencionar que los módulos article y message board están en realidad dentro del mismo proyecto blog. Si se usan espacios de nombres para expresar su relación, sería así:
<?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();
?>
Además, los subespacios pueden definir muchos niveles, por ejemplo:Blog\Article\Archives\Date
Espacio global
Tengo un archivo de script common_inc.php que contiene algunas funciones y clases útiles:
<?php
function getIP() { }
class FilterXSS { }
?>
Si se incluye este script dentro de un espacio de nombres, los elementos del script no pertenecerán a este espacio de nombres. Si el script no define otros espacios de nombres, sus elementos estarán siempre en el espacio global:
<?php namespace Blog\Article; //引入脚本文件 include './common_inc.php'; $filter_XSS = new FilterXSS(); //出现致命错误:找不到Blog\Article\FilterXSS类 $filter_XSS = new \FilterXSS(); //正确 ?>
La forma de llamar al espacio global es añadir \ directamente delante del nombre del elemento; de lo contrario, el analizador de PHP considerará que quiero llamar a un elemento del espacio actual. Además de los elementos personalizados, los elementos integrados de PHP también pertenecen al espacio global.
Cabe mencionar que, en realidad, las funciones y constantes del espacio global no necesitan llevar\para poder llamarse con normalidad (no entiendo por qué PHP hace esto), pero para distinguir correctamente los elementos, se recomienda añadirlo al llamar a funciones.\
Terminología de nombres
Antes de hablar de aliases e importación, es necesario conocer la terminología de los tres tipos de nombres en los espacios, y cómo los analiza PHP. La documentación oficial lo explica muy bien, así que la usaré directamente.
- 1. Nombre no cualificado, o nombre de clase sin prefijo, por ejemplo $comment = new Comment();. Si el espacio de nombres actual es Blog\Article, Comment se resolverá como Blog\Article\Comment. Si el código que usa Comment no está incluido en ningún espacio de nombres (espacio global), Comment se resolverá como Comment.
- 2. Nombre cualificado, o nombre con prefijo, por ejemplo $comment = new Article\Comment();. Si el espacio de nombres actual es Blog, Comment se resolverá como Blog\Article\Comment. Si el código que usa Comment no está incluido en ningún espacio de nombres (espacio global), Comment se resolverá como Comment.
- 3. Nombre totalmente cualificado, o nombre que incluye el operador de prefijo global, por ejemplo $comment = new \Article\Comment();. En este caso, Comment siempre se resuelve como el nombre literal Article\Comment del código.
En realidad, se pueden comparar estos tres tipos de nombres con un nombre de archivo (por ejemplo comment.php), una ruta relativa (por ejemplo ./article/comment.php) y una ruta absoluta (por ejemplo /blog/article/comment.php), lo que puede facilitar la comprensión.
He usado algunos ejemplos para representarlos:
<?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 realidad, ya había estado usando nombres no cualificados y nombres totalmente cualificados; ahora por fin se les puede llamar por su nombre.
Aliases e importación
Los aliases y la importación pueden verse como un atajo para llamar a elementos de espacios de nombres. PHP no admite la importación de funciones o constantes.
Ambos se implementan mediante el operador 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();
?>
Nótese: ¿qué sucedería si, al importar un elemento, el espacio actual tiene un elemento con el mismo nombre? Evidentemente, el resultado sería un error fatal.
<?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发生冲突,程序产生致命错误
?>
Llamadas dinámicas
PHP proporciona la palabra clave namespace y la constante mágica __NAMESPACE__ para acceder dinámicamente a los elementos. __NAMESPACE__ se puede usar para acceder dinámicamente mediante la combinación de cadenas:
<?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();
?>
Problemas con las llamadas en forma de cadena
En el ejemplo de llamada dinámica anterior, hemos visto la forma de llamada dinámica mediante cadenas. Si se quiere usar este método, hay que tener en cuenta dos problemas.
1. Al usar comillas dobles, los caracteres especiales pueden escaparse
<?php
namespace Blog\Article;
class name { }
//我是想调用Blog\Article\name
$class_name = __NAMESPACE__ . "\name"; //但是\n将被转义为换行符
$name = new $class_name(); //发生致命错误
?>
2. No se considerará como nombre cualificado
PHP determina el espacio al que pertenecen los elementos y las importaciones en el momento de compilar el script. Sin embargo, al analizar el script, las llamadas en forma de cadena solo pueden considerarse nombres no cualificados o nombres totalmente cualificados, pero nunca nombres cualificados.
<?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 { }
?>
Resumen
Acabo de empezar con los espacios de nombres de PHP, así que no puedo dar consejos a la ligera sin haberlos puesto en práctica. Personalmente creo que la utilidad y las funciones de los espacios de nombres son muy potentes; al escribir plugins o bibliotecas de uso general, ya no hay que preocuparse por los nombres duplicados. Sin embargo, si el proyecto ya tiene cierto avance y se quieren añadir espacios de nombres para resolver colisiones de nombres, creo que el trabajo no será menor que el de refactorizar los nombres. Tampoco se puede negar que su sintaxis añade cierta complejidad al proyecto, por lo que desde el inicio del proyecto se debe planificar bien y establecer una convención de nomenclatura.
Dirección original: https://www.cnblogs.com/kuyuecs/p/3556421.html