Une brève introduction aux espaces de noms php

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. En-tête de nomenclature.
Remarque 2 : Bien que tout le code PHP légal puisse être placé sous l'espace de noms, les seules classes (classes abstraites et traits), interfaces, constantes et fonctions affectées par l'espace de noms sont affectées.

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, la. 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é en général. Cette utilisation n'est pas nécessaire.

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, mais il n'y a pas d'exemples ici.

Trois : 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. Trions les 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. dans ce cas, la classe, la constante et l'espace de noms de l'espace de noms auquel appartient le contenu seront lus. Les noms de fonction et d'interface, mais s'il n'y a pas de données pertinentes dans l'espace de noms, une erreur fatale sera renvoyée s'il s'agit d'une classe ou. nom de l'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. seront ajoutées. Les données correspondant au nom, c'est-à-dire :

sont lues en qualifiant le nom dans l'espace de noms. Si le code n'a pas d'espace de noms global, il est lu directement par qualification de préfixe. le nom, c'est-à-dire : nom qualifié par préfixe à lire.

Exemple de code :

<?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 
} 
 
?>

②Nom de préfixe qualifié global : c'est-à-dire un nom qualifié de préfixe modifié par un opérateur global à l'extrême gauche. Bien entendu, il peut également être directement exploité globalement. sans qualification de préfixe Il est également possible d'ajouter un symbole avec un nom. Mais après avoir ajouté l'opérateur global, c'est le même que le chemin absolu dans le répertoire, et ne sera lu qu'en fonction des paramètres après qualification globale.

Les exemples spécifiques sont les suivants :

<?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 
} 
 
?>

Quatre : échappement de l'espace de noms dans la chaîne

Parfois, l'espace de noms est utilisé dans la chaîne If Les guillemets simples ne le seront pas. interprété par le compilateur, donc il n'y a pas de problème, mais s'il s'agit de guillemets doubles, il y aura des situations inattendues. Vous devez savoir que le contenu entre guillemets doubles doit être interprété par le compilateur puis sorti, et dans l'interprétation. dans le compilateur peut facilement conduire à une ambiguïté.

Par exemple, n dans "indexname" sera interprété comme une nouvelle ligne. De plus, il existe de nombreuses autres situations qui provoquent des accidents.

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

随手双引号的举个例子：

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

这部分碍于篇幅就暂时到这里了，下一篇主要总结命名空间里的namespace和__NAMESPACE__的使用，以及别名的使用等。

相关推荐：

php的命名空间解读

php命名空间用法详解

简单聊聊关于jquery的事件名称与命名空间

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!