PHP 5/Zend Engine 2.0的改进-会员卡,广州印刷,深圳印刷,印刷公司,名片,彩页,名片设计,设计教程,名片制作,彩色名片,名片模板,贵宾卡,pvc卡,设计欣赏,深圳名片,广州名片,business card design

首页	名片设计 CorelDRAW Illustrator AuotoCAD Painter 其他软件 Photoshop Fireworks Flash

» 彩色名片
» PVC卡
» 彩色磁性卡
» 彩页/画册
» 个性印务
» 彩色不干胶
» 明信片
   » 明信片
   » 彩色书签
   » 门挂
» 其他产品与服务
   » 创业锦囊
   » 办公用品
   » 信封、信纸
   » 便签纸、斜面纸砖
   » 无碳复印纸
   » 海报
   » 大篇幅印刷
   » KT板
   » 海报
   » 横幅

PHP 5/Zend Engine 2.0的改进
近两年没有使用PHP写过程序了,今天要用PHP,就在网上查了查，看到了PHP5，一时之间爱好又大了起来，于是翻译了这篇文章。
文章来源于http://www.php.net/。
新的对象模型
PHP中的对象处理部分已完全重写，具有更佳的性能和更多的功能。在先前的PHP版本中，对象被当做原始的简朴类型
（如integer和string）来处理，这种方式的缺点是当变量被赋值或作为参数传递时，得到的是对象拷贝。而在新版本中，
对象是通过句柄来引用的，而不是通过对象的值（句柄想象为对象的标识符）。
很多PHP程序员可能未意识到老的对象模型的“copying quirks“，因此以前的大多数PHP程序将不需要做任何更改
即可运行，或只做很少的改动。

私有和保护成员
PHP 5引进了私有和保护成员变量，它们可以定义可视化的类属性。
示例
保护成员变量能在该类的子类中被访问，而私有成员变量只能在所属类中被访问。
<?phpclass 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; /* 不输出任何内容，以下类同 */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)中，私有方式和保护方式也被引入。
示例：
<?phpclass 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还引入了抽象类和方式。抽象方式只声明方式的”符号”，而不提供它的实现。一个包含抽象方式的类需要声明为”abstract”。
例如：
<?phpabstract class AbstractClass { abstract public function test();}class ImplementedClass extends AbstractClass { public function test() { echo \"ImplementedClass::test() called./n\"; }}$o = new ImplementedClass;$o->test();?>
抽象类不能实例化。
旧的代码中的用户自定义类或方式中虽未定义\"abstract”要害字，但无需修改就可以运行。
接口(Interfaces)
ZEND引擎2.0引入了接口。一个类可以实现任意的接口列表。
例如：
<?phpinterface Throwable { public function getMessage();}class Exception implements Throwable { public function getMessage() { // ...}?>
旧的代码中的用户定义类或方式中虽然没有定义\"interface”要害字，但无需修改就可以正常运行。

类类型提示(Class Type Hints)
在保留类无需定义类型的同时，PHP 5引入了类类型提示来声明，以期望把对象的类通过参数传递给一个方式。
例如：
<?phpinterface 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);?>
这些类类型提示不是象一些需要类型定义的语言那样在编译中进行检查，而是在运行时进行检查。这就意味着：
<?phpfunction foo(ClassName $object) { // ...}?>
is equivalent to:
<?phpfunction foo($object) { if (!($object instanceof ClassName)) { die(\"Argument 1 must be an instance of ClassName\"); }}?>
这种语法只用于对象或类，不适用于内建(built-in)类型。

Final要害字（final）
PHP 5引入了“final”要害字以定义在子类中不能被覆盖的成员或方式。
例：
<?php
class Foo { final function bar() { // ... }}?>
以前所写代码中的用户自定义类或方式中虽未定义\"final\"要害字，但无需修改就可以运行了。
对象克隆(Object Cloning)
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中当类在一个大型的类继续中进行移动时，处理方法有点笨拙。当一个派生类被移动到一个不同
的父类中时，父类的构造方式名必然是不同的，这样的话派生类中的有关调用父类构造方式的语句需要改写。
PHP5引入了一个定义构造方式的标准方法，通过调用它们的__construct()来定义。
示例：
<?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已支持注册在哀求结束时需要运行的函数。
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 引入了类常量（per-class constants）定义：
<?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”要害字，
但无需修改就可以运行。

非常(Exceptions)
PHP4中没非常处理，PHP5引入了与其它与语言相似的非常处理模型。
<?php
class MyExceptionFoo extends Exception {
function __construct($exception) {
parent::__construct($exception);
}
}

try {
throw new MyExceptionFoo(\"Hello\");
} catch (MyExceptionFoo $exception) {
print $exception->getMessage();
}
?>

以前代码中的用户自定义类或方式中虽未定义\\\'catch\\\', \\\'throw\\\' 和 \\\'try\\\'要害字，但无需修改
就可以运行。

函数返回对象值
在PHP4中，函数不可能返回对象的值并对返回的对象进行方式调用，随着Zend Engine 2
（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();
?>

静态类中的静态成员变量可初始化
例如：
<?php
class foo {
static $my_static = 5;
}

print foo::$my_static;
?>

静态方式(Static Methods)
PHP5引入了要害字\\\'static\\\'来定义一个静态方式，这样可以从对象外进行调用。
例如：

<?php
class Foo {
public static function aStaticMethod() {
// ...
}
}

Foo::aStaticMethod();
?>

虚拟变量$this在被定义为静态(static)的方式中无效。

Instanceof

PHP5引入了 “instanceof“要害字来确定一个对象是否是某一个对象的实例，或某一个对象的派生，或使用了某一个接口。

示例：

<?php
class baseClass { }

$a = new baseClass;

if ($a instanceof basicClass) {
echo \"Hello World\";
}
?>

静态函数变量(Static function variables)
所有的静态变量现在在编译时进行处理，这答应开发者通过引用来指定静态变量。这个变化提高了效率但意味着不可能对静态变量进行间接引用。

函数中通过引用方法传递的参数答应有默认值
例如：

<?php
function my_function(&$var = null) {
if ($var === null) {
die(\"$var needs to have a value\");
}
}
?>

__autoload()

在初始化一个未定义的类时，__autoload()拦截函数（interceptor function）将被自动调
用。类名将作为__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);
?>

返回类别: 教程
上一教程: 第七节--类的静态成员 -- Classes and Objects in PHP5 [7]
下一教程: 在PHP中用Socket发送电子邮件(四)

您可以阅读与"PHP 5/Zend Engine 2.0的改进"相关的教程:
· PHP5/ZendEngine2的改进
· 修改Zend引擎实现PHP源码加密的原理及实践
· 修改Zend引擎实现PHP源码加密的原理及实践
· 第十五节--Zend引擎的发展 -- Classes and Objects in PHP5 [15]
· 用Zend Encode编写开发PHP程序


	快精灵印艺坊版权所有	首页会员中心在线印刷在线编辑付款方式索取样品设计指南连锁门店网站地图关于我们友情链接