PHP espace de noms (namespace)

PHP espace de noms (namespace) est ajouté en PHP 5.3, si vous avez appris C # et Java, espace de noms qui ne sont pas quelque chose de nouvelles choses. Mais en PHP, qui a encore une signification très importante.

namespaces PHP peuvent résoudre les deux problèmes suivants:

Code utilisateur écrit à l'intérieur PHP classes / fonctions / constantes ou tiers nom classes / fonctions / constantes conflits entre.
Comme noms d'identificateurs longs (généralement pour alléger la première catégorie définie) créer un alias (ou court) le nom de l'amélioration de la lisibilité du code source.

Définition de namespaces

Par défaut, toutes les constantes, les classes et les noms de fonction sont placés dans l'espace mondial, tout de même que devant le PHP de support d'espace de noms.

Namespace déclaration namespace mot-clé. Si un nom de fichier contient des espaces, il doit déclarer l'espace de noms avant tout autre code. La syntaxe est la suivante;

< ?php  
// 定义代码在 'MyProject' 命名空间中  
namespace MyProject;  
 
// ... 代码 ...

Vous pouvez également définir différents espaces de noms dans le même fichier dans le code, tels que:

< ?php  
namespace MyProject1;  
// MyProject1 命名空间中的PHP代码  
 
namespace MyProject2;  
// MyProject2 命名空间中的PHP代码    
 
// 另一种语法
namespace MyProject3 {  
 // MyProject3 命名空间中的PHP代码    
}  
?>

Avant de déclarer un espace de noms de code juridique unique, est utilisé pour définir le fichier source méthodes de codage déclarent déclaration. Tout le code non-PHP inclut des espaces peut ne pas apparaître avant la déclaration d'espace de noms.

<?php
declare(encoding='UTF-8'); //定义多个命名空间和不包含在命名空间中的代码
namespace MyProject {

const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */  }
}

namespace { // 全局代码
session_start();
$a = MyProject\connect();
echo MyProject\Connection::start();
}
?>

Le code erreur de syntaxe suivante se produira:

<html>
<?php
namespace MyProject; // 命名空间前出现了“<html>” 会致命错误 -　命名空间必须是程序脚本的第一条语句
?>

Subnamespaces

Relations avec les répertoires et les fichiers tout comme, namespaces PHP permet également de spécifier le nom de l'espace de noms hiérarchique. Ainsi, le nom de l'espace peut être défini à l'aide d'une manière hiérarchique:

<?php
namespace MyProject\Sub\Level;  //声明分层次的单个命名空间

const CONNECT_OK = 1;
class Connection { /* ... */ }
function Connect() { /* ... */  }

?>

L'exemple ci-dessus crée constante Sous \ MyProject \ Niveau \ CONNEXION_OK, tapez MyProject \ Sous \ Niveau \ Connexion et la fonction MonProjet \ \ Sub Level \ Connect.

Namespaces

PHP nom de la classe d'espace de noms peut être référencé de trois façons:

nom sans réserve, ou le nom de la classe ne contient pas de préfixe, tel que $ a = new foo (); ou foo :: staticmethod ();. Si l'espace de noms courant est currentnamespace, foo sera interprété comme \ foo. Si foo est un code global, le code ne contient pas d'espace de noms, il sera analysé comme foo foo. Attention: Si la fonction d'espace de noms ou constante ne sont pas définis, le nom de la fonction ou le nom constant sans réserve seront résolus au nom de la fonction globale, ou le nom constant.
Nom qualifié, ou le nom contient le préfixe, tel que $ a = new subnamespace \ foo ( ); ou subnamespace \ foo :: staticmethod ();. Si l'espace de noms courant est currentnamespace, alors foo sera analysé comme espacedenomscourant \ subnamespace \ foo. Si foo est un code global, le code ne contient pas d'espace de noms, foo sera résolu à sousespacedenoms \ foo.
Entièrement nom qualifié, ou d' inclure un nom global de l' opérateur de préfixe, par exemple, $ a = new \ espacedenomscourant \ foo (); ou \ \ foo :: staticmethod () ;. Dans ce cas, foo sera toujours résolu au nom des mots de code (littéral nom) espacedenomscourant \ foo.

Voici un exemple de ces trois façons:

Code de fichier file1.php

<?php
namespace Foo\Bar\subnamespace; 

const FOO = 1;
function foo() {}
class foo
{
    static function staticmethod() {}
}
?>

Code de fichier file2.php

<?php
namespace Foo\Bar;
include 'file1.php';

const FOO = 2;
function foo() {}
class foo
{
    static function staticmethod() {}
}

/* 非限定名称 */
foo(); // 解析为 Foo\Bar\foo resolves to function Foo\Bar\foo
foo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod。resolves to class Foo\Bar\foo, method staticmethod
echo FOO; // resolves to constant Foo\Bar\FOO

/* 限定名称 */
subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foo
subnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo,
                                  // 以及类的方法 staticmethod
echo subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO
                                  
/* 完全限定名称 */
\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo
\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethod
echo \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO
?>

Notez que pour accéder à une classe, fonction globale ou constante, vous pouvez utiliser le nom complet, comme \ strlen () ou \ Exception ou \ INI_ALL.

Namespace Accès aux classes mondiales, fonctions et constantes:

<?php
namespace Foo;

function strlen() {}
const INI_ALL = 3;
class Exception {}

$a = \strlen('hi'); // 调用全局函数strlen
$b = \INI_ALL; // 访问全局常量 INI_ALL
$c = new \Exception('error'); // 实例化全局类 Exception
?>

Espaces de noms et langage dynamique

Mettre en œuvre PHP espace affecté par ses propres caractéristiques dynamiques linguistiques. Donc, si vous voulez que le code suivant dans namespaces, des éléments d'accès dynamique.

Code de fichier example1.php:

<?php
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "global";

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global
?>

Vous devez utiliser un nom complet (y compris le nom de la classe du préfixe d'espace de noms). Notez que parce que dans un nom de classe dynamique, nom de la fonction, ou le nom constant, nom qualifié et le nom complet est pas de différence, de sorte que le backslash leader est inutile.

élément d'espace de noms d'accès dynamique

<?php
namespace namespacename;
class classname
{
    function __construct()
    {
        echo __METHOD__,"\n";
    }
}
function funcname()
{
    echo __FUNCTION__,"\n";
}
const constname = "namespaced";

include 'example1.php';

$a = 'classname';
$obj = new $a; // prints classname::__construct
$b = 'funcname';
$b(); // prints funcname
echo constant('constname'), "\n"; // prints global

/* note that if using double quotes, "\\namespacename\\classname" must be used */
$a = '\namespacename\classname';
$obj = new $a; // prints namespacename\classname::__construct
$a = 'namespacename\classname';
$obj = new $a; // also prints namespacename\classname::__construct
$b = 'namespacename\funcname';
$b(); // prints namespacename\funcname
$b = '\namespacename\funcname';
$b(); // also prints namespacename\funcname
echo constant('\namespacename\constname'), "\n"; // prints namespaced
echo constant('namespacename\constname'), "\n"; // also prints namespaced
?>

mot-clé namespace et constantes NAMESPACE

PHP supporte deux façons d'accéder aux éléments d'espace de noms courant abstraits de l'intérieur, __ constantes NAMESPACE__ magiques et espace mot-clé.

__NAMESPACE__ Valeur constante est une chaîne contenant le nom de l'espace de noms courant. En global, le code ne comporte aucun espace de noms qui contient une chaîne vide.

__NAMESPACE__ Exemple, dans un code d'espace de noms

<?php
namespace MyProject;

echo '"', __NAMESPACE__, '"'; // 输出 "MyProject"
?>

__NAMESPACE__ Exemple, code global

<?php

echo '"', __NAMESPACE__, '"'; // 输出 ""
?>

__NAMESPACE__ Constant créé dynamiquement lorsque le nom est utile, par exemple:

Utilisez __NAMESPACE__ nom créé dynamiquement

<?php
namespace MyProject;

function get($classname)
{
    $a = __NAMESPACE__ . '\\' . $classname;
    return new $a;
}
?>

Namespace mot-clé peut être utilisé pour accéder explicitement l'espace de noms actuel ou un des éléments sous-espace de noms. Il est équivalent à la classe de l'opérateur auto.

namespace namespace code opérateur

<?php
namespace MyProject;

use blah\blah as mine; // see "Using namespaces: importing/aliasing"

blah\mine(); // calls function blah\blah\mine()
namespace\blah\mine(); // calls function MyProject\blah\mine()

namespace\func(); // calls function MyProject\func()
namespace\sub\func(); // calls function MyProject\sub\func()
namespace\cname::method(); // calls static method "method" of class MyProject\cname
$a = new namespace\sub\cname(); // instantiates object of class MyProject\sub\cname
$b = namespace\CONSTANT; // assigns value of constant MyProject\CONSTANT to $b
?>

opérateur d'espace de noms, code mondial

<?php

namespace\func(); // calls function func()
namespace\sub\func(); // calls function sub\func()
namespace\cname::method(); // calls static method "method" of class cname
$a = new namespace\sub\cname(); // instantiates object of class sub\cname
$b = namespace\CONSTANT; // assigns value of constant CONSTANT to $b
?>

Utilisation de namespaces: Aliasing / Importation

namespaces PHP supportent deux en utilisant des alias ou l'importation: Utilisez un alias pour le nom de la classe, ou un alias pour un nom d'espace de noms. Notez que PHP ne supporte pas l'importation d'une fonction ou constante.

En PHP, alias pour l'utilisation de l'opérateur pour obtenir ce qui suit est une utilisation de tous les moyens possibles pour importer trois exemples:

1, en utilisant les opérateurs utilisation importation / alias

<?php
namespace foo;
use My\Full\Classname as Another;

// 下面的例子与 use My\Full\NSname as NSname 相同
use My\Full\NSname;

// 导入一个全局类
use \ArrayObject;

$obj = new namespace\Another; // 实例化 foo\Another 对象
$obj = new Another; // 实例化 My\Full\Classname　对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
$a = new ArrayObject(array(1)); // 实例化 ArrayObject 对象
// 如果不使用 "use \ArrayObject" ，则实例化一个 foo\ArrayObject 对象
?>

2, la ligne qui contient plusieurs instructions d'utilisation

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化 My\Full\Classname 对象
NSname\subns\func(); // 调用函数 My\Full\NSname\subns\func
?>

opération d'importation est effectuée au moment de la compilation, mais un nom de classe dynamique, nom de la fonction, ou le nom constant est pas.

3, le nom dynamique importation et

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // 实例化一个 My\Full\Classname 对象
$a = 'Another';
$obj = new $a;      // 实际化一个 Another 对象
?>

En outre, l'opération d'importation ne concerne que les noms non qualifiés et qualifiés. Entièrement nom qualifié parce qu'il est identifié, il n'a pas été affectée par l'importation.

4, Importation et entièrement noms qualifiés

<?php
use My\Full\Classname as Another, My\Full\NSname;

$obj = new Another; // instantiates object of class My\Full\Classname
$obj = new \Another; // instantiates object of class Another
$obj = new Another\thing; // instantiates object of class My\Full\Classname\thing
$obj = new \Another\thing; // instantiates object of class Another\thing
?>

Utilisation de namespaces: retour à la fonction globale / constante

Dans un espace de noms, lorsque PHP rencontre, une fonction classe non qualifié ou le nom constant, il utilise un différentes stratégies prioritaires pour résoudre le nom. Le nom de la classe de l'espace de noms courant résout toujours. Par conséquent, dans un accès interne au système ou non inclus dans l'espace de noms du nom de la classe, vous devez utiliser le nom complet, par exemple:

1, accéder à des cours mondiaux dans un espace de noms

<?php
namespace A\B\C;
class Exception extends \Exception {}

$a = new Exception('hi'); // $a 是类 A\B\C\Exception 的一个对象
$b = new \Exception('hi'); // $b 是类 Exception 的一个对象

$c = new ArrayObject; // 致命错误, 找不到 A\B\C\ArrayObject 类
?>

Pour les fonctions et constantes, n'existe pas la fonction ou si les constantes d'espace de noms actuels, PHP va revenir à des fonctions ou des constantes globales dans l'espace.

2, fonction globale espace de noms réservés / constantes

<?php
namespace A\B\C;

const E_ERROR = 45;
function strlen($str)
{
    return \strlen($str) - 1;
}

echo E_ERROR, "\n"; // 输出 "45"
echo INI_ALL, "\n"; // 输出 "7" - 使用全局常量 INI_ALL

echo strlen('hi'), "\n"; // 输出 "1"
if (is_array('hi')) { // 输出 "is not array"
    echo "is array\n";
} else {
    echo "is not array\n";
}
?>

l'espace mondial

Si vous ne définissez pas de l'espace de noms, toutes les définitions et les fonctions de classe sont dans un espace global et PHP comme avant l'introduction de la notion de namespaces. Avant que le nom préfixé \ indique que le nom est un espace de nom global, il est vrai aussi d'autres espaces de noms, même si le nom se trouve.

Description Utiliser l'espace global

<?php
namespace A\B\C;

/* 这个函数是 A\B\C\fopen */
function fopen() { 
     /* ... */
     $f = \fopen(...); // 调用全局的fopen函数
     return $f;
} 
?>

Ordre namespace

Depuis avec l'espace de noms, ce qui est l'utilisation la plus sujette aux erreurs de temps de classe, pour trouver le chemin de cette classe est ce que le.

<?php
namespace A;
use B\D, C\E as F;

// 函数调用

foo();      // 首先尝试调用定义在命名空间"A"中的函数foo()
            // 再尝试调用全局函数 "foo"

\foo();     // 调用全局空间函数 "foo" 

my\foo();   // 调用定义在命名空间"A\my"中函数 "foo" 

F();        // 首先尝试调用定义在命名空间"A"中的函数 "F" 
            // 再尝试调用全局函数 "F"

// 类引用

new B();    // 创建命名空间 "A" 中定义的类 "B" 的一个对象
            // 如果未找到，则尝试自动装载类 "A\B"

new D();    // 使用导入规则，创建命名空间 "B" 中定义的类 "D" 的一个对象
            // 如果未找到，则尝试自动装载类 "B\D"

new F();    // 使用导入规则，创建命名空间 "C" 中定义的类 "E" 的一个对象
            // 如果未找到，则尝试自动装载类 "C\E"

new \B();   // 创建定义在全局空间中的类 "B" 的一个对象
            // 如果未发现，则尝试自动装载类 "B"

new \D();   // 创建定义在全局空间中的类 "D" 的一个对象
            // 如果未发现，则尝试自动装载类 "D"

new \F();   // 创建定义在全局空间中的类 "F" 的一个对象
            // 如果未发现，则尝试自动装载类 "F"

// 调用另一个命名空间中的静态方法或命名空间函数

B\foo();    // 调用命名空间 "A\B" 中函数 "foo"

B::foo();   // 调用命名空间 "A" 中定义的类 "B" 的 "foo" 方法
            // 如果未找到类 "A\B" ，则尝试自动装载类 "A\B"

D::foo();   // 使用导入规则，调用命名空间 "B" 中定义的类 "D" 的 "foo" 方法
            // 如果类 "B\D" 未找到，则尝试自动装载类 "B\D"

\B\foo();   // 调用命名空间 "B" 中的函数 "foo" 

\B::foo();  // 调用全局空间中的类 "B" 的 "foo" 方法
            // 如果类 "B" 未找到，则尝试自动装载类 "B"

// 当前命名空间中的静态方法或函数

A\B::foo();   // 调用命名空间 "A\A" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "A\A\B" 未找到，则尝试自动装载类 "A\A\B"

\A\B::foo();  // 调用命名空间 "A\B" 中定义的类 "B" 的 "foo" 方法
              // 如果类 "A\B" 未找到，则尝试自动装载类 "A\B"
?>

Nom Résolution Suivez ces règles:

Fonction Nom complet de la classe et les appels constants résolus au moment de la compilation. Par exemple new \ A \ B décide de la classe A \ B.
Tous les noms non qualifiés et qualifiés (pas de noms pleinement qualifiés) convertis au moment de la compilation en fonction des règles d'importation actuelles. Par exemple, si l'espace de noms A \ B \ C est importé comme C, puis un appel à C \ D \ e () sera converti en A \ B \ C \ D \ e ().
Namespace à l'intérieur, tous les noms qualifiés non traduits selon les règles d'importation sera ajouté à l'espace de noms courant devant elle. Par exemple, dans l'espace de noms A \ B Appel interne C \ D \ e (), puis C \ D \ e () est traduit en A \ B \ C \ D \ e ().
nom de classe non qualifiés du convertisseur (avec le nom complet au lieu du nom d'une brève introduction) au moment de la compilation en fonction des règles d'importation actuelles. Par exemple, si l'espace de noms A \ B \ C est importé comme C, le nouveau C () sont converties en nouvelles A \ B \ C () .
Namespace interne (comme A \ B), appelle à absolu nom de la fonction est résolu à l'exécution. Par exemple, un appel à la fonction foo () est résolu comme ceci:
1. Find appelé A \ B \ foo dans l'espace de noms courant () fonction
2. Essayez de trouver et d' appeler le global (global) fonction de l' espace foo ().
Namespace (par exemple, A \ B) interne au nom non qualifié ou qualifiée des noms de classe (pas des noms pleinement qualifiés) appel est résolu au moment de l' exécution. Voici l'appel à new C () et le nouveau D \ E () du processus de résolution: new C () analyse:
1. Trouver A \ B classe \ C dans l'espace actuel.
2. Il tente de autoload A \ B \ C
nouveau D \ E () analyse:
1. Dans le nom de la classe précédé par le nom d'espace de noms courant devient: A \ B \ D \ E , puis chercher la classe.
2. Il tente de autoload A \ B \ D \ E.
Pour référencer la classe mondiale d'espace de noms global, vous devez utiliser le nom complet nouvelle \ C ().

Précédent: variable PHP magique

Suivant: PHP PDO

PHP cours

PHP forme

PHP Tutorial avancée

PHP 7 Nouvelles fonctionnalités

PHP Base de données

PHP XML

PHP & AJAX

PHP Manuel de référence

PHP espace de noms (namespace)

Définition de namespaces

Subnamespaces

Namespaces

Espaces de noms et langage dynamique

mot-clé namespace et constantes NAMESPACE

Utilisation de namespaces: Aliasing / Importation

Utilisation de namespaces: retour à la fonction globale / constante

l'espace mondial

Ordre namespace

PHP cours

PHP forme

PHP Tutorial avancée

PHP 7 Nouvelles fonctionnalités

PHP Base de données

PHP XML

PHP & AJAX

PHP Manuel de référence

PHP espace de noms (namespace)

Définition de namespaces

Subnamespaces

Namespaces

Espaces de noms et langage dynamique

mot-clé namespace et constantes __NAMESPACE__

Utilisation de namespaces: Aliasing / Importation

Utilisation de namespaces: retour à la fonction globale / constante

l'espace mondial

Ordre namespace

mot-clé namespace et constantes NAMESPACE