Explication détaillée de l'utilisation de l'espace de noms PHP

Cette fois, je vais vous apporter une explication détaillée de l'utilisation de espace de noms php , et quelles sont les précautions lors de l'utilisation de l'espace de noms php. Voici un cas pratique, prenons un. regarder.

1 : Concept d'espace de noms : L'espace de noms est une méthode d'encapsulation d'éléments, similaire aux répertoires et aux fichiers.

Problèmes résolus par les espaces de noms (le manuel est également écrit très clairement, et ce qui suit est simplifié selon ma propre compréhension) :

1 : Résoudre les problèmes de classes, de constantes, de fonctions et là est un conflit de nom au sein de PHP ou d'un tiers.

2 : Créez des alias pour aider à résoudre le problème des noms trop longs de classes, de constantes et de fonctions, et pour aider à améliorer la lisibilité du code. De plus, les noms trop longs sont généralement causés par l'atténuation du premier. type de problème.

2 : Comment définir un espace de noms

1 : L'espace de noms est déclaré avec le mot-clé namespace En même temps, l'espace de noms doit être situé avant tout autre code, y compris tout code non-php. et des espaces (mots clés de déclaration de php), sinon une erreur fatale sera générée.

Par exemple :

<?php 
namespace Index; 
?>

Remarque 1 : S'il n'y a pas de code ou d'espace avant l'espace de noms, mais qu'une erreur fatale se produit toujours, cela devrait être dû à l'en-tête de la nomenclature. . Supprimez simplement la bombe.
Remarque 2 : Bien que tout le code PHP légal puisse être placé sous l'espace de noms, les seules classes (classes abstraiteset traits) et interfaces, constantes et fonctions qui sont affectées par l'espace de noms le sont.

2 : 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, séparés par .

Par exemple :

<?php 
namespace Index\Col\File; 
define(&#39;MESSAGE&#39;,&#39;hello world&#39;); 
?>

3 : Plusieurs espaces de noms peuvent être définis dans un seul fichier. Il existe deux syntaxes de définition, l'une est une syntaxe de combinaison simple et l'autre est une syntaxe de forme d'accolade, <.> L'utilisation d'un autre fichier pour définir plusieurs espaces de noms est généralement un scénario dans lequel plusieurs fichiers sont fusionnés en un seul fichier, mais il est préférable de ne pas le faire sauf si cela est absolument nécessaire, car cela augmente la complexité du code et réduit la lisibilité. , il n'est généralement pas nécessaire de l'utiliser de cette manière.

Syntaxe de combinaison simple :

<?php 
namespace Index; 
const INSTANCE=1; 
 
namespace Col; 
const INSTANCE=2; 
?>

Syntaxe des accolades, un fichier a plusieurs espaces de noms, si vous devez écrire du code sans espace de noms, vous ne pouvez utiliser que la syntaxe des accolades et du code sans espace de noms utilise un espace de noms pour déclarer un espace de noms sans nom, puis utilise des accolades :

<?php 
/*命名空间Index*/ 
namespace Index{ 
  const INSTANCE=1; 
} 
 
/*命名空间Col*/ 
namespace Col{ 
  const INSTANCE=2; 
} 
 
/*全局非命名空间代码*/ 
namespace { 
  const INSTANCE=3; 
} 
?>

4 : Plusieurs fichiers différents peuvent définir le même espace de noms, c'est-à-dire le même nom. Le contenu de l'espace peut être stocké dans plusieurs fichiers différents, je ne donnerai donc pas d'exemple ici.

3 : Principe d'identification de l'espace de noms

Il existe trois situations dans lesquelles le principe d'utilisation de l'espace de noms est utilisé. Le manuel l'explique en détail, mais cela peut provoquer une certaine confusion en raison de problèmes de traduction. Je vais le simplifier et utiliser le mien. Jetons un coup d'œil aux exemples :

1 : Il n'y a pas de nom qualifié, c'est-à-dire que le nom de la classe, de la constante, de la fonction et de l'interface à lire est directement utilisé dans ce cas, la classe, la constante et l'espace de noms de l'espace de noms auquel appartient le contenu seront lus, mais s'il n'y a pas de données pertinentes dans l'espace de noms, une erreur fatale sera renvoyée si c'est le cas. un nom de classe ou d'interface. S'il s'agit d'une fonction ou d'une constante, les fonctions et constantes globales seront automatiquement lues. S'il n'y a pas de fonction ou de constante globale, une erreur fatale sera signalée.

L'exemple suivant :

<?php 
/*全局非命名空间代码*/ 
namespace { 
  const INSTANCE=1; 
 
  function test(){ 
    echo 1; 
  } 
 
  class foo{ 
    static function fool(){ 
          echo 1; 
        } 
  } 
 
  var_dump(INSTANCE);   //打印出来的是1 
 
  test();       //输出1 
 
  foo::fool();      //输出1 
 
} 
 
/*命名空间Index*/ 
namespace Index{ 
  const INSTANCE=2; 
 
  function test(){ 
    echo 2; 
  } 
 
  class foo{ 
    static function fool(){ 
          echo 2; 
        } 
  } 
 
  var_dump(INSTANCE);   //打印出来的是2 
 
  test();     //输出2 
 
  foo::fool();    //输出2 
} 
 
/*命名空间Col*/ 
namespace Col{ 
  const INSTANCE=3; 
 
  function test(){ 
    echo 3; 
  } 
 
  class foo{ 
    static function fool(){ 
          echo 3; 
        } 
  } 
 
  var_dump(INSTANCE);   //打印出来的是3 
 
  test();     //输出2 
   
  foo::fool();    //输出2 
} 
?>

Dans l'exemple ci-dessus, chaque sortie d'espace de noms n'a pas de nom qualifié, donc la valeur de données correspondante définie dans l'espace de noms actuel sera obtenue.

Si l'espace de noms actuel n'est pas défini, les fonctions et les constantes liront les valeurs de données correspondantes définies globalement. Les erreurs fatales ne seront signalées que s'il n'y a pas de paramètre global correspondant. Les classes et les interfaces signaleront directement les erreurs fatales. , comme indiqué dans le code suivant Show.

<?php 
/*全局非命名空间代码*/ 
namespace { 
  const INSTANCE=1;  
  function test(){ 
    echo 1; 
  } 
 
  class foo{ 
    static function fool(){ 
          echo 1; 
        } 
  } 
 
  var_dump(INSTANCE);   //打印出来的是1  
  test();     //输出1  
  foo::fool();    //输出1  
} 
 
/*命名空间Index*/ 
namespace Index{ 
  var_dump(INSTANCE);   //打印出来的是1  
  test();     //输出1  
  foo::fool();    //fatal error 
 
} 
?>

2 : Nom qualifié, divisé en deux situations, l'une est le cas d'un nom qualifié contenant un préfixe, et l'autre est le cas d'un nom qualifié global contenant. Le manuel sépare ces deux types séparément, mais je pense que ces deux peuvent être combinés. Ils ont tous deux des noms qualifiés, mais le premier n'a pas de qualifications globales, tandis que le second a des qualifications globales.

① Un nom qualifié contenant un préfixe. Ce préfixe peut avoir plusieurs ou un seul niveau, mais le plus à gauche ne peut pas être un qualificatif global. Dans ce cas, l'espace de noms où se trouve le code sera lu et la qualification du préfixe. sera ajoutée. Les données correspondant au nom sont :

所处命名空间\前缀限定\名称来读取，如果该代码是全局没有命名空间的，则直接用前缀限定名称来读取，也就是：前缀限定\名称来读取。

实例代码：

<?php 
/*命名空间Col\Index*/ 
namespace Col\Index{ 
  const INSTANCE=1; 
} 
 
/*命名空间Index*/ 
namespace Index{ 
  const INSTANCE=2; 
} 
 
/*命名空间Col*/ 
namespace Col{ 
  const INSTANCE=3; 
  var_dump(Index\INSTANCE); //打印出来的是1 读取的是Col\Index\INSTANCE 
} 
 
/*全局非命名空间代码*/ 
namespace { 
  const INSTANCE=4; 
  var_dump(Index\INSTANCE); //打印出来的是2 读取的是Index\INSTANCE 
} 
 
?>

②全局限定前缀名称：也就是在最左侧有全局操作符\进行修饰的前缀限定名称，当然也可以没有前缀限定直接全局操作符\加上名称也是可以的。但加上全局操作符后就跟目录里的绝对路径一样，只会按照全局限定后的所设置的进行读取。

具体实例如下：

<?php 
/*命名空间Col\Index*/ 
namespace Col\Index{ 
  const INSTANCE=1; 
} 
 
/*命名空间Index*/ 
namespace Index{ 
  const INSTANCE=2; 
} 
 
/*命名空间Col*/ 
namespace Col{ 
  const INSTANCE=3; 
  var_dump(\Index\INSTANCE); //打印出来的是2 读取的是Index\INSTANCE 
} 
 
/*全局非命名空间代码*/ 
namespace { 
  const INSTANCE=4; 
  var_dump(\Index\INSTANCE); //打印出来的是2 读取的是Index\INSTANCE 
} 
 
namespace Lin{ 
  const INSTANCE=5; 
  var_dump(\INSTANCE); //打印出来的是4 读取的是INSTANCE，是全局非命名空间里的INSTANCE，如果没有全局操作符\，读取的会是当前命名空间的Lin\INSTANCE=5 
} 
 
?>

四：命名空间在字符串中的转义

有时候命名空间会放在字符串中使用，如果是单引号不会通过编译器解释，所以没有任何问题，但是如果是双引号，那么就会有些意外情况了，要知道双引号里的内容是需要经过编译器进行解释然后再进行输出的，而\在编译器里的解释容易造成歧义。

例如"index\name"这里就有\n会被解释成换行，除此之外还有很多这种造成意外的情况。

因此一般我们推荐命名空间如果要放在字符串中使用，最好使用单引号，一是效率，二是安全，如果使用双引号，则必须增加一个\进行转义避免歧义，例如"index\\name"这样就没有问题了。

随手双引号的举个例子：

<?php 
/*全局非命名空间代码*/ 
namespace Index\Name{ 
  class foo{ 
    function construct(){ 
      echo 2; 
    } 
  } 
} 
 
namespace{ 
  $a= "Index\\Name\\foo"; //用\转义了\所以可以正常运行，但是如果去掉转义的话会报错Class 'Index\Nameoo'，因为/f被解释成了换页符 
  $obj=new $a; 
}

相信看了本文案例你已经掌握了方法，更多精彩请关注php中文网其它相关文章！

推荐阅读：

Laravel实现密码重置步骤详解

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!