PHP Namespace (Namensraum)

PHP Namespace (Namensraum) in PHP 5.3, hinzugefügt, wenn Sie C # und Java gelernt, Namensraum, der nichts Neues ist. Aber in PHP, die hat immer noch eine sehr wichtige Bedeutung.

PHP Namespaces können die folgenden zwei Probleme zu lösen:

Benutzer geschriebenen Code in PHP-Klassen / Funktionen / Konstanten oder Fremd Klassen / Funktionen / Konstanten Namenskonflikte zwischen.
Solange Identifier-Namen erstellen einen Alias (oder kurz) den Namen der Verbesserung der Lesbarkeit des Quellcodes (in der Regel die erste Kategorie definiert zu lindern).

definieren von Namespaces

Standardmäßig werden alle Konstanten, Klassen und Funktionsnamen werden im globalen Raum platziert, genau das gleiche wie vor dem Namespace-Unterstützung PHP.

Namespace-Deklaration nach Stichwort Namespace. Wenn ein Dateiname Leerzeichen enthält, muss es den Namespace vor jedem anderen Code deklarieren. Die Syntax ist wie folgt;

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

Sie können auch verschiedene Namensräume in der gleichen Datei im Code, wie definieren:

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

Bevor Sie einen Namensraum einzigartigen Rechts Code erklärt wird verwendet, um die Quelldatei Codierverfahren Anweisung deklarieren zu definieren. Alle Nicht-PHP-Code enthält Leerzeichen nicht vor der Namespace-Deklaration erscheinen kann.

<?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();
}
?>

Der folgende Code Syntaxfehler auftreten:

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

Subnamespaces

Beziehung mit Verzeichnissen und Dateien viel wie, PHP Namespaces ermöglicht auch den Namen des hierarchischen Namensraum angeben. Somit kann der Name des Namespace definiert werden, um eine hierarchische Weise unter Verwendung von:

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

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

?>

Das obige Beispiel erzeugt Konstante MyProject \ Sub \ Ebene \ CONNECT_OK, Typ MyProject \ Sub \ Ebene \ Connection und Funktion MyProject \ Sub \ Ebene \ Connect.

Namespaces

PHP Namespace Klassenname kann auf drei Arten verwiesen werden:

Unqualifizierte Namen oder den Namen der Klasse enthält kein Präfix, wie $ a = new foo (); oder foo :: static ();. Wenn der aktuelle Namespace aktuellerNamespace, wird foo als aktuellerNamespace \ foo interpretiert werden. Wenn foo globale Code ist, wird der Code keinen Namensraum enthalten, wird es als foo foo analysiert werden. Achtung: Wenn der Namespace-Funktion oder Konstante nicht definiert ist, dann der Name der Funktion oder unqualifizierte konstant Name wird auf die globale Funktionsnamen oder konstante Name aufgelöst werden.
Qualifizierter Name, oder enthält der Name mit dem Präfix, wie $ a = new subnamespace \ foo ( ); oder subnamespace \ foo :: static ();. Wenn der aktuelle Namespace aktuellerNamespace ist, dann wird foo als aktuellerNamespace \ subnamespace \ foo analysiert. Wenn foo globale Code ist, wird der Code keinen Namensraum enthalten, wird foo aufgelöst werden \ foo subnamespace.
Der vollständig qualifizierte Name oder ein globales Präfix Name des Bedieners umfassen zum Beispiel $ a = new \ aktuellerNamespace \ foo (); oder \ aktuellerNamespace \ foo :: static () ;. In diesem Fall wird, foo immer auf den Namen der Codewörter aufgelöst werden (wörtliche Name) aktuellerNamespace \ foo.

Hier ist ein Beispiel dieser drei Möglichkeiten:

file1.php Datei Code

<?php
namespace Foo\Bar\subnamespace; 

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

file2.php Datei Code

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

Beachten Sie, dass für den Zugriff auf jede globale Klasse, Funktion oder Konstante, können Sie den vollständig qualifizierten Namen, wie zum Beispiel \ strlen () oder \ Exception oder \ INI_ALL verwenden.

Namespace-Zugriff auf globale Klassen, Funktionen und Konstanten:

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

Namespaces und dynamische Sprachfeatures

Implementieren Sie PHP Namespace durch seine eigene dynamische Sprachfunktionen betroffen. Also, wenn Sie wollen den folgenden Code in Namespaces, dynamische Zugriffselemente.

example1.php Datei Code:

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

Sie müssen einen vollqualifizierten Namen (einschließlich der Klassenname des Namespacepräfix) verwenden. Beachten Sie, dass, weil in einer dynamischen Klasse Name, Funktion Name, oder konstanten Namen, qualifizierten Namen und den voll qualifizierten Namen keinen Unterschied, so der führende Backslash unnötig ist.

Dynamic Access-Namespace-Element

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

Namespace-Schlüsselwort und Konstanten NAMESPACE

PHP unterstützt zwei Möglichkeiten, um die aktuellen Namensraum abstrakten Interieur-Elemente zuzugreifen, __ NAMESPACE__ magische Konstanten und Namespace-Schlüsselwort.

__NAMESPACE__ Konstanter Wert ist eine Zeichenfolge, die den Namen des aktuellen Namensraum enthält. Im globalen, wird der Code keinen Namensraum enthalten, die eine leere Zeichenfolge enthält.

__NAMESPACE__ Beispiel, in einem Namespace Code

<?php
namespace MyProject;

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

__NAMESPACE__ Beispiel, globale Code

<?php

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

Constant __NAMESPACE__ dynamisch erstellt, wenn der Name nützlich ist, zum Beispiel:

Verwenden Sie __NAMESPACE__ dynamisch erstellten Namen

<?php
namespace MyProject;

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

Namespace-Schlüsselwort kann explizit verwendet werden, um den aktuellen Namespace zugreifen oder ein Unternamensraum-Elemente. Sie ist äquivalent zu der Klasse der Selbstbedienungsperson.

Namespace-Operator-Namespace Code

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

Namespace-Betreiber, die globale Code

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

Namespaces verwenden: Importieren / Aliase

PHP Namespaces unterstützen zwei Aliasnamen oder den Import verwendet: ein Alias für den Klassennamen verwenden oder einen Alias für einen Namespace-Namen. Beachten Sie, dass PHP unterstützt keine Funktion oder Konstante importieren.

In PHP, alias für Operator verwenden Sie die folgende zu erreichen, ist eine Nutzung aller Möglichkeiten, drei Beispiele zu importieren:

1, mit der Verwendung Operator Import / 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, die Linie, die mehrfache Verwendung Aussagen enthält

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

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

Importoperation wird bei der Kompilierung durchgeführt, sondern eine dynamische Klasse Name, Funktion Name, oder konstant Name nicht.

3, Import und dynamischen Namens

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

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

Darüber hinaus wirkt sich der Importvorgang nur unqualifizierte und qualifizierte Namen. Vollständig qualifizierte Namen, weil er identifiziert wird, wird es nicht durch den Import betroffen.

4, Importieren und voll qualifizierten Namen

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

Namespaces verwenden: Rückgriff auf globale Funktion / Konstante

In einem Namespace, wenn PHP eine unqualifizierte Klasse trifft, Funktion oder konstanten Namen, verwendet es eine andere Priorität Strategien, um den Namen aufzulösen. Der Klassenname des aktuellen Namespace-Namen aufgelöst immer. Daher wird in einem internen Zugriff auf das System oder nicht im Namensraum des Klassennamens enthalten ist, müssen Sie den vollständig qualifizierten Namen verwenden, zum Beispiel:

1, Zugriff auf globale Klassen in einem Namespace

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

Für Funktionen und Konstanten, wird die Funktion nicht vorhanden ist oder wenn die aktuellen Namespace Konstanten, wird PHP zu globalen Funktionen oder Konstanten im Raum zurückgreifen.

2, globale Funktion Namensraum reserviert / Konstanten

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

globale Raum

Wenn Sie keinen Namensraum definieren, werden alle Klassendefinitionen und Funktionen sind in einem globalen Raum und PHP als vor der Einführung des Konzepts der Namensräume. Bevor der Name Präfix \ zeigt an, dass der Name einer globalen Namensraum ist, ist es auch wahr, andere Namespace auch wenn der Name befindet.

Beschreibung Verwendung globaler Raum

<?php
namespace A\B\C;

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

Bestellen Sie Namespace

Da mit dem Namespace, die die meisten fehleranfällige Nutzung der Unterrichtszeit ist, zu finden, der Weg dieser Klasse ist das, was die.

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

Namensauflösung Führen Sie die folgenden Regeln:

Funktion voll qualifizierten Namen der Klasse und die ständigen Anrufe bei der Kompilierung gelöst. Für neues Beispiel \ A \ B wird als Klasse A \ B
Alle nicht qualifizierten und qualifizierten Namen (nicht vollständig qualifizierte Namen) zum Zeitpunkt der Kompilierung umgewandelt basieren auf aktuellen Einfuhrbestimmungen. wenn der Namespace A \ B \ C als C Zum Beispiel importiert wird, dann ein Anruf an C \ D \ e () wird nach A \ B \ C \ D \ umgewandelt werden e ().
Namespace nach innen, alle qualifizierten Namen nicht übersetzt nach Importregeln werden auf den aktuellen Namespace-Namen vor ihm hinzugefügt werden. Zum Beispiel, in dem Namespace A \ B Interner Anruf C \ D \ e (), dann C \ D \ e () auf A \ B \ C \ D \ übersetzt e ().
Nicht qualifizierte Klassenname des Wandlers (mit vollem Namen anstelle des Namens einer kurzen Einführung) bei der Kompilierung auf aktuellen Import Regeln. wenn der Namespace A \ B \ C als C Zum Beispiel importiert wird, die neue C () umgewandelt werden , um neue A \ B \ C () .
Namespace interne (wie A \ B), ruft zu unqualifizierten Funktionsnamen zur Laufzeit aufgelöst wird. Zum Beispiel, um ein Aufruf der Funktion foo () wird wie folgt gelöst:
1. Finden A \ B \ foo im aktuellen Namensraum () Funktion aufgerufen
2. Versuchen Sie , und rufen Sie die globale (global) Raum function foo ().
Namespace (zum Beispiel A \ B) im Inneren unqualifizierte oder qualifizierten Namen der Klassennamen (nicht vollständig qualifizierte Namen) Anruf wird zur Laufzeit aufgelöst. Hier ist der Aufruf an neue C () und die neue D \ E () des Auflösungsprozess: neue C () Analyse:
1. Find A \ B \ C - Klasse im aktuellen Namensraum.
2. Es wird versucht , automatisch zu laden A \ B \ C
neue D \ E () Analyse:
1. In der Klassenname durch den aktuellen Namespace - Namen vorangestellt wird: A \ D \ E \ B , dann für die Klasse aussehen.
2. Es wird versucht , automatisch zu laden A \ B \ D \ E.
Um den globalen Namensraum globale Klasse verweisen, müssen Sie den vollständig qualifizierten Namen neue \ C () verwenden.

Zurück: PHP Magie Variable

Next: PHP PDO

PHP Kurs

PHP Form

PHP Erweiterte Tutorial

PHP 7 Neue Funktionen

PHP Datenbank

PHP XML

PHP & AJAX

PHP Referenzhandbuch

PHP Namespace (Namensraum)

definieren von Namespaces

Subnamespaces

Namespaces

Namespaces und dynamische Sprachfeatures

Namespace-Schlüsselwort und Konstanten NAMESPACE

Namespaces verwenden: Importieren / Aliase

Namespaces verwenden: Rückgriff auf globale Funktion / Konstante

globale Raum

Bestellen Sie Namespace

PHP Kurs

PHP Form

PHP Erweiterte Tutorial

PHP 7 Neue Funktionen

PHP Datenbank

PHP XML

PHP & AJAX

PHP Referenzhandbuch

PHP Namespace (Namensraum)

definieren von Namespaces

Subnamespaces

Namespaces

Namespaces und dynamische Sprachfeatures

Namespace-Schlüsselwort und Konstanten __NAMESPACE__

Namespaces verwenden: Importieren / Aliase

Namespaces verwenden: Rückgriff auf globale Funktion / Konstante

globale Raum

Bestellen Sie Namespace

Namespace-Schlüsselwort und Konstanten NAMESPACE