PHP nazw (namespace)

PHP nazw (namespace) jest dodana w PHP 5.3, jeśli nauczył C # i Java, nazw, które nie ma nic nowego. Ale w PHP, które wciąż ma bardzo ważne znaczenie.

przestrzenie nazw PHP może rozwiązać dwa następujące problemy:

Kod napisany przez użytkownika wewnątrz PHP klas / funkcji / stałych lub konfliktów z innymi firmami nazw klas / funkcje / Stałe pomiędzy.
W długich nazw identyfikatorów (zwykle do łagodzenia pierwszą kategorię zdefiniowaną) Utwórz alias (lub krótki) imię poprawy czytelności kodu źródłowego.

Definiowanie przestrzeni nazw

Domyślnie wszystkie stałe, klasy i nazwy funkcji umieszczone są w przestrzeni globalnej, tak samo jak przed PHP wsparcia nazw.

deklaracja przestrzeni nazw poprzez nazw słów kluczowych. Jeśli nazwa pliku zawiera spacje, musi zadeklarować nazw przed każdym innym kodem. Składnia jest następująca;

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

Można również zdefiniować różne przestrzenie nazw w tym samym pliku w kodzie, takie jak:

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

Przed deklarowania przestrzeni nazw unikalny kod prawną służy do definiowania pliku źródłowego metody kodowania zadeklarować oświadczenie. Cały kod non-PHP zawiera spacje nie może stanąć przed deklaracji przestrzeni nazw.

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

Następujący błąd składni kodu nastąpi:

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

Subnamespaces

Powiązania z katalogów i plików podobny, przestrzenie nazw PHP pozwala także określić nazwę przestrzeni nazw hierarchicznej. Tak więc, nazwa nazw można określić stosując sposób hierarchiczny:

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

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

?>

Powyższy przykład tworzy stałą myproject \ \ Sub Level \ CONNECT_OK typu myproject \ Sub \ Poziom \ podłączanie i działanie myproject \ Sub \ Poziom \ Połącz.

Przestrzenie nazw

PHP nazwa klasy nazw można odwoływać się na trzy sposoby:

Nieuwarunkowany nazwisko lub nazwa klasy nie zawiera prefiks, takich jak $ a = new Foo (); lub foo :: staticmethod ();. Jeśli bieżący nazw jest currentnamespace foo zostanie zinterpretowane jako currentnamespace \ foo. Jeśli foo jest hasło globalne kod nie zawiera żadnych nazw, to będzie analizowany jako bla bla. Uwaga: Jeśli funkcja nazw lub stałe nie jest zdefiniowana, to nazwa funkcji lub niewykwalifikowanych stała nazwa zostanie rozwiązany do globalnej nazwy funkcji lub stałej nazwy.
nazwa kwalifikowana lub nazwa zawiera przedrostek, takie jak $ a = new subnamespace \ foo ( ); lub subnamespace \ foo :: staticmethod ();. Jeśli prąd jest currentnamespace nazw, a następnie foo będzie analizowany jako currentnamespace \ subnamespace \ foo. Jeśli foo jest hasło globalne kod nie zawiera żadnych nazw, foo zostanie rozwiązany do subnamespace \ foo.
Pełna nazwa lub zawierają nazwę globalnego prefiksu operatora, na przykład, $ a = new \ currentnamespace \ foo (); lub \ currentnamespace \ foo :: staticmethod () ;. W tym przypadku, bla zawsze będą rozwiązane do nazwy słów kodowych (dosłownym nazwa) currentnamespace \ foo.

Tutaj jest instancją tych trzech sposobów:

file1.php kod pliku

<?php
namespace Foo\Bar\subnamespace; 

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

file2.php kod pliku

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

Należy pamiętać, że aby uzyskać dostęp do każdej globalnej klasy, funkcji lub stała, można użyć pełnej nazwy, takie jak \ strlen () lub \ wyjątku lub \ INI_ALL.

Dostęp do globalnych nazw klas, funkcji i stałych:

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

Przestrzenie nazw i dynamiczne funkcje językowe

Wdrożenie PHP nazw dotkniętych własnych dynamicznych cech językowych. Tak więc, jeśli chcesz następujący kod do przestrzeni nazw, elementów dynamicznych dostępu.

example1.php kod pliku:

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

Należy użyć pełnej nazwy (łącznie z nazwą klasy przedrostka przestrzeni nazw). Należy zauważyć, że w dynamicznym nazwy klasy, nazwy funkcji lub stałej nazwy, kwalifikowanej nazwy i pełnej nazwy ma żadnej różnicy, więc wiodącym backslash jest niepotrzebna.

Element nazw dynamiczna o dostępie

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

Hasło nazw i stałe NAMESPACE

PHP obsługuje dwa sposoby dostępu do bieżącej przestrzeni nazw abstrakcyjnych elementów wnętrz, __ NAMESPACE__ magicznych stałych i słowa kluczowego namespace.

__NAMESPACE__ Wartość stała jest ciągiem zawierającym nazwę bieżącego nazw. W globalnym, kod nie zawiera żadnych nazw, który zawiera pusty ciąg.

__NAMESPACE__ Przykład w kodzie przestrzeni nazw

<?php
namespace MyProject;

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

__NAMESPACE__ Przykład globalny kod

<?php

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

Stała __NAMESPACE__ tworzone dynamicznie, gdy nazwa jest przydatna, na przykład:

Użyj __NAMESPACE__ dynamicznie utworzony nazwę

<?php
namespace MyProject;

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

Hasło nazw może być użyta, aby wyraźnie dostęp do aktualnego nazw lub elementy sub-nazw. Jest to równoważne z klasy operatora siebie.

Kod nazw nazw operatora

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

Operator nazw, globalny kod

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

Korzystanie z przestrzeni nazw: Aliasing / import

przestrzenie nazw PHP wspiera dwa używając aliasów lub importowanie: Użycie aliasu dla nazwy klasy lub alias dla nazwy przestrzeni nazw. Zauważ, że PHP nie obsługuje importowanie funkcji lub stała.

W PHP, alias do użycia operatora do osiągnięcia następujących celów jest wykorzystanie wszystkich możliwych sposobów, aby importować trzy przykłady:

1, za pomocą operatora Zastosowanie import / pseudonim

<?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, linia, która zawiera wiele instrukcji użytkowania

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

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

Operacja importu odbywa się w czasie kompilacji, ale nazwa dynamiczna klasa, nazwa funkcji lub stała nazwa nie jest.

3, Import i dynamiczną nazwę

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

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

Ponadto, operacja importu wpływa tylko nazwy niewykwalifikowanych i wykwalifikowanych. Pełna nazwa, ponieważ jest on zidentyfikowany, nie jest dotknięte przez import.

4, importu i pełne nazwy

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

Korzystanie z przestrzeni nazw: Przenieś się na globalnej funkcji / stała

W przestrzeni nazw, gdy PHP napotyka bez zastrzeżeń klasy, funkcji lub stałej nazwy, używa różnych strategii priorytetowych w celu rozwiązania nazwy. Nazwa klasy obecną nazwą przestrzeni nazw zawsze postanawia. W związku z tym, w wewnętrznym dostępu do systemu lub nie ujęte w przestrzeni nazw nazwy klasy, należy użyć pełnej nazwy, na przykład:

1, dostęp do globalnych klas w przestrzeni nazw

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

Dla funkcji i stałych, funkcja nie istnieje lub jeśli obecnych stałych przestrzeni nazw, PHP spadnie z powrotem do globalnych funkcji lub stałych w przestrzeni.

2, funkcja globalnej przestrzeni nazw zastrzeżone / Stałe

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

Globalna przestrzeń

Jeśli nie zdefiniować dowolną przestrzeń nazw, wszystkie definicje i funkcje klasy znajdują się w przestrzeni globalnej i PHP jak przed wprowadzeniem pojęcia przestrzeni nazw. Przed nazwą przedrostek \ wskazuje, że nazwa jest globalną przestrzeń nazw, to samo dotyczy innych nazw, nawet jeśli nazwa znajduje.

Opis Zastosowanie globalna przestrzeń

<?php
namespace A\B\C;

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

nazw Zamówienie

Ponieważ z nazw, która jest najbardziej podatna na błędy wykorzystanie czasu klasy, aby znaleźć drogę z tej klasy jest co.

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

Imię Rozdzielczość według poniższych zasad:

Funkcja pełni kwalifikowana nazwa klasy i połączenia stałe rozdzielone w czasie kompilacji. Na przykład nowy \ A \ B postanawia klasy A \ B.
Wszystkie niewykwalifikowanych i wykwalifikowanych nazwy (nie w pełni kwalifikowanych nazw) konwertowane w czasie kompilacji na podstawie aktualnych przepisów importowych. Na przykład, jeśli namespace A \ B \ C jest importowany jako C, a następnie wezwanie do C \ D \ e () zostanie przekształcony w \ B \ C \ D \ e ().
Przestrzeń nazw wewnątrz, wszystkie kwalifikowane nazwy nie przeliczono według zasad importu zostanie dodany do obecnej nazwy przestrzeni nazw przed nim. Na przykład, w przestrzeni nazw A \ B połączenie wewnętrzne C \ D \ e (), a następnie C \ D \ e () jest tłumaczona na A \ B \ C \ D \ e ().
Non-nazwa klasy konwerter (z pełną nazwą zamiast nazwy krótkim wprowadzeniu) w czasie kompilacji na bazie obecnych przepisów importowych. Na przykład, jeśli namespace A \ B \ C jest importowany jako C, nowy C () są zamieniane na nowe A \ B \ C () .
Przestrzeń nazw wewnętrzne (takie jak A \ B), wzywa do niewykwalifikowany nazwa funkcji zostanie rozwiązany przy starcie. Na przykład wywołanie funkcji foo () został rozwiązany w ten sposób:
1. Znajdź nazywa A \ B \ foo w bieżącym obszarze nazw () funkcja
2. Spróbuj odnaleźć i wywołać globalne (global) funkcji przestrzeni foo ().
Przestrzeń nazw (na przykład A \ B) wewnątrz niewykwalifikowanego lub kwalifikowanej nazwy nazw klasowych (nie w pełni kwalifikowane nazwy) połączenie zostanie rozwiązany w czasie wykonywania. Oto wezwanie do nowej C () i nowe D \ E () procesu rozdzielczość: nowa C () parsowania:
1. Find A \ B Class \ C w bieżącym obszarze nazw.
2. Próbuje autoload A \ B \ C.
Nowa D \ E () parsowania:
1. W nazwa klasy poprzedzona obecną nazwą przestrzeni nazw staje: A \ B \ D \ E , a następnie szukać klasy.
2. Próbuje autoload A \ B \ D \ E.
Aby odwołać się do globalnej przestrzeni nazw globalnej klasy, należy użyć w pełni kwalifikowanej nazwy nowego \ C ().

Zmienna magii PHP: Poprzedni

Dalej: PHP PDO

PHP kurs

PHP forma

PHP zaawansowane Tutorial

PHP 7 Nowe funkcje

PHP baza danych

PHP XML

PHP & AJAX

PHP Reference Manual

PHP nazw (namespace)

Definiowanie przestrzeni nazw

Subnamespaces

Przestrzenie nazw

Przestrzenie nazw i dynamiczne funkcje językowe

Hasło nazw i stałe NAMESPACE

Korzystanie z przestrzeni nazw: Aliasing / import

Korzystanie z przestrzeni nazw: Przenieś się na globalnej funkcji / stała

Globalna przestrzeń

nazw Zamówienie

PHP kurs

PHP forma

PHP zaawansowane Tutorial

PHP 7 Nowe funkcje

PHP baza danych

PHP XML

PHP & AJAX

PHP Reference Manual

PHP nazw (namespace)

Definiowanie przestrzeni nazw

Subnamespaces

Przestrzenie nazw

Przestrzenie nazw i dynamiczne funkcje językowe

Hasło nazw i stałe __NAMESPACE__

Korzystanie z przestrzeni nazw: Aliasing / import

Korzystanie z przestrzeni nazw: Przenieś się na globalnej funkcji / stała

Globalna przestrzeń

nazw Zamówienie

Hasło nazw i stałe NAMESPACE