PHP 5昨天隆重推出–PHP 5/Zend Engine 2.0新特性

前言

今天突然想到PHP官方網站上一轉，一眼就看到PHP5推出的通告。雖然以前看到過PHP5的預告，但還是仔細看了PHP 5/Zend Engine 2.0新特性一文，一股JAVA氣息撲面而來...
特將該文試譯出來，首發於CSDN網站，以饗讀者。

PHP 5/Zend Engine 2.0新特性
徐喚春 譯 sfwebsite@hotmail.com
http://www.php.net/zend-engine-2.php

全新的物件模型
PHP中的對象處理部分已完全重寫，具有更佳的效能和更多的功能。在PHP的以前版本中，對象與內建變數類型（如integer和string）的處理方法相同，其弊端是當變數被賦值為對象或對象作為參數傳遞時，得到的是對象複製品。而在新版本中，對象通過控制代碼進行引用，而不是通過它的值。（控制代碼可以認是為是對象的標識符）
很多PHP程式員可能未意識到以前的物件模型的“複製怪癖”，因此以前的PHP程式將不需要做任何更改，或只做很小的改動即可運行
私人和保護成員
PHP 5引入了私人和保護成員變數，它們可以定義類屬性在何時可以被訪問。
例
類的保護成員變數能在該類的擴充類中被訪問，而私人成員變數只能在本類中被訪問。
<?php
class MyClass {
private $Hello = "Hello, World!\n";
protected $Bar = "Hello, Foo!\n";
protected $Foo = "Hello, Bar!\n";

function printHello() {
print "MyClass::printHello() " . $this->Hello;
print "MyClass::printHello() " . $this->Bar;
print "MyClass::printHello() " . $this->Foo;
}
}

class MyClass2 extends MyClass {
protected $Foo;

function printHello() {
MyClass::printHello(); /* Should print */
print "MyClass2::printHello() " . $this->Hello; /* Shouldn't print out anything */
print "MyClass2::printHello() " . $this->Bar; /* Shouldn't print (not declared)*/
print "MyClass2::printHello() " . $this->Foo; /* Should print */
}
}

$obj = new MyClass();
print $obj->Hello; /* Shouldn't print out anything */
print $obj->Bar; /* Shouldn't print out anything */
print $obj->Foo; /* Shouldn't print out anything */
$obj->printHello(); /* Should print */

$obj = new MyClass2();
print $obj->Hello; /* Shouldn't print out anything */
print $obj->Bar; /* Shouldn't print out anything */
print $obj->Foo; /* Shouldn't print out anything */
$obj->printHello();
?>
私人和保護方法
在PHP 5(ZEND引擎2)中，還引入了私人和保護方法。
例：
<?php
class Foo {
private function aPrivateMethod() {
echo "Foo::aPrivateMethod() called.\n";
}

protected function aProtectedMethod() {
echo "Foo::aProtectedMethod() called.\n";
$this->aPrivateMethod();
}
}

class Bar extends Foo {
public function aPublicMethod() {
echo "Bar::aPublicMethod() called.\n";
$this->aProtectedMethod();
}
}

$o = new Bar;
$o->aPublicMethod();
?>
以前代碼中的使用者自訂類或方法中雖未定義"public," "protected" 或 "private"等關鍵字，但無需編輯即可運行。
抽象類別和方法
PHP 5還引入了抽象類別和方法。抽象方法只聲明方法定義， 不供實際運行。包含抽象方法的類需要聲明為抽象類別。
例：
<?php
abstract class AbstractClass {
abstract public function test();
}

class ImplementedClass extends AbstractClass {
public function test() {
echo "ImplementedClass::test() called.\n";
}
}

$o = new ImplementedClass;
$o->test();
?>
抽象類別不能執行個體化。以前代碼中的使用者自訂類或方法中雖未定義"abstract”關鍵字，但無需編輯即可運行。
介面
ZEND引擎2.0引入了介面。一個類可以運行任意的介面列表。
Example
例：
<?php
interface Throwable {
public function getMessage();
}

class Exception implements Throwable {
public function getMessage() {
// ...
}
?>
以前代碼中的使用者自訂類或方法中雖未定義"interface”關鍵字，但無需編輯即可運行。
類類型定義
在保留類無需定義類型的同時，PHP 5引入了類類型定義來聲明希望把哪個類通過參數傳遞給一個方法。
Example
例：
<?php
interface Foo {
function a(Foo $foo);
}

interface Bar {
function b(Bar $bar);
}

class FooBar implements Foo, Bar {
function a(Foo $foo) {
// ...
}

function b(Bar $bar) {
// ...
}
}

$a = new FooBar;
$b = new FooBar;

$a->a($b);
$a->b($b);
?>
這些類類型定義在不象一些需要類型預定義的語言在編譯中進行檢查，而是在運行時進行。這意味著：
<?php
function foo(ClassName $object) {
// ...
}
?>
等價於：
<?php
function foo($object) {
if (!($object instanceof ClassName)) {
die("Argument 1 must be an instance of ClassName");
}
}
?>
本文法只用於對象或類，不適用於內建類型。

final
PHP 5引入了“final”關鍵字定義在子類中不能被覆蓋的成員或方法。
例：
<?php
class Foo {
final function bar() {
// ...
}
}
?>
以前代碼中的使用者自訂類或方法中雖未定義"final"關鍵字，但無需編輯即可運行。
對象複製
PHP 4在對象被複製時，使用者不能決定拷貝的機制。在複製時，PHP 4隻一位一位地複製一個和原來對象一模一樣的複製品。
我們並不是每次都要建立一個完全一樣的複製品。一個很好的需要一種複製機制的例子是，當有一個代表一個GTK視窗的對象，它擁有該視窗的所有資源，當你建立一個拷貝時，你可能需要一個新的視窗，它擁有原視窗的所有屬性，但需要擁有新視窗的資源。另外一個例子是你有一個對象引用了另外一個對象，當你複製父物件時，你希望建立那個引用對象的新執行個體，以使複製品引用它。
對一個對象的拷貝通過調用對象的__clone()方法完成：
<?php
$copy_of_object = $object->__clone();
?>
當開發人員請求建立一個對象的新的拷貝時，ZEND引擎會檢查是否定義了__clone()方法。如果未定義的話，它會調用一個預設的__clone()方法來複製該對象的所有屬性。如果定義了該方法，該方法會負責在拷貝中設定必要的屬性。為方便起見，引擎會提供一個函數從來源物件中匯入所有的屬性，這樣它就可以先得到一個具有值的來源物件拷貝，只需要對需要改變的屬性進行覆蓋即可。
例：
<?php
class MyCloneable {
static $id = 0;

function MyCloneable() {
$this->id = self::$id++;
}

function __clone() {
$this->name = $that->name;
$this->address = "New York";
$this->id = self::$id++;
}
}

$obj = new MyCloneable();

$obj->name = "Hello";
$obj->address = "Tel-Aviv";

print $obj->id . "\n";

$obj = $obj->__clone();

print $obj->id . "\n";
print $obj->name . "\n";
print $obj->address . "\n";
?>
統一的構造方法名
ZEND引擎允許開發人員定義類的構造方法。具有構造方法的類在建立時會首先調用構造方法，構造方法適用於在正式使用該類前進行的初始化。
在PHP4中，構造方法的名稱與類名相同。由於在衍生類別中調用父類的作法比較普遍，因此導致在PHP4中當類在一個大型的類繼承中進行移動時，處理方式有點笨拙。當一個衍生類別被移動到一個不同的父類中時，父類的構造方法名必然是不同的，這樣的話衍生類別中的有關調用父類構造方法的語句需要改寫。
PHP 5 introduces a standard way of declaring constructor methods by calling them by the name __construct().
PHP5引入了方法名__construct()來定義構造方法。
Example
<?php
class BaseClass {
function __construct() {
print "In BaseClass constructor\n";
}
}

class SubClass extends BaseClass {
function __construct() {
parent::__construct();
print "In SubClass constructor\n";
}
}

$obj = new BaseClass();
$obj = new SubClass();
?>
為向下相容，PHP5當在類不能找到__construct()方法時，會通過老的方法也就是類名來尋找構造方法。這意味著唯一可能產生相容性問題的是在以前的代碼中已經使用了一個名為__construct()的方法名。
析構方法
定義析構方法是十分有用的。析構方法可以記錄調試資訊，關閉資料庫連接，還有做其它的掃尾工作。PHP4中並無此機制，儘管PHP已支援註冊在請求結束時需要啟動並執行函數。
PHP 5 introduces a destructor concept similar to that of other object-oriented languages, such as Java: When the last reference to an object is destroyed the object's destructor, which is a class method name %__destruct()% that recieves no parameters, is called before the object is freed from memory.
PHP5引入了與其它物件導向語言如Java語言相似的析構方法：當最後一個該對象的引用被清除時，系統將會在該對象從記憶體中釋放前調用名為__destruct()的析構方法。
例：
<?php
class MyDestructableClass {
function __construct() {
print "In constructor\n";
$this->name = "MyDestructableClass";
}

function __destruct() {
print "Destroying " . $this->name . "\n";
}
}

$obj = new MyDestructableClass();
?>
和構造方法相似，引擎將不調用父類的析構方法，為調用該方法，你需要在子類的析構方法中通過parent::__destruct()語句進行調用。
常量
PHP 5 引入了類常量定義：
<?php
class Foo {
const constant = "constant";
}

echo "Foo::constant = " . Foo::constant . "\n";
?>

PHP5允許常量中有運算式，但在編譯時間常量中的運算式將被計算.，因此常量不能在運行中改變它的值。
<?php
class Bar {
const a = 1<<0;
const b = 1<<1;
const c = a | b;
}
?>
以前代碼中的使用者自訂類或方法中雖未定義"const”關鍵字，但無需編輯即可運行。
例外
PHP 4 had no exception handling. PHP 5 introduces a exception model similar to that of other programming languages.
PHP4中無例外處理，PHP5引用了與其它語言相似的例外處理模型。
例：
<?php
class MyExceptionFoo extends Exception {
function __construct($exception) {
parent::__construct($exception);
}
}

try {
throw new MyExceptionFoo("Hello");
} catch (MyException $exception) {
print $exception->getMessage();
}
?>
以前代碼中的使用者自訂類或方法中雖未定義'catch', 'throw' 和 'try'關鍵字，但無需編輯即可運行。
函數返回對象值
In PHP 4 it wasn't possible to dereference objects returned by functions and make further method calls on those objects. With the advent of Zend Engine 2, the following is now possible:
在PHP4中，函數不可能返回對象的值並對返回的對象進行方法調用，通過ZEND引擎2中，這一切變得可能：
<?php
class Circle {
function draw() {
print "Circle\n";
}
}

class Square {
function draw() {
print "Square\n";
}
}

function ShapeFactoryMethod($shape) {
switch ($shape) {
case "Circle":
return new Circle();
case "Square":
return new Square();
}
}

ShapeFactoryMethod("Circle")->draw();
ShapeFactoryMethod("Square")->draw();
?>
靜態類中的靜態成員變數現在可初始化
Example
<?php
class foo {
static $my_static = 5;
}

print foo::$my_static;
?>
靜態方法
PHP5引入了關鍵字'static'來定義一個靜態方法，這樣可以從對象外進行調用。
例：
<?php
class Foo {
public static function aStaticMethod() {
// ...
}
}

Foo::aStaticMethod();
?>
虛擬變數$this在靜態方法中無效。
instanceof
PHP5引入了關鍵字instanceof來確定一個對象是否是某一個對象的執行個體，或某一個對象的派生，或使用了某一個介面。
例：
<?php
class baseClass { }

$a = new baseClass;

if ($a instanceof basicClass) {
echo "Hello World";
}
?>
靜態函數變數
所有的靜態變數現在在編譯時間進行處理，這允許開發人員通過引用來指定靜態變數。這個變化提高了效率但意味著不可能對靜態變數進行間接引用。
函數中通過按地址傳送方式的參數允許定義預設值
例：
<?php
function my_function(&$var = null) {
if ($var === null) {
die("$var needs to have a value");
}
}
?>
__autoload()
在初始化一個未定義的類時，引擎將自動調用__autoload()攔截器函數。該類名將作為__autoload()攔截器函數唯一參數傳遞給它。
例：
<?php
function __autoload($className) {
include_once $className . ".php";
}

$object = new ClassName;
?>
方法和屬性調用的重載
通用 __call(), __get() 和 __set()方法可以進行方法和屬性調用的重載。

例: __get() 和 __set()
<?php
class Setter {
public $n;
public $x = array("a" => 1, "b" => 2, "c" => 3);

function __get($nm) {
print "Getting [$nm]\n";

if (isset($this->x[$nm])) {
$r = $this->x[$nm];
print "Returning: $r\n";
return $r;
} else {
print "Nothing!\n";
}
}

function __set($nm, $val) {
print "Setting [$nm] to $val\n";

if (isset($this->x[$nm])) {
$this->x[$nm] = $val;
print "OK!\n";
} else {
print "Not OK!\n";
}
}
}

$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump($foo);
?>
例: __call()
<?php
class Caller {
var $x = array(1, 2, 3);

function __call($m, $a) {
print "Method $m called:\n";
var_dump($a);
return $this->x;
}
}

$foo = new Caller();
$a = $foo->test(1, "2", 3.4, true);
var_dump($a);
?>