PHP5 - Новые возможности PHP5-Zend Engine 2_0
Автор статьи: нет ©
Сайт Автора: нет
E-mail Автора: нет
Дата публикации: 27.06.2006
  1. Введение
  2. Новая объектная модель
  3. Частные и защищенные элементы класса
  4. Частные и защищенные методы
  5. Абстрактные классы и методы
  6. Интерфейсы
  7. Уточнение типа класса (Class Type Hints)
  8. Ключевое слово final
  9. Клонирование объектов
  10. Единое имя конструкторов
  11. Деструкторы
  12. Константы-элементы класса
  13. Исключения (exceptions)
  14. Разыменование объектов, возвращаемых функцией
  15. Инициализация статических переменных-элементов статических классов
  16. Статические методы
  17. Ключевое слово instanceof
  18. Статические переменные функций
  19. Значения по умолчанию для параметров, передаваемых по ссылке
  20. __autoload()
  21. Перегрузка вызовов метода и доступа к свойствам
  22. Итераторы
  23. Новая константа __METHOD__
  24. Новый метод __toString()
  25. Reflection API
  26. Новый диспетчер памяти
Введение

Этот документ - достаточно вольный перевод статьи с официального сайта PHP - http://php.net/. Если у вас нет проблем с английским языком, рекомендую ознакомиться с первоисточником.

Новая объектная модель

Обработка объектов в Zend Engine 2 полностью переработана: повышена производительность и добавлены новые возможности. В предыдущих версиях PHP объекты обрабатывались так же, как и переменные простых типов (например, целочисленные значения или строки). Недостаток такого подхода в том, что при присваивании (или передаче объекта как параметра функции) происходило копирование объекта. При новом подходе, объекты передаются по ссылке, а не по значению (если вам незнакома эта терминология, можете представить себе ссылку как уникальный идентификатор объекта).

Многие PHP-программисты никогда не задумывались об аспекте копирования объекта, присущем старой объектной модели; следовательно, большинство существующих PHP-программ при переходе на PHP5 будут нормально работать без необходимости модификации кода, или же требуемая модификация будет весьма несущественной.

Частные и защищенные элементы класса

В PHP5 введены частные (private) и защищенные (protected) переменные-элементы класса (member variables), что позволяет определять область их видимости.

Пример:

Защищенные (protected) переменные-элементы класса доступны методам (methods) класса, в котором они объявлены, и методам производного от него класса. Частные (private) элементы класса доступны только методам класса, в котором они объявлены.

<?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(); /* Выведет значение */
        print "MyClass2::printHello() " . $this->Hello; /* Ничего не выведет */
        print "MyClass2::printHello() " . $this->Bar; /* Не выведет значение (переменная не определена)*/
        print "MyClass2::printHello() " . $this->Foo; /* Выведет значение */
    }
}

$obj = new MyClass(); print $obj->Hello; /* Ничего не выведет */
print $obj->Bar; /* Ничего не выведет */
print $obj->Foo; /* Ничего не выведет */
$obj->printHello(); /* Выведет значение */

$obj = new MyClass2();
print $obj->Hello; /* Ничего не выведет */
print $obj->Bar; /* Ничего не выведет */
print $obj->Foo; /* Ничего не выведет */
$obj->printHello();
?> Частные и защищенные методы

В PHP5 также введены частные (private) и защищенные (protected) методы.

Пример:

<?php
class Foo {
    private function aPrivateMethod() {
    echo "Вызван метод Foo::aPrivateMethod().\n";
    }

    protected function aProtectedMethod() {
        echo "Вызван метод Foo::aProtectedMethod().\n";
    $this->aPrivateMethod();
    }
}

class Bar extends Foo {
    public function aPublicMethod() {
        echo "Вызван метод Bar::aPublicMethod().\n";
    $this->aProtectedMethod();
    }
}

$o = new Bar;
$o->aPublicMethod();
?>

Существующие программы, не испольующие собственные классы или функции, названные "public", "protected" или "private", будут работать без каких-либо изменений.

Абстрактные классы и методы

В PHP5 также введены абстрактные (abstract) классы и методы. Абстрактный метод представляет собой только объявление метода и не предусматривает его реализации. Класс, содержащий абстрактные методы, должен быть объявлен абстрактным.

Пример:

<?php
abstract class AbstractClass {
    abstract public function test();
}

class ImplementedClass extends AbstractClass {
    public function test() {
    echo "Вызван метод ImplementedClass::test().\n";
    }
}

$o = new ImplementedClass;
$o->test();
?>

Создание экземпляра абстрактного класса невозможно.

Существующие программы, не испольующие собственные классы или функции, названные "abstract", будут работать без каких-либо изменений.

Интерфейсы

В PHP5 введены интерфейсы (interfaces). Класс может реализовывать произвольное число интерфейсов.

Пример:

<?php
interface Throwable {
    public function getMessage();
}

class Exception implements Throwable {
    public function getMessage() {
        // ...
    }
}
?>

Существующие программы, не испольующие собственные классы или функции, названные "interface" или "implements", будут работать без каких-либо изменений.

Уточнение типа класса (Class Type Hints)

Оставаясь слабо типизированным языком, PHP5 предоставляет возможность использовать уточнения типа класса (class type hints) для указания ожидаемого класса объекта, передаваемого методу в качестве параметра.

Пример:

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

В PHP5 введено ключевое слово "final", используемое для определения финальных элементов и методов класса. Элементы и методы, в объявлении которых указано ключевое слово "final", нельзя переопределить в классе-потомке.

Пример:

<?php
class Foo {
    final function bar() {
        // ...
    }
}
?>

Также возможно использовать ключевое слово "final" в определении самого класса, что запретит создание производных от него классов. При этом все элементы и методы такого класса автоматически являются финальными, и определять их таковыми явно нет необходимости.

Пример:

<?php
final class Foo {
    // определение класса
}

// следующая строка вызовет ошибку времени выполнения
// class Bork extends Foo {}
?>

Свойства не могут быть финальными.

Существующие программы, не испольующие собственные классы или функции, названные "final", будут работать без каких-либо изменений.

[fixxxer] Примечание: в PHP все методы класса являются виртуальными.

Клонирование объектов

В PHP4 отсутствовала возможность определить конструктор копии, который бы выполнялся при создании копии объекта. PHP4 осуществлял побайтовое копирование объекта, создавая точные копии всех его свойств.

Данное поведение PHP4 не всегда позволяло достичь нужного результата. Хорошим примером необходимости конструктора копии является объект, представляющий GTK-окно и содержащий его ресурсы: при создании копии такого объекта, вам, скорее всего, хотелось бы создать новое окно с теми же свойствами, и получить объект, содержащий ресурсы нового окна. Еще один пример: объект хранит ссылку на другой используемый им объект, и при создании копии хотелось бы получить ссылку на новый экземпляр объекта, а не на тот же.

Для создания копии объекта, вызывается его метод __clone():

<?php
$copy_of_object = $object->__clone();
?>

При выполнении данной операции, PHP5 сначала проверит, определен ли метод __clone(). Если он не определен, PHP вызовет метод __clone(), созданный под умолчанию, который осуществит побайтное копирование всех свойств объекта. В случае же, если метод __clone() определен, он отвечает за установку требуемых свойств создаваемой копии объекта. Для удобства, Zend Engine предоставляет функцию, импортирующую все свойства копируемого объекта, так что достаточно переопределить только те свойства, которые необходимо изменить.

Пример:

<?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";
?> Единое имя конструкторов

PHP5 позволяет определить метод-конструктор класса. Классы, имеющие конструктор, вызывают его для каждого создаваемого объекта. Обычно конструкторы используются для присваивания переменным-элементам класса начальных значений, необходимых до использования объекта.

В PHP4 конструктором явзяется метод, который называется так же, как сам класс. Так как часто необходимо вызывать конструктор базового класса из класса производного, такой принцип именования конструкторов затрудняет работу со сложной иерархией классов. Если базовый класс изменен, приходится также менять имя вызываемого конструктора базового класса в коде производного класса.

В PHP5 введен стандартный способ объявления конструктора класса. Конструктором в PHP5 является метод с именем __construct().

Пример:

<?php
class BaseClass {
    function __construct() {
        print "В конструкторе базового класса BaseClass\n";
    }
}

class SubClass extends BaseClass {
    function __construct() {
        parent::__construct();
        print "В конструкторе производного класса SubClass\n";
    }
}

$obj = new BaseClass();
$obj = new SubClass();
?>

Для обратной совместимости, предусмотрено следующее: если PHP5 не находит функцию __construct() в определении данного класса, используется старый стиль именования конструкторов. Таким образом, единственный случай несовместимости при переходе на PHP5 - присутствие в объявлении класса метода с именем __construct().

Деструкторы

Возможность объявления деструкторов может быть весьма полезной. Деструктор может вести лог отладочных сообщений, закрывать соединения с базой данных и т.п. В PHP4 отсутствовала поддержка деструкторов, хотя имелась возможность указать функцию, которая вызывается при завершении работы скрипта.

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() в коде деструктора.

[fixxxer] Примечание: само собой разумеется, при портировании PHP4-скриптов возможной несовместимостью будет наличие методов __destruct(), используемых в других целях. Видимо, в связи с мизерной вероятностью такого случая разработчики не сочли нужным об этом упомянуть.

Константы-элементы класса

В PHP5 введены константы-элементы класса:

<?php
class Foo {
    const constant = "constant";
}

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

Существующие программы, не испольующие собственные классы или функции, названные "const", будут работать без каких-либо изменений.

Исключения (exceptions)

В PHP4 не было обработки исключений. В PHP5 реализована обработка исключений, подобно другим языкам программирования. Обратите внимание на поддержку инструкций "catch all" и "finally". Исключения можно повторно посылать из блоков catch. Также, возможно наличие нескольких блоков catch. В этом случае, полученное исключение обрабатывается первым по порядку блоком catch, instanceof которого совпадает с типом класса, экземпляром которого является исключение. При завершении работы блока catch, выполнение программы продолжается с инструкции, следующей за последним блоком catch. Если ни одного подходящего по "instanceof" блока catch не обнаружено, продолжается поиск других блоков try/catch. Если же и этот поиск не увенчается успехом, исключение считается необработанным, выводится сообщение об ошибке, и выполнение программы прерывается.

Пример:

<?php
class MyException {
    function __construct($exception) {
    $this->exception = $exception;
    }

    function Display() {
    print "MyException: $this->exception\n";
    }
}

class MyExceptionFoo extends MyException {
    function __construct($exception) {
    $this->exception = $exception;
    }

    function Display() {
        print "MyException: $this->exception\n";
    }
}

try {
    throw new MyExceptionFoo('Hello');
}
catch (MyException $exception) {
    $exception->Display();
}
catch (Exception $exception) {
    echo $exception;
}
?>

Несмотря на то, что вышеприведенный пример демонстрирует возможность определения исключения как элемента класса, не являющегося производным от класса Exception, так делать не рекомендуется, так как встроенный класс Exception позволяет собрать и вывести информацию, иначе недоступную. Примером использования данной возможности является нижеприведенный код, снабженный комментариями, описывающими каждое свойство и, соответственно, методы, используемые для чтения их значений. Так как некоторые методы используются для внутренних целей, они объявлены финальными (final). Вообще, в объявлении класса Exception довольно много ограничений, так как необходимо гарантировать совпадение ожидаемого результата с действительным.

Пример:

<?php
class Exception {
    function __construct(string $message=NULL, int code=0) {
        if (func_num_args()) {
            $this->message = $message;
        }
        $this->code = $code;
        $this->file = __FILE__; // соответствует оператору throw
        $this->line = __LINE__; // соответствует оператору throw
        $this->trace = debug_backtrace();
        $this->string = StringFormat($this);
    }

    protected $message = 'Unknown exception'; // текст сообщения об исключении
    protected $code = 0; // код исключения, определяемый пользователем
    protected $file; // имя файла, где произошло исключение
    protected $line; // строка, где произошло исключение

    private $trace; // backtrace исключения
    private $string; // только для внутреннего использования!!

    final function getMessage() {
        return $this->message;
    }
    final function getCode() {
        return $this->code;
    }
    final function getFile() {
        return $this->file;
    }
    final function getTrace() {
        return $this->trace;
    }
    final function getTraceAsString() {
    return self::TraceFormat($this);
    }
    function _toString() {
    return $this->string;
    }
    static private function StringFormat(Exception $exception) {
        // ... функция, недоступная из PHP-скриптов. Возвращает всю нужную информацию в виде строки.
    }
    static private function TraceFormat(Exception $exception) {
    // ... функция, недоступная из PHP-скриптов.
    // возвращает backtrace в виде строки
    }
}
?>

Если вы создадите ваши собственные классы исключений как производные от приведенного класса Exception, встроенный обработчик необработанных исключений выведет о них подробную информацию.

Существующие программы, не испольующие собственные классы или функции, названные "catch", "throw" или "try", будут работать без каких-либо изменений.

Разыменование объектов, возвращаемых функцией

В PHP4 не было возможности разыменования (dereferencing) объектов, возвращаемых фунцией. В PHP5 такая возможность введена, что позволяет вызывать методы возвращаемых объектов, оперируя непосредственно с результатом выполнения функции:

<?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;
    public $my_prop = 'bla';
}

print foo::$my_static;
$obj = new foo;
print $obj->my_prop;
?> Статические методы

В PHP5 ключевое слово "static" можно использовать для определения статического метода, что позволяет вызывать метод вне контекста объекта.

Пример:

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

Foo::aStaticMethod();
?>

Псевдо-переменная $this внутри метода, объявленного статическим, недоступна (так как при вызове статического метода неизвестно, в контексте какого экземпляра класса ее использовать, да и вполне возможно, что на момент вызова их не существует вообще - [fixxxer]).

Ключевое слово 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);
?> Итераторы

Для объекта можно указать итератор, который будет использован при применении класса в операторе foreach. По умолчанию итерация происходит путем перебора всех свойств.

Пример:

<?php class Foo {
    var $x = 1;
    var $y = 2;
}

$obj = new Foo;

foreach ($obj as $prp_name => $prop_value) {
    // using the property
}
?>

Каждый класс, экземпляры которого можно использовать с оператором foreach, должен реализовывать пустой интерфейс Traversable. Другими словами, любой объект, котороый реализует Traversable, можно использовать с foreach.

Интерфейсы IteratorAggregate и Iterator позволяют указать поведение класса при его использовании с оператором foreach. Первый интерфейс предоставляет единственный метод getIterator(), который должен возвращать массив или объект, который либо реализует интерфейс Iterator, либо является объектом встроенного класса, имеющего итератор.

Пример:

<?php
class ObjectIterator implements Iterator {

    private $obj;
    private $num;

    function __construct($obj) {
        $this->obj = $obj;
    }
    function rewind() {
        $this->num = 0;
    }
    function hasMore() {
        return $this->num < $this->obj->max;
    }
    function key() {
        return $this->num;
    }
    function current() {
        switch($this->num) {
            case 0: return "1st";
            case 1: return "2nd";
            case 2: return "3rd";
            default: return $this->num."th";
        }
    }
    function next() {
        $this->num++;
    }
}

class Object implements IteratorAggregate {

    public$max = 3;

    function getIterator() {
        return new ObjectIterator($this);
    }
}

$obj = new Object;

// this foreach ...
foreach($obj as $key => $val) {
    echo "$key = $val\n";
}

// matches the following 7 lines with the for directive.
$it = $obj->getIterator();
for($it->rewind(); $it->hasMore(); $it->next) {
    $key = $it->current();
    $val = $it->key();
    echo "$key = $val\n";
}
unset($it);
?>

Данный пример весьма интерестен, так как демонстрирует использование всех абстрактных методов, объявленных в интерфейсах Iterator и IteratorAggregate соответственно.

Новая константа __METHOD__

Новая псевдо-константа __METHOD__ содержит текущие имена класса и метода, если используется внутри метода, и имя функции, если используется вне класса.

Пример: Example

<?php
class Foo {
    function Show() {
        echo __FILE__ . '(' . __LINE__ . ')' . __METHOD__;
    }
}
function Test() {
    echo __FILE__ . '(' . __LINE__ . ')' . __METHOD__;
}
?> Новый метод __toString()

Новый метод __toString() позволяет перегрузить преобразование типа "объект->строка".

Пример:

<?php
class Foo {
    function __toString() {
        return "What ever";
    }
}

$obj = Foo;

$str = (string) $obj; // вызывается __toString()

echo $obj; // вызывается __toString()
?> Reflection API

PHP5 включает в себя reflection API, предоставляющий возможность реверс-инжиниринга классов, интерфейсов, функций, методов, а также расширений (extensions).

Reflection API также предоставляет доступ к doc-комментариям функций, классов и методов.

Практически все аспекты ОО-кода могут быть отражены с помощью reflection API. Reflaction API документируется отдельно.

Пример:

<?php
class Foo {
    public $prop;
    function Func($name) {
        echo "Hello $name";
    }
}

reflection_class::export('Foo');
reflection_object::export(new Foo);
reflection_method::export('Foo', 'func');
reflection_property::export('Foo', 'prop');
reflection_extension::export('standard');
?> Новый диспетчер памяти

В PHP5 используется новый диспетчер памяти, более эффективно работающий в мультитрэдовой среде, так как он не использует мутексы (mutexes) для осуществления блокирования/разблокирования (lock/unlock) при операциях выделения/освобождения памяти (allocation/deallocation). Вверх ^

 

Список похожих статей