本文主要和大家分享的是php類別與物件易錯筆記,資訊量很大,但是對於學php的人來說很有幫助,希望能幫助到大家。
new:如果在 new 之後跟著的是包含有類別名稱的字串,則該類別的一個實例被建立。如果該類別屬於一個名字空間,則必須使用其完整名稱。
Example #3 建立一個實例
<?php$instance = new stdClass();// 也可以这样做:$className = 'stdClass';$instance = new $className(); // Foo()?>
#在類別定義內部,可以用<span style="font-size: 14px;">new self</span>
# 和<span style="font-size: 14px;">new parent</span>
建立新物件。
PHP 5.3.0 引進了兩個新方法來建立一個物件的實例:
<?phpclass Test{ static public function getNew()//单例模式可以使用此方法 { return new static; }} class Child extends Test {}$obj1 = new Test();$obj2 = new $obj1;var_dump($obj1 !== $obj2);//bool(true)$obj3 = Test::getNew();var_dump($obj3 instanceof Test);//bool(true)$obj4 = Child::getNew();var_dump($obj4 instanceof Child);//bool(true)?>
從PHP 5.5 起,關鍵字<span style="font-size: 14px;">class</span>
也可用來類別名稱的解析:<span style="font-size: 14px;">ClassName::class</span>
##當把一個物件已經建立的實例賦給一個新變數時,新變數會存取同一個實例,就和用該物件賦值一樣。此行為和傳遞給函數進入實例時一樣。可以用克隆給一個已建立的物件建立一個新實例。 <span style="font-size: 14px;"></span>
<?php Class Object{ public $foo="bar";};$objectVar = new Object();$reference =& $objectVar;$assignment = $objectVar;$cloneObj = clone $objectVar;$objectVar->foo = "qux";var_dump( $objectVar );var_dump( $reference );var_dump( $assignment );var_dump( $cloneObj );echo '--------------------', PHP_EOL;$objectVar = null;var_dump($objectVar);var_dump($reference);var_dump($assignment);var_dump($cloneObj);/*Result:object(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#2 (1) { ["foo"]=> string(3) "bar"}--------------------NULLNULLobject(Object)#1 (1) { ["foo"]=> string(3) "qux"}object(Object)#2 (1) { ["foo"]=> string(3) "bar"}*/
spl_autoload_register()<span style="font-size: 14px;"></span>
函數可以註冊任意數量的自動載入器,當使用尚未定義的類別(class)和介面(interface)時自動去載入。透過註冊自動載入器,腳本引擎在 PHP 出錯失敗前有了最後一個機會載入所需的類別。 <span style="font-size: 14px;"></span>
儘管<span style="font-size: 14px;"></span>__autoload()<span style="font-size: 14px;"></span>
函數也能自動載入類別和接口,但更建議使用spl_autoload_register()<span style="font-size: 14px;"></span>
函數。 <span style="font-size: 14px;"></span>spl_autoload_register()<span style="font-size: 14px;"></span>
提供了一種更靈活的方式來實現類別的自動載入(同一個應用程式中,可以支援任意數量的載入器,例如第三方庫中的)。因此,不再建議使用 __autoload() 函數,在以後的版本中它可能會被棄用。 <span style="font-size: 14px;"></span>
Example #1 自動載入範例<span style="font-size: 14px;"></span>
#本範例嘗試分別從 MyClass1.php 和 MyClass2.php 檔案中載入 MyClass1 和 MyClass2 類別。 <span style="font-size: 14px;"></span>
<?phpspl_autoload_register(function ($class_name) { require_once $class_name . '.php';});$obj = new MyClass1();$obj2 = new MyClass2();?>
#Note: 如果子類別中定義了建構函式則不會隱含調用其父類別的建構子。要執行父類別的建構函數,需要在子類別的建構子中呼叫parent::__construct()<span style="font-size: 14px;"></span>
。如果子類別沒有定義建構函式則會如同一個普通的類別方法一樣從父類別繼承(假如沒有被定義為 private 的話)。 <span style="font-size: 14px;"></span>和建構子一樣,父類別的析構函式不會被引擎暗中呼叫。要執行父類別的析構函數,必須在子類別的析構函數體中明確呼叫
#parent::__destruct()<span style="font-size: 14px;"></span>
。另外也和建構子一樣,子類別如果自己沒有定義析構函式則會繼承父類別的。 <span style="font-size: 14px;"></span>析構函數即使在使用 exit() 終止腳本執行時也會被呼叫。在析構函數中呼叫 exit() 將會中止其餘關閉操作的運作。
#類別屬性必須定義為#公有<span style="font-size: 14px;"></span>
,<span style="font-size: 14px;"></span> 受保護<span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>#私有<span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span><span style="font-size: 14px;">##之一。如果用 var 定義,則視為公有。 </span>
<span style="font-size: 14px;"></span>類別中的方法可以定義為<span style="font-size: 14px;"></span>公有
<span style="font-size: 14px;"></span><span style="font-size: 14px;"></span>#私有
或
同一个类的对象即使不是同一个实例也可以互相访问对方的私有与受保护成员。这是由于在这些对象的内部具体实现的细节都是已知的。
Example #3 访问同一个对象类型的私有成员
<?phpclass Test{ private $foo; public function __construct($foo) { $this->foo = $foo; } private function bar() { echo 'Accessed the private method.'; } public function baz(Test $other) { // We can change the private property: $other->foo = 'hello'; var_dump($other->foo); // We can also call the private method: $other->bar(); }}$test = new Test('test');$test->baz(new Test('other'));//string(5) "hello"//Accessed the private method.?>
继承和访问控制:
<?php abstract class base { public function inherited() { $this->overridden(); } private function overridden() { echo 'base'; } } class child extends base { private function overridden() { echo 'child'; } } $test = new child(); $test->inherited(); ?> Output will be "base". If you want the inherited methods to use overridden functionality in extended classes but public sounds too loose, use protected. That's what it is for:) A sample that works as intended: <?php abstract class base { public function inherited() { $this->overridden(); } protected function overridden() { echo 'base'; } } class child extends base { protected function overridden() { echo 'child'; } } $test = new child(); $test->inherited(); ?> Output will be "child".
<span style="font-size: 14px;">范围解析操作符</span>
(也可称作 Paamayim Nekudotayim)或者更简单地说是一对冒号,可以用于访问<span style="font-size: 14px;">静态成员</span>
,<span style="font-size: 14px;">类常量</span>
,还可以用于<span style="font-size: 14px;">覆盖类中的属性和方法</span>
。
访问静态变量,静态方法,常量:
<?php class A { public static $B = '1'; # Static class variable. const B = '2'; # Class constant. public static function B() { # Static class function. return '3'; } }echo A::$B . A::B . A::B(); # Outputs: 123
Example #3 调用父类的方法
<?phpclass MyClass{ protected function myFunc() { echo "MyClass::myFunc()\n"; }}class OtherClass extends MyClass{ // 覆盖了父类的定义 public function myFunc() { // 但还是可以调用父类中被覆盖的方法 parent::myFunc(); echo "OtherClass::myFunc()\n"; }}$class = new OtherClass();$class->myFunc();?>
用 static 关键字来定义<span style="font-size: 14px;">静态方法</span>
和<span style="font-size: 14px;">属性</span>
。static 也可用于<span style="font-size: 14px;">定义静态变量</span>
以及<span style="font-size: 14px;">后期静态绑定</span>
。
声明类属性或方法为静态,就可以不实例化类而直接访问。静态属性不能通过一个类已实例化的对象来访问(但静态方法可以)。
继承一个抽象类的时候:
1.子类必须定义父类中的所有抽象方法;
2.这些方法的访问控制必须和父类中一样(或者更为宽松)。例如某个抽象方法被声明为受保护的,那么子类中实现的方法就应该声明为受保护的或者公有的,而不能定义为私有的;
3.方法的调用方式必须匹配,即类型和所需参数数量必须一致。例如,子类定义了一个可选参数,而父类抽象方法的声明里没有,则两者的声明并无冲突
。 这也适用于 PHP 5.4 起的构造函数。在 PHP 5.4 之前的构造函数声明可以不一样的;
接口中定义的所有方法都必须是公有,这是接口的特性。
实现类必须实现接口中定义的所有方法
类可以实现多个接口,用逗号来分隔多个接口的名称。
实现多个接口时,接口中的方法不能有重名。
类要实现接口,必须使用和接口中所定义的方法完全一致的方式。
接口中也可以定义常量。接口常量和类常量的使用完全相同,但是不能被子类或子接口所覆盖。
自 PHP 5.4.0 起,PHP 实现了一种代码复用的方法,称为 <span style="font-size: 14px;">trait</span>
。
Trait 是为类似 PHP 的单继承语言而准备的一种代码复用机制。Trait 为了减少单继承语言的限制,使开发人员能够自由地在不同层次结构内独立的类中复用 method。Trait 和 Class 组合的语义定义了一种减少复杂性的方式,避免传统多继承和 Mixin 类相关典型问题。
Trait 和 Class 相似,但仅仅旨在用细粒度和一致的方式来组合功能。 无法通过 trait 自身来实例化。它为传统继承增加了水平特性的组合;也就是说,应用的几个 Class 之间不需要继承。
优先级:从基类继承的成员会被 trait 插入的成员所覆盖。优先顺序是来自当前类的成员覆盖了 trait 的方法,而 trait 则覆盖了被继承的方法。
<?phpclass Base { public function sayHello() { echo 'Hello '; }}trait SayWorld { public function sayHello() { parent::sayHello(); echo 'World!'; }}class MyHelloWorld extends Base { use SayWorld;}$o = new MyHelloWorld();$o->sayHello();//Hello World!?>
多个 trait:通过逗号分隔,在 use
声明列出多个 trait,可以都插入到一个类中。
冲突的解决:为了解决多个 trait 在同一个类中的命名冲突,需要使用 insteadof
操作符来明确指定使用冲突方法中的哪一个。
<?phptrait A { public function smallTalk() { echo 'a'; } public function bigTalk() { echo 'A'; }}trait B { public function smallTalk() { echo 'b'; } public function bigTalk() { echo 'B'; }}class Talker { use A, B { B::smallTalk insteadof A; A::bigTalk insteadof B; }}class Aliased_Talker { use A, B { B::smallTalk insteadof A; A::bigTalk insteadof B; B::bigTalk as talk; }}?>
修改方法的<span style="font-size: 14px;">访问控制</span>
:使用 as
语法还可以用来调整方法的访问控制。
<?phptrait HelloWorld { public function sayHello() { echo 'Hello World!'; }}// 修改 sayHello 的访问控制class MyClass1 { use HelloWorld { sayHello as protected; }}// 给方法一个改变了访问控制的别名// 原版 sayHello 的访问控制则没有发生变化class MyClass2 { use HelloWorld { sayHello as private myPrivateHello; }}?>
从 <span style="font-size: 14px;">trait</span>
来组成 <span style="font-size: 14px;">trait</span>
:在 trait 定义时通过使用一个或多个 trait,能够组合其它 trait 中的部分或全部成员。
<?phptrait Hello { public function sayHello() { echo 'Hello '; }}trait World { public function sayWorld() { echo 'World!'; }}trait HelloWorld { use Hello, World;}class MyHelloWorld { use HelloWorld;}$o = new MyHelloWorld();$o->sayHello();$o->sayWorld();?>
Trait 的<span style="font-size: 14px;">抽象成员</span>
:为了对使用的类施加强制要求,trait 支持抽象方法的使用。
<?phptrait Hello { public function sayHelloWorld() { echo 'Hello'.$this->getWorld(); } abstract public function getWorld();}class MyHelloWorld { private $world; use Hello; public function getWorld() { return $this->world; } public function setWorld($val) { $this->world = $val; }}?>
Trait 的<span style="font-size: 14px;">静态成员</span>
:Traits 可以被静态成员静态方法定义。
<?phpclass TestClass { public static $_bar;}class Foo1 extends TestClass { }class Foo2 extends TestClass { }Foo1::$_bar = 'Hello';Foo2::$_bar = 'World';echo Foo1::$_bar . ' ' . Foo2::$_bar; // Prints: World World?>Example using trait:<?phptrait TestTrait { public static $_bar;}class Foo1 { use TestTrait;}class Foo2 { use TestTrait;}Foo1::$_bar = 'Hello';Foo2::$_bar = 'World';echo Foo1::$_bar . ' ' . Foo2::$_bar; // Prints: Hello World?>
<span style="font-size: 14px;">属性</span>
:Trait 同样可以定义属性。
Trait 定义了一个属性后,类就不能定义同样名称的属性,否则会产生 fatal error。 有种情况例外:属性是兼容的(同样的访问可见度、初始默认值)。 在 PHP 7.0 之前,属性是兼容的,则会有 E_STRICT 的提醒。
Example #12 解决冲突
<?phptrait PropertiesTrait { public $same = true; public $different = false;}class PropertiesExample { use PropertiesTrait; public $same = true; // PHP 7.0.0 后没问题,之前版本是 E_STRICT 提醒 public $different = true; // 致命错误}?>
PHP所提供的"<span style="font-size: 14px;">重载</span>
"(overloading)是指动态地"创建"类属性和方法。我们是通过魔术方法(magic methods)来实现的。
当调用当前环境下未定义或不可见的类属性或方法时,重载方法会被调用。本节后面将使用"<span style="font-size: 14px;">不可访问属性</span>
(inaccessible properties)"和"<span style="font-size: 14px;">不可访问方法</span>
(inaccessible methods)"来称呼这些未定义或不可见的类属性或方法。
This is a misuse of the term overloading. This article should call this technique "interpreter hooks".
参加魔术方法php超全局变量,魔术常量,魔术方法
Note:
因为 PHP 处理赋值运算的方式,<span style="font-size: 14px;">__set()</span>
的返回值将被忽略。类似的, 在下面这样的链式赋值中,<span style="font-size: 14px;">__get()</span>
不会被调用:<span style="font-size: 14px;">$a = $obj->b = 8; </span>
Note:
在除<span style="font-size: 14px;">isset()</span>
外的其它语言结构中无法使用重载的属性,这意味着当对一个重载的属性使用<span style="font-size: 14px;">empty()</span>
时,重载魔术方法将不会被调用。
为避开此限制,必须将重载属性赋值到本地变量再使用empty()
。
1.用 <span style="font-size: 14px;">foreach</span>
语句。默认情况下,所有可见属性都将被用于遍历。
<?phpforeach(new class(10) { public $public = []; protected $protected = [3, 4, 5]; private $private = [6, 7, 8]; function __construct($value = 1) { for ($i=0; $i < $value; $i++) { $this->public[] = $i; } } function __destruct() { foreach ($this as $key => list($a, $b, $c)) { print "$key => [$a, $b, $c]\n"; } }} as $key => list($a, $b, $c)) { print "$key => [$a, $b, $c]\n";}echo "\n";//Result:/*public => [0, 1, 2]public => [0, 1, 2]protected => [3, 4, 5]private => [6, 7, 8] */
2.实现 <span style="font-size: 14px;">Iterator</span>
接口。可以让对象自行决定如何遍历以及每次遍历时那些值可用。
<?phpclass MyIterator implements Iterator{ private $var = array(); public function __construct($array) { if (is_array($array)) { $this->var = $array; } } public function rewind() { echo "rewinding\n"; reset($this->var); } public function current() { $var = current($this->var); echo "current: $var\n"; return $var; } public function key() { $var = key($this->var); echo "key: $var\n"; return $var; } public function next() { $var = next($this->var); echo "next: $var\n"; return $var; } public function valid() { $var = $this->current() !== false; echo "valid: {$var}\n"; return $var; }}$values = array(1,2,3);$it = new MyIterator($values);foreach ($it as $a => $b) { print "$a: $b\n";}?>
可以用 <span style="font-size: 14px;">IteratorAggregate</span>
接口以替代实现所有的 <span style="font-size: 14px;">Iterator</span>
方法。<span style="font-size: 14px;">IteratorAggregate</span>
只需要实现一个方法 <span style="font-size: 14px;">IteratorAggregate::getIterator()</span>
,其应返回一个实现了 Iterator
的类的实例。
Example #3 通过实现 IteratorAggregate 来遍历对象
<?phpclass MyCollection implements IteratorAggregate{ private $items = array(); private $count = 0; // Required definition of interface IteratorAggregate public function getIterator() { return new MyIterator($this->items); } public function add($value) { $this->items[$this->count++] = $value; }}$coll = new MyCollection();$coll->add('value 1');$coll->add('value 2');$coll->add('value 3');foreach ($coll as $key => $val) { echo "key/value: [$key -> $val]\n\n";}?>
PHP 5.5 及以后版本的用户也可参考生成器,其提供了另一方法来定义 Iterators。
参见php超全局变量,魔术常量,魔术方法。
如果父类中的方法被声明为 <span style="font-size: 14px;">final</span>
,则子类无法<span style="font-size: 14px;">覆盖</span>
该方法。如果一个类被声明为 final,则不能被<span style="font-size: 14px;">继承</span>
。
属性
不能被定义为final
,只有类和方法才能被定义为final
。可以使用<span style="font-size: 14px;">const</span>
定义为常量来代替。
对象复制可以通过 <span style="font-size: 14px;">clone</span>
关键字来完成(如果可能,这将调用对象的 <span style="font-size: 14px;">__clone()</span>
方法)。对象中的 __clone() 方法不能被直接调用。
当对象被复制后,PHP 5 会对对象的所有属性执行一个<span style="font-size: 14px;">浅复制</span>
(<span style="font-size: 14px;">shallow copy</span>
)。所有的引用属性
仍然会是一个指向原来的变量的引用。
<span style="font-size: 14px;">==</span>
:如果两个对象的属性和属性值都相等,而且两个对象是同一个类的实例,那么这两个对象变量相等。<span style="font-size: 14px;">===</span>
:这两个对象变量一定要指向某个类的同一个实例(即同一个对象,但不需要引用赋值)。
<?phpfunction compareObjects(&$o1, &$o2){ echo 'o1 == o2 : ' , var_export($o1 == $o2) . "\r\n"; echo 'o1 === o2 : ' , var_export($o1 === $o2) . "\r\n";}class Flag{ public $flag; function __construct($flag = true) { $this->flag = $flag; }}class OtherFlag{ public $flag; function __construct($flag = true) { $this->flag = $flag; }}$o = new Flag;$p = new Flag;$q = $o;$r = new OtherFlag;$s = new Flag(false);echo "Two instances of the same class\r\n";compareObjects($o, $p);echo "\r\nTwo references to the same instance\r\n";compareObjects($o, $q);echo "\r\nInstances of two different classes\r\n";compareObjects($o, $r);echo "Two instances of the same class\r\n";compareObjects($o, $s);//Result:/*Two instances of the same classo1 == o2 : trueo1 === o2 : falseTwo references to the same instanceo1 == o2 : trueo1 === o2 : trueInstances of two different classeso1 == o2 : falseo1 === o2 : falseTwo instances of the same classo1 == o2 : falseo1 === o2 : false */?>
<span style="font-size: 14px;">后期静态绑定</span>
,<span style="font-size: 14px;">static::</span>
不再被解析为定义当前方法所在的类,而是在实际运行时计算的。也可以称之为“<span style="font-size: 14px;">静态绑定</span>
”,因为它可以用于(但不限于)静态方法的调用。
Example #2 static:: 简单用法
<?phpclass A { public static function who() { echo __CLASS__; } public static function test() { self::who(); static::who(); // 后期静态绑定从这里开始 }}class B extends A { public static function who() { echo __CLASS__; }}B::test();//AB?>
Finally we can implement some ActiveRecord methods:
<?php class Model { public static function find() { echo static::$name; } } class Product extends Model { protected static $name = 'Product'; } Product::find(); ?> Output: 'Product'
Notes on reference:A reference is not a pointer. However, an object handle IS a pointer. Example:<?phpclass Foo { private static $used; private $id; public function __construct() { $id = $used++; } public function __clone() { $id = $used++; }}$a = new Foo; // $a is a pointer pointing to Foo object 0$b = $a; // $b is a pointer pointing to Foo object 0, however, $b is a copy of $a$c = &$a; // $c and $a are now references of a pointer pointing to Foo object 0$a = new Foo; // $a and $c are now references of a pointer pointing to Foo object 1, $b is still a pointer pointing to Foo object 0unset($a); // A reference with reference count 1 is automatically converted back to a value. Now $c is a pointer to Foo object 1$a = &$b; // $a and $b are now references of a pointer pointing to Foo object 0$a = NULL; // $a and $b now become a reference to NULL. Foo object 0 can be garbage collected nowunset($b); // $b no longer exists and $a is now NULL$a = clone $c; // $a is now a pointer to Foo object 2, $c remains a pointer to Foo object 1unset($c); // Foo object 1 can be garbage collected now.$c = $a; // $c and $a are pointers pointing to Foo object 2unset($a); // Foo object 2 is still pointed by $c$a = &$c; // Foo object 2 has 1 pointers pointing to it only, that pointer has 2 references: $a and $c;const ABC = TRUE;if(ABC) { $a = NULL; // Foo object 2 can be garbage collected now because $a and $c are now a reference to the same NULL value} else { unset($a); // Foo object 2 is still pointed to $c}
虽然任意合法的PHP代码都可以包含在命名空间中,但只有以下类型的代码受命名空间的影响,它们是:<span style="font-size: 14px;">类</span>
(包括<span style="font-size: 14px;">抽象类</span>
和<span style="font-size: 14px;">traits</span>
)、<span style="font-size: 14px;">接口</span>
、<span style="font-size: 14px;">函数</span>
和<span style="font-size: 14px;">常量</span>
。
命名空间通过关键字 <span style="font-size: 14px;">namespace</span>
来声明。如果一个文件中包含命名空间,它必须在其它所有代码之前声明命名空间,除了一个以外:declare
关键字。
<span style="font-size: 14px;">define()</span>
will define constants exactly as specified:
Regarding constants defined with define() inside namespaces...define() will define constants exactly as specified. So, if you want to define a constant in a namespace, you will need to specify the namespace in your call to define(), even if you're calling define() from within a namespace. The following examples will make it clear.The following code will define the constant "MESSAGE" in the global namespace (i.e. "\MESSAGE").<?phpnamespace test;define('MESSAGE', 'Hello world!');?>The following code will define two constants in the "test" namespace.<?phpnamespace test;define('test\HELLO', 'Hello world!');define(__NAMESPACE__ . '\GOODBYE', 'Goodbye cruel world!');echo \test\HELLO, PHP_EOL;//Hello world!echo namespace\HELLO, PHP_EOL;//Hello world!echo constant('\\'. __NAMESPACE__ . '\HELLO') , PHP_EOL;//Hello world!echo constant(__NAMESPACE__ . '\HELLO') , PHP_EOL;//Hello world!echo HELLO, PHP_EOL;//Hello world!echo __NAMESPACE__, PHP_EOL;//test?>
也可以在同一个文件中定义多个命名空间。在同一个文件中定义多个命名空间有两种语法形式:<span style="font-size: 14px;">简单组合语法</span>
和<span style="font-size: 14px;">大括号语法</span>
。
Example #4 定义多个命名空间和不包含在命名空间中的代码
<?phpdeclare(encoding='UTF-8');namespace MyProject {const CONNECT_OK = 1;class Connection { /* ... */ }function connect() { /* ... */ }}namespace { // 全局代码session_start();$a = MyProject\connect();echo MyProject\Connection::start();}?>
(PHP 5 >= 5.3.0, PHP 7)
在讨论如何使用命名空间之前,必须了解 PHP 是如何知道要使用哪一个命名空间中的元素的。可以将 PHP 命名空间与文件系统作一个简单的类比。在文件系统中访问一个文件有三种方式:
相对文件名形式
如<span style="font-size: 14px;">foo.txt</span>
。它会被解析为 <span style="font-size: 14px;">currentdirectory/foo.txt</span>
,其中 <span style="font-size: 14px;">currentdirectory</span>
表示当前目录。因此如果当前目录是 <span style="font-size: 14px;">/home/foo</span>
,则该文件名被解析为<span style="font-size: 14px;">/home/foo/foo.txt</span>
。
相对路径名形式
如<span style="font-size: 14px;">subdirectory/foo.txt</span>
。它会被解析为 <span style="font-size: 14px;">currentdirectory/subdirectory/foo.txt</span>
。
绝对路径名形式
如<span style="font-size: 14px;">/main/foo.txt</span>
。它会被解析为<span style="font-size: 14px;">/main/foo.txt</span>
。
PHP 命名空间中的元素使用同样的原理。例如,类名可以通过三种方式引用:
非限定名称
,或不包含前缀的类名称,例如 <span style="font-size: 14px;">$a=new foo()</span>
; 或 <span style="font-size: 14px;">foo::staticmethod()</span>
;。如果当前命名空间是 <span style="font-size: 14px;">currentnamespace</span>
,<span style="font-size: 14px;">foo</span>
将被解析为 <span style="font-size: 14px;">currentnamespace\foo</span>
。如果使用 <span style="font-size: 14px;">foo</span>
的代码是全局的,不包含在任何命名空间中的代码,则 <span style="font-size: 14px;">foo</span>
会被解析为<span style="font-size: 14px;">foo</span>
。 警告:如果命名空间中的函数或常量未定义,则该非限定的函数名称或常量名称会被解析为全局函数名称或常量名称。详情参见 使用命名空间:后备全局函数名称/常量名称。
限定名称
,或包含前缀的名称,例如 <span style="font-size: 14px;">$a = new subnamespace\foo()</span>
; 或 <span style="font-size: 14px;">subnamespace\foo::staticmethod()</span>
;。如果当前的命名空间是 <span style="font-size: 14px;">currentnamespace</span>
,则 <span style="font-size: 14px;">foo</span>
会被解析为 <span style="font-size: 14px;">currentnamespace\subnamespace\foo</span>
。如果使用 <span style="font-size: 14px;">foo</span>
的代码是全局的,不包含在任何命名空间中的代码,<span style="font-size: 14px;">foo</span>
会被解析为<span style="font-size: 14px;">subnamespace\foo</span>
。
完全限定名称
,或包含了全局前缀操作符的名称,例如, <span style="font-size: 14px;">$a = new \currentnamespace\foo()</span>
; 或 <span style="font-size: 14px;">\currentnamespace\foo::staticmethod()</span>
;。在这种情况下,<span style="font-size: 14px;">foo</span>
总是被解析为代码中的文字名(literal name)<span style="font-size: 14px;">currentnamespace\foo</span>
。
下面是一个使用这三种方式的实例:
file1.php
<?phpnamespace Foo\Bar\subnamespace;const FOO = 1;function foo() {}class foo{ static function staticmethod() {}}?>
file2.php
<?phpnamespace Foo\Bar;include 'file1.php';const FOO = 2;function foo() {}class foo{ static function staticmethod() {}}/* 非限定名称 */foo(); // 解析为 Foo\Bar\foo resolves to function Foo\Bar\foofoo::staticmethod(); // 解析为类 Foo\Bar\foo的静态方法staticmethod。resolves to class Foo\Bar\foo, method staticmethodecho FOO; // resolves to constant Foo\Bar\FOO/* 限定名称 */subnamespace\foo(); // 解析为函数 Foo\Bar\subnamespace\foosubnamespace\foo::staticmethod(); // 解析为类 Foo\Bar\subnamespace\foo, // 以及类的方法 staticmethodecho subnamespace\FOO; // 解析为常量 Foo\Bar\subnamespace\FOO /* 完全限定名称 */\Foo\Bar\foo(); // 解析为函数 Foo\Bar\foo\Foo\Bar\foo::staticmethod(); // 解析为类 Foo\Bar\foo, 以及类的方法 staticmethodecho \Foo\Bar\FOO; // 解析为常量 Foo\Bar\FOO?>
注意访问任意全局类、函数或常量,都可以使用完全限定名称,例如 <span style="font-size: 14px;">\strlen()</span>
或 <span style="font-size: 14px;">\Exception</span>
或 <span style="font-size: 14px;">\INI_ALL</span>
。
Example #1 在命名空间内部访问全局类、函数和常量
<?phpnamespace Foo;function strlen() {}const INI_ALL = 3;class Exception {}$a = \strlen('hi'); // 调用全局函数strlen$b = \INI_ALL; // 访问全局常量 INI_ALL$c = new \Exception('error'); // 实例化全局类 Exception?>
php.php
<?phpnamespace testt;class cls {}function func($value='') {}const VAL = __NAMESPACE__; ?>
test.php
<?phpnamespace test { include 'php.php'; //new testt\cls; //Fatal error: Uncaught Error: Class 'test\testt\cls' not found in D:\php\test\test.php:4 //new cls; //Fatal error: Uncaught Error: Class 'test\cls' not found in D:\php\test\test.php:5 new \testt\cls; echo \testt\VAL, PHP_EOL; \testt\func();}namespace tests { use testt\cls; use testt\VAL;//未报错,也没效果 use testt\func;//未报错,也没效果 //new testt\cls; //Fatal error: Uncaught Error: Class 'test\testt\cls' not found in D:\php\test\test.php:4 new cls; new \testt\cls; echo \testt\VAL, PHP_EOL; //echo VAL, PHP_EOL; //Notice: Use of undefined constant VAL - assumed 'VAL' in D:\php\test\test.php on line 19 \testt\func(); //func(); //Fatal error: Uncaught Error: Call to undefined function test\func() in D:\php\test\test.php:21}namespace { //new cls; //Fatal error: Uncaught Error: Class 'cls' not found in D:\php\test\test.php:12 new \testt\cls; new testt\cls; echo testt\VAL, PHP_EOL; testt\func();}namespace { use testt\cls; use testt\VAL;//未报错,也没效果 use testt\func;//未报错,也没效果 new cls; new \testt\cls; new testt\cls; echo testt\VAL, PHP_EOL; testt\func(); //func(); //Fatal error: Uncaught Error: Call to undefined function func() in D:\php\test\test.php:41}//Result/*testttestttestttestt */
<span style="font-size: 14px;">常量</span><span style="font-size: 14px;">__NAMESPACE__</span>
的值是包含当前命名空间名称的字符串。在全局的,不包括在任何命名空间中的代码,它包含一个空的字符串。
关键字 <span style="font-size: 14px;">namespace</span>
可用来显式访问当前命名空间或子命名空间中的元素。它等价于类中的 self 操作符。
<?phpnamespace test;class cls {}function func($value='') {}const VAL = __NAMESPACE__;namespace\func();echo namespace\VAL;//testecho constant(__NAMESPACE__ . '\VAL');//testnew namespace\cls;
别名是通过操作符 use 来实现的:所有支持命名空间的PHP版本支持三种别名或导入方式:为类名称使用别名、为接口使用别名或为命名空间名称使用别名。
PHP 5.6开始允许导入<span style="font-size: 14px;">函数</span>
或<span style="font-size: 14px;">常量</span>
或者为它们设置别名。
Example #1 使用use操作符导入/使用别名
<?phpnamespace foo;use My\Full\Classname as Another;//为命名空间设置别名// 下面的例子与 use My\Full\NSname as NSname 相同use My\Full\NSname;// 导入一个全局类use ArrayObject;// importing a function (PHP 5.6+)use function My\Full\functionName;// aliasing a function (PHP 5.6+)use function My\Full\functionName as func;// importing a constant (PHP 5.6+)use const My\Full\CONSTANT;$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 对象func(); // calls function My\Full\functionNameecho CONSTANT; // echoes the value of My\Full\CONSTANT?>
对命名空间中的名称(包含命名空间分隔符的完全限定名称如 Foo\Bar以及相对的不包含命名空间分隔符的全局名称如 FooBar)来说,前导的反斜杠是不必要的也不推荐的,因为导入的名称必须是完全限定的,不会根据当前的命名空间作相对解析。导入操作只影响非限定名称和限定名称。完全限定名称由于是确定的,故不受导入的影响。
如果没有定义任何命名空间,所有的类与函数的定义都是在<span style="font-size: 14px;">全局空间</span>
,与 PHP 引入命名空间概念前一样。在名称前加上前缀 <span style="font-size: 14px;">\</span>
表示该名称是全局空间中的名称,即使该名称位于其它的命名空间中时也是如此。
在一个命名空间中,当 PHP 遇到一个非限定的类、函数或常量名称时,它使用不同的优先策略来解析该名称。类名称总是解析到当前命名空间中的名称。因此在访问系统内部或不包含在命名空间中的类名称时,必须使用完全限定名称,例如:
<?phpnamespace test;class Exception extends \Exception { protected $message = 'My Exception';}try { throw new Exception;//如果未定义Exception类,则会报致命错误。} catch (\Exception $e) { echo $e->getMessage();} finally { echo PHP_EOL, "finally do";}//Result/*My Exceptionfinally do */
在说明名称解析规则之前,我们先看一些重要的定义:
命名空间名称定义
非限定名称Unqualified name
名称中不包含命名空间分隔符的标识符,例如 <span style="font-size: 14px;">Foo</span>
限定名称Qualified name
名称中含有命名空间分隔符的标识符,例如 <span style="font-size: 14px;">Foo\Bar</span>
完全限定名称Fully qualified name
名称中包含命名空间分隔符,并以命名空间分隔符开始的标识符,例如 <span style="font-size: 14px;">\Foo\Bar</span>
<span style="font-size: 14px;">。 </span><span style="font-size: 14px;">namespace\Foo</span>
也是一个完全限定名称。
名称解析遵循下列规则:
对完全限定名称的函数,类和常量的调用在编译时解析。例如 <span style="font-size: 14px;">new \A\B</span>
解析为类 <span style="font-size: 14px;">A\B</span>
。
所有的非限定名称和限定名称(非完全限定名称)根据当前的导入规则在编译时进行转换。例如,如果命名空间 <span style="font-size: 14px;">A\B\C</span>
被导入为 <span style="font-size: 14px;">C</span>
,那么对 <span style="font-size: 14px;">C\D\e()</span>
的调用就会被转换为 <span style="font-size: 14px;">A\B\C\D\e()</span>
。
在命名空間內部,所有的沒有根據匯入規則轉換的限定名稱都會在其前面加上目前的命名空間名稱。例如,在命名空間<span style="font-size: 14px;">A\B</span>
內部呼叫<span style="font-size: 14px;">C\D\e()</span>
,則<span style="font-size: 14px;">C\D\e()</span>
會轉換成<span style="font-size: 14px;">A\B\C\D\ e()</span>
。
非限定類別名稱根據目前的導入規則在編譯時轉換(以全名取代短的導入名稱)。例如,如果命名空間<span style="font-size: 14px;">A\B\C</span>
導入為##C<span style="font-size: 14px;"></span>
,則<span style="font-size: 14px;"></span>new C()<span style="font-size: 14px;"></span>
轉換為<span style="font-size: 14px;"></span>#new A\B\C()<span style="font-size: 14px;"></span>## 。
<span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>#A\B<span style="font-size: 14px;"></span>),對非限定名稱的函數呼叫是在運行時解析的。例如對函數
<span style="font-size: 14px;"></span>foo()<span style="font-size: 14px;"></span>
的呼叫是這樣解析的:
<span style="font-size: 14px;"></span>
A\B\foo()<span style="font-size: 14px;"> 的函數</span>
<span style="font-size: 14px;"></span>
#foo()<span style="font-size: 14px;">。 </span>
<span style="font-size: 14px;"></span>
#A\B<span style="font-size: 14px;">)內部對非限定名稱或限定名稱類別(非完全限定名稱)的呼叫是在執行時間解析的。下面是呼叫</span>
new C()<span style="font-size: 14px;"> 和</span>
new D\E()<span style="font-size: 14px;">的解析過程: </span>
new C()<span style="font-size: 14px;">的解析:</span>
<span style="font-size: 14px;"></span>
A\B\C<span style="font-size: 14px;"></span>類別。 <span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>
A\B\C<span style="font-size: 14px;"></span>。 <span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>
##的解析:<span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>#在類別名稱前面加上目前命名空間名稱變成:
<span style="font-size: 14px;"></span>,然後尋找該類。 <span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>嘗試自動載入類別
<span style="font-size: 14px;"></span>。 <span style="font-size: 14px;"></span>
<span style="font-size: 14px;"></span>為了引用全域命名空間中的全域類,必須使用完全限定名稱
<span style="font-size: 14px;"></span>。 <span style="font-size: 14px;"></span>
相關推薦:<span style="font-size: 14px;"></span>
詳解php中的類別與物件(繼承)_php實例<span style="font-size: 14px;"></span>