Future of PHP

[Caminus]

Eben auf entwickler.com etwas über die ZEND 2 Engine gelesen welche in den Zukuenftigen Versionen von PHP eingesetzt wird. :)
PHP scheint sich nach dem Logischen Prinzip mehr OOP zu entwickeln was ich anhand mehrerer in den News gegebenen Beispielen aufzeigen will.

<?php
class MyDestructableClass
{
function __construct()
{
print "In constructor\n";
$this->name = 'MyDestructableClass';
}

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

Endlich werden Destruktoren unerstützt.
Für jene ohne OOP (bsp C++) Kenntnisse:

Konstruktoren werden automatisch bei der instanzierung einer klasse aufgerufen und eignen sich deshalb dazu ein Objekt korrekt zu initialisieren. Die Konstruktoren waren auch schon in Zend 1 die wir alle kennen enthalten.
Jetzt werden zudem aber auch Destruktoren unterstützt welche wie in java (nein nicht javascript ;)) dann aufgerufen werden sobald die letzte refernz auf ein object verfällt.
Dies erleichtert ungemein einen Object Orientierten Programmentwurf.

<?php
class MyDestructableClass
{
function __construct()
{
print "In constructor\n";
$this->name = 'MyDestructableClass';
}

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

$obj = new MyDestructableClass();
?>


Ausnahme handling:
Im alten PHP gabs kein korrektes Ausnahme handling. Dies machte es leider allzuoft notwendig Ausdrücke auf Durchführbarkeit zu testen bevor der Ausdrauk durchgeführt werden sollte. Durch Ausnahmehandling ist es nun möglich einen Ausdruck dürzuführen und bei scheitern eine Ausnahme zu senden und diese Abzufangen:
Bei Java / C# u. C++ einer der mächtigsten Werkzeuge kontrollierter Programmierung.

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

Ich kommentiere:
Wir schreiben 2 Klassen eine Ausnahmeklasse welche im Konstruktor mit einer ausnahme instanziert wird und eine Klasse die von dieser Ausnahmeklasse erbt. Besonders schön zu sehen ist der try{} und catch{} block welcher folgendermassen zu übersetzen ist:
versuche ein MyExceptionFoo Objekt zu senden:
Bahndle gesendete MyException Objekte.


Objecte koenenn nun als Returnwert zurückgegeben werden:

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

Statische Membervariablen statischer Klassen koennen nun initialisiert werden:

<?php
class foo
{
static $my_static = 5;
}
print foo::$my_static;
?>

Referenz Variablen koennen nun mit Standartwert übergeben werden.

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

PS: hier in diesem Beispiel wäre ein Exceptionhandling von Vorteil aber wohl zu unübersichtlich