[PHP] zend engine 2 OOP info

[GiLuX]

voor wie het interessant vind,
andi gutmans poste eergisteren in de zendengine2 mailing list de volgende voorbeelden van wat je kan verwachten hoe OOP er in zend engine 2.0 gaat uitzien.
aangezien daar vast niet al te veel mensen zullen opstaan hier de examples:

code:

Example 1: A singleton (static members)
=======================================

<?php

    class Counter {
        var $counter = 0;
        
        function increment_and_print()
        {
                print ++$this->counter;
                print "\n";
        }   
    }
    
    
    class SingletonCounter {
        static $m_instance = NULL;
        
        function Instance()
        {
                if (self::$m_instance == NULL) {
                    self::$m_instance = new Counter();
                }
                return self::$m_instance;
        }   
    }
    
    SingletonCounter::Instance()->increment_and_print();
    SingletonCounter::Instance()->increment_and_print();
    SingletonCounter::Instance()->increment_and_print();
    
?>

Example 2: Factory method (derefencing objects returned from functions)
=======================================================================

<?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 3: Nested class
=======================

<?php
    
    class Database {
        class MySQL {
            var $host = "";
            
            function db_connect($user) {
                print "Connecting to MySQL database '$this->host' as $user\n";
            }
        }
        
        class Oracle {
            var $host = "localhost";
            
            function db_connect($user) {
                print "Connecting to Oracle database '$this->host' as $user\n";
            }
            
        }   
    }
    
    $MySQL_obj = new Database::MySQL();
    $MySQL_obj->db_connect("John");
    
    $Oracle_obj = new Database::Oracle();
    $Oracle_obj->db_connect("Mark");

    unset($MySQL_obj);
    unset($Oracle_obj);
?>
    
Example 3: Nested class suitable for a PEAR like hierarchy
==========================================================

<?php
    
    class DB::MySQL {
        var $host = "";
        
        function db_connect($user) {
            print "Connecting to MySQL database '$this->host' as $user\n";
        }
    }
        
    class DB::Oracle {
        var $host = "localhost";
        
        function db_connect($user) {
            print "Connecting to Oracle database '$this->host' as $user\n";
        }
        
    }   
    
    $MySQL_obj = new DB::MySQL();
    $MySQL_obj->db_connect("Susan");
    
    $Oracle_obj = new DB::Oracle();
    $Oracle_obj->db_connect("Barbara");
    
?>

Example 4: Class constants and class scope
==========================================

<?php

    class ErrorCodes {
        const FATAL = "Fatal error\n";
        const WARNING = "Warning\n";
        const INFO = "Informational message\n";
        
        function print_fatal_error_codes()
        {
            print "FATAL = " . FATAL;
            print "self::FATAL = " . self::FATAL;
        }
    }
    
    /* Call the static function and move into the ErrorCodes scope */
    ErrorCodes::print_fatal_error_codes();

?>

Example 5: Regular object method using both local and global functions
======================================================================

<?php

    class HelloWorld {
        const HELLO_WORLD = "Hello, World!\n";
        
        function get_hello_world()
        {
            return HELLO_WORLD;
        }
        
        function length_of_hello_world()
        {
            $str = get_hello_world();
            return strlen($str);
        }   
    }
    
    $obj = new HelloWorld();
    print "length_of_hello_world() = " . $obj->length_of_hello_world();
    print "\n";
?>

Example 6: Multiple derefencing of objects returned from methods
================================================================

<?php


    class Name {
        function Name($_name)
        {
            $this->name = $_name;   
        }
        
        function display()
        {
            print $this->name;
            print "\n";
        }
    }
    
    class Person {
        function Person($_name, $_address)
        {
            $this->name = new Name($_name);
        }
        
        function getName()
        {
            return $this->name; 
        }
    }   

    $person = new Person("John", "New York");
    print $person->getName()->display();
    
?>

Example 7: Exception handling
=============================

<?
    class MyException {
        function MyException($_error) {
            $this->error = $_error; 
        }
        
        function getException()
        {
            return $this->error;    
        }
    }
    
    function ThrowException()
    {
        throw new MyException("'This is an exception!'");   
    }
    
    
    try {
    } catch ($exception) {
        print "There was an exception: " . $exception->getException();
        print "\n";
    }
    
    try {
        ThrowException();   
    } catch ($exception) {
        print "There was an exception: " . $exception->getException();
        print "\n";
    }
    
?>

Example 8: __clone()
===================

<?
    class MyCloneable {
        static $id = 0;
        
        function MyCloneable()
        {
            $this->id = self::$id++;
        }
        
        function __clone()
        {
            $this->name = $clone->name;
            $this->address = "New York";
            $this->id = self::$id++;
        }
    }
    

    
    $obj = new MyCloneable();

    $obj->name = "Hello";
    $obj->address = "Tel-Aviv";
    
    print $obj->id;
    print "\n";
    
    $obj = $obj->__clone();
    
    print $obj->id;
    print "\n";
    print $obj->name;
    print "\n";
    print $obj->address;
    print "\n";
?>

Example 9: Unified constructors
===============================

<?

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

Example 10: Destructors
=======================

<?php

class MyDestructableClass {
    function __construct()
    {
        print "In constructor\n";
        $this->name = "MyDestructableClass";
    }   
    
    function __destruct()
    {
        print "Destroying " . $this->name . "\n";
    }   
}

$obj = new MyDestructableClass();

?>

[Orphix]

Wel leuk om te zien, ja. Vooral de exceptie-afhandeling ziet er wel handig uit en is iets wat ik eigenlijk totaal niet had verwacht. Hopelijk gaan de PHP functies zelf ook excepties implementeren.
Maar ook hierbij vind ik het op een paar punten weer beetje knullig. PHP wil alle acties van alle talen graag benoemen en dat is een beetje vreemd.

Zo zie ik dat je een constructor met de naam van de class kan hebben en een constructor met de naam __constructor()

Ook vind ik de __clone() functie erg dubieus, moet dit een bepaalde taal feature zijn? Clonen wordt veelal gebruikt bij polymorfie, maar aangezien PHP dit niet ondersteund is het niet nodig.
Wat hier gebeurt is gewoon een aanroep van de copy-constructor, die je -al langer- gewoon kan definieren in PHP.

Maar zend engine 2.0, wanneer gaat PHP hier gebruik van maken?

[GiLuX]

Op donderdag 03 januari 2002 01:39 schreef Orphix het volgende:
..
Zo zie ik dat je een constructor met de naam van de class kan hebben en een constructor met de naam __constructor()
...

je bedoeld: __construct();

ik denk dat je mischien alleen een __desctruct() mag gebruiken als je een __construct() hebt.
geen idee eigenlijk.

wat betreft in gebruikname van ZE2,
ze zijn er zelf ook nog niet helemaal uit volgens mij,
ik verwacht dat ze het als php5 zullen uitbrengen.

[mbravenboer]

Example 2: Factory method (derefencing objects returned from functions)

Hum, das een hele merkwaardig Factory method.

Gevalsonderscheid lijkt mij absoluut geen Factory Method implementatie (das een Design Pattern uit het boek 'Design Patterns' van Erich Gamma etc).

[GiLuX]

Op donderdag 03 januari 2002 02:32 schreef mbravenboer het volgende:

[..]

Hum, das een hele merkwaardig Factory method.

Gevalsonderscheid lijkt mij absoluut geen Factory Method implementatie (das een Design Pattern uit het boek 'Design Patterns' van Erich Gamma etc).

mwah,
zover ik dat factory gebeuren heb begrepen heb je predefined welke naam welk object terug geeft en dan doormiddel van een lookup krijg je het gewenste object terug, zoals in java bv met JNDI.

dus dit is een zeer simpele methode als je het zo wilt stellen.

kans is trouwens groot dat ik nu behoorlijke wartaal uitsla

ik vraag me eigenlijk af wat dat zinnetje daarachter betekend, mischien dat dat de boel verduidelijkt,
maw, wat de hel is:"derefencing"??

[mbravenboer]

GiLuX: zover ik dat factory gebeuren heb begrepen heb je predefined welke naam welk object terug geeft en dan doormiddel van een lookup krijg je het gewenste object terug, zoals in java bv met JNDI.

Nou ja, JNDI is wel iets anders dan het design pattern Factory Method .

In een Factory Method beschrijf je in een interface een methode waarmee je een object kunt aanmaken. Subclasses beslissen echter welke klasse er aangemaakt moet worden. Als je bijvoorbeeld in dit geval een Factory Method zou willen maken zou je een interface maken "ShapeFactory" en twee subklassen: CircleFactory en SquareFactory. Deze zouden dan een Circle en een Square aanmaken, die beiden subklassen zijn van een Shape.

Je moet dus niet via parameters bepalen wat voor object er aangemaakt moet worden: dat wordt via sub-classing (of eigenlijk interface implementatie) geregeld. Op deze manier bereik je polymorfisme zonder gevalsonderscheid.

De huidige gevalsonderscheid methode heeft totaal niets met Factory Method te maken. Een Factory Method maakt bovendien meestal maar 1 soort object aan.

Het doet nog meer denken aan een Abstract Factory: hierbij definieer je in een interface een factory voor een aantal typen objecten. Je kunt deze factory interface implementeren voor verschillende verzamelingen van klassen. In dit geval zou je dan dit kunnen doen:

code:

public interface AbstractShapeFactory
{
     public Square createSquare();
     public Circle createCircle();
}

Als je nu verschillende implementaties van Square en Circles hebt (dat is in dit geval dus niet zo en dus ook niet zinvol) kan je verschillende implementaties van deze ShapeFactory maken.

ik vraag me eigenlijk af wat dat zinnetje daarachter betekend, mischien dat dat de boel verduidelijkt,
maw, wat de hel is:"derefencing"??

Das de * uit C/C++: als je een pointer hebt die je 'dereferenced' krijg je het object waarnaar de pointer wijst.

Het geheel heeft overigens wel een zeer sterk java ( -- ) gehalte .

[chem]

Toch baal ik niet van deze functies

Helaas verwacht ik dat het werken met zeer veel objecten juist weer niet veel beter wordt... bv. bij een forum: $board->show_frontpage(); waarbij die weer al $categorie->print() geeft, die weer alle fora etc...

[drm]

Ik kan nou niet zeggen dat het enorm geweldige verbeteringen zijn ofzo. Behalve try / catch -exceptionhandling vind ik er niets tussenzitten waarvan ik denk: "Dat draagt nou nog eens echt bij aan een verbeterde OOP". Maar goed, just my C 0,02

[GiLuX]

Op donderdag 03 januari 2002 09:52 schreef drm het volgende:
Ik kan nou niet zeggen dat het enorm geweldige verbeteringen zijn ofzo. Behalve try / catch -exceptionhandling vind ik er niets tussenzitten waarvan ik denk: "Dat draagt nou nog eens echt bij aan een verbeterde OOP". Maar goed, just my C 0,02

php hobbelt er dat betreft idd een beetje achteraan en ik denk ook niet dat er iets innovatiefs op het gebied van OO van php verwacht moet worden maar ik vind het in iedergeval een goede zaak dat ze niet achter willen blijven op dit gebied en gewoon wel een goede/betere basis gaan bieden zodat je in de meeste gevallen niet te kort komt.

[tomato]

Ik word hier eigenlijk niet echt warm of koud van. Zend 2 zal vast leuk worden, sommige voorbeelden die hier gegeven worden spreken me zelfs enigzins aan, maar om echt eerlijk te zijn wil ik dit helemaal niet in PHP.

Nested classes, exception handling en destructors zijn wel eens leuk, maar ik zit echt niet te wachten op cloneble objects, native singletons en factory methods (in PHP that is)

[Verwijderd]

Ogh hoewel ik veel niet zal gebruiken, het wordt wel steeds beter...

[drm]

In plaats van dat ze nou eens function overloading en typechecking gaan implementeren, maar neuhhhh...

of beter gezegd: typejuggling explementeren

zucht

[Verwijderd]

Op donderdag 03 januari 2002 15:13 schreef drm het volgende:
In plaats van dat ze nou eens function overloading en typechecking gaan implementeren, maar neuhhhh...

Type checking kan toch (get_type() oid)? Overloading ook wel met een beetje wil (als ik goed in m'n hoofd heb wat het is ).

[tomato]

drm: [function overloading]

In een bepaalde vorm kent PHP eigenlijk al function overloading.

[kvdveer]

Als er nou ook nog een goede static storage komt ben ik helemaal blij.
(zoals application("var") in asp).
Dan maak je je object forum een keer aan, en houd je alleen de belangrijke database connecties in stand om de wijzigingen bij te houden. Met een extern configuratiepanel kun je dan de balans tussen caching en database bijhouden...
Ideaal voor de performance.

[drm]

Op donderdag 03 januari 2002 15:15 schreef Zef het volgende:
Type checking kan toch (get_type() oid)? Overloading ook wel met een beetje wil (als ik goed in m'n hoofd heb wat het is ).

Ja, als je het zo bekijkt wel, maar dat is niet precies wat ik bedoel. Ik bedoel dat de compiler op typen checkt.

Dat expliciet casten verplicht wordt, e.d.

Overloading kan niet echt. Juist omdat er geen typechecking is.

[Nielsz]

Op donderdag 03 januari 2002 15:17 schreef drm het volgende:

[..]

Ja, als je het zo bekijkt wel, maar dat is niet precies wat ik bedoel. Ik bedoel dat de compiler op typen checkt.

Dat expliciet casten verplicht wordt, e.d.

Overloading kan niet echt. Juist omdat er geen typechecking is.

Dat kan je in 4.10 toch gewoon instellen in php.ini

[drm]

Nielsz:
Dat kan je in 4.10 toch gewoon instellen in php.ini

Laat onze webserver nou 4.04b hebben draaien, en laat ik er niets aan kunnen doen

Maar dat is nieuw voor mij. In hoeverre word dit ondersteund, dan?