XCII. Przeciążanie właściwości obiektów i wołania ich metod

Wstęp

Celem tego rozszerzenia jest umożliwienie przeciążania dostępu do właściwości obiektów oraz wołania metod. Rozszerzenie to definiuje tylko jedną funkcję, overload(), która przyjmuje jako parametr nazwę klasy dla której przeciążanie powinno być udostępnione. Klasa ta powinna mieć zdefiniowane odpowiednie metody, jeżeli chce korzystać z tej dodatkowej funkcjonalności: __get(), __set() oraz __call() odpowwiednio dla pobierania/ustawiania wartości właściwości, lub wołania metod. Tym sposobem przeciążanie może być dostępne wybiórczo. Wewnątrz tych funkcji bsługujących przeciążanie, ono samo jest niedostępne by mieć możliwość normalnego dostępu do właściwości obiektu.

Ostrzeżenie

Ten moduł jest w stadium EKSPERYMENTALNYM. Oznacza to, że zachowanie tych funkcji, ich nazwy, w zasadzie wszystko udokumentowane tutaj może zostać zmienione w przyszłych wersjach PHP bez wcześniejszego uprzedzenia. Używaj tego modułu na własne ryzyko.

Wymagania

Do zbudowania tego rozszerzenia nie są wymagane żadne zewnętrzne biblioteki.

Instalacja

Chcąc używać tych funkcji musisz skompilować PHP z opcją --enable-overload. Od PHP 4.3.0 to rozszerzenie jest włączone domyślnie. Możesz wyłączyć wsparcie dla przeciążania opcją --disable--overload.

PHP w wersji dla systemów Windows posiada wbudowaną obsługę dla tego rozszerzenia. Nie trzeba ładować żadnych dodatkowych rozszerzeń aby korzystać z tych funkcji.

Notatka: Wsparcie dla przeciążania jest wbudowane od wersji PHP 4.3.0.

Konfiguracja czasu wykonywania

To rozszerzenie nie definiuje posiada żadnych dyrektyw konfiguracyjnych w pliku php.ini.

Typy zasobów

To rozszerzenie nie posiada żadnych rodzajów zasobów.

Stałe predefinopwane

To rozszerzenie nie posiada żadnych stałych.

Przykłady

Kilka prostych przykładów demonstrujących użycie funkcji overload():

Przykład 1. Przeciążanie klasy PHP


<?php



class OO

{

    var $a = 111;

    var $elem = array('b' => 9, 'c' => 42);



    // Funkcja obsługująca pobierania właściwości

    function __get($wl_nazwa, &$wl_wart)

    {

        if (isset($this->elem[$wl_nazwa])) {

            $wl_wart = $this->elem[$wl_nazwa];

            return true;

        } else {

            return false;

        }

    }



    // Funkcja obsługująca ustawianie właściwości

    function __set($wl_nazwa, $wl_wart)

    {

        $this->elem[$wl_nazwa] = $wl_wart;

        return true;

    }

}



// Umożliwiamy przeciążanie obiektów klasy OO

overload('OO');



$o = new OO;

print "\$o->a: $o->a\n"; // print: $o->a:

print "\$o->b: $o->b\n"; // print: $o->b: 9

print "\$o->c: $o->c\n"; // print: $o->c: 42

print "\$o->d: $o->d\n"; // print: $o->d:



// dodajemy nową pozycję do tablicy $elem w OO

$o->x = 56; 



// tworzymy egzemplarz klasy stdclass (wbudowanej w PHP 4)

// $val nie jest przeciążane!

$val = new stdclass;

$val->prop = 555;



// Ustawiamy "a" jako tablicę z obiektem $val w środku

// Lecz __set() włoży to do tablicy $elem

$o->a = array($val);

var_dump($o->a[0]->prop);



?>

Ostrzeżenie

Ponieważ jest to rozszerzenie eksperymentalne, nie wszystko działa. Brakuje aktualnie wsparcia dla __call(), można przeciążać tylko operacje pobierania i ustawiania właściwości obiektu. Nie można także wołać funkcji obsługi przeciążania jak normalnych metod istniejących w klasie, a __set() działa tylko do jednego poziomu dostępu do właściwości.

Spis treści
overload -- Umożliwienie przeciążania właściwości i wołania metod dla klasy

User Contributed Notes


Here is a cleaner way to fake overloading which is a modification on fabiostt[X_AT_X]libero[X_DOT_X]it

12-Aug-2003 01:56 posting. This example allows you to reuse the object and not have to re-create the object everytime the variables need to change.



Hope this helps,



<?

Class NCSession

{

//Class Variables



    Var $sessionResult = null;



    // Sims Overloading in PHP - Yes it is crap but it works until you move to PHP 5.

    function ncStartSession()

    {

        $numArgs = func_num_args() ; //number of args

        $args = func_get_args() ;  //array containing args

        $x = call_user_func_array( array( &$this, 'ncStartSession'.$numArgs),  $args) ;

        $sessionResult = $x;

        return $sessionResult;

    }



    function ncStartSession0()

    {

        session_start();

        $sessionResult = "SUCCESS|YES|SESSIONID|" . session_id(); 

        session_destroy();

        return $sessionResult;

    }



    function ncStartSession1($arg)

    {

        session_start($arg);

        $sessionResult = "SUCCESS|YES|SESSIONID|" . session_id(); 

        session_destroy();

        return $sessionResult;

        }

}

//End of Class



$myTestSession = NEW NCSession();



$myResult = $myTestSession->ncStartSession();

echo "\n\$myResult = $myResult\n";



?>


Overload and Inheritance.



After wasting a few hours trying to get it to work, it seems appropriate to put a warning here.



Short Version:



DON'T ever subclass an overloaded class. EVER.



Corollary:

If an overloaded class simply must be subclassed, rewrite the parent class to get rid of the overloading. It can be as simple as commenting out the overload() statement and calling the get/set/call methods explicitely. 

This was the road I ended up taking.



Long Version:



While it is, in theory, possible to end up with a working subclass, it requires much mucking and OO-principles compromise. 

There is a great post that details the problem at great length. For those with the stomach, the URL is:

http://www.zend.com/lists/engine2/200201/msg00140.html



If you're still thinking about mixing inheritance and overloading, at least read the "Best Practices for the overload functions" in the URL above. If that doesn't change your mind, at least you'll be able to avoid most of the pitfalls.


The following backwards compatible code demonstrates the differences between the PHP version 4 and 5 implementation of overloading:



<?



class Foo {

    // The properties array

    var $array = array('a' => 1, 'b' => 2, 'c' => 4);



    // Getter

    function __get($n, $val = "") {

        if (phpversion() >= 5) {

            return $this->array[$n];

        } else {

            $val = $this->array[$n];

            return true;

        }

    }

    

    // Setter

    function __set($n, $val) {

        $this->array[$n] = $val;

        if (phpversion() < 5) return true;

    }

    

    // Caller, applied when $function isn't defined

    function __call($function, $arguments) {

        // Constructor called in PHP version < 5

        if ($function != __CLASS__) {

            $this->$arguments[0] = $arguments[1];

        }

        if (phpversion() < 5) return true;

    }

}



// Call the overload() function when appropriate

if (function_exists("overload") && phpversion() < 5) {

    overload("Foo");

}



// Create the object instance

$foo = new Foo;



// Adjust the value of $foo->array['c'] through 

// method overloading

$foo->set_array('c', 3);



// Adjust the value of $foo->array['c'] through 

// property overloading

$foo->c = 3;



// Print the new correct value of $foo->array['c']

echo 'The value of $foo->array["c"] is: ', $foo->c;



?>


I've found a work around that allows overload to work with nested classes.  I was trying to design a set of classes that I didn't need to define the setter/getter methods for each of the properties.  



I stayed away from the __get() and __set() function since this bypasses object encapsulation.  Instead I use the __call() method to implement the accessor functions.  The __call() function emulates the get{var name} and stores the variable into an internal array with in the class.  The get{var name} checks the array for the var name and returns it if found.



Using the Zend Dev Studio (Great Product!) I was able to debug the code and found that when overloaded objects are nested that the nested object somehow looses the array var.  Just for giggles, I added a second variable and assigned the array var by reference.  Some how this worked.  



class Base {

   var $_prop = array();

   var $_fix;

   

   function Base() {

      // This somehow fixes the problem with nested overloading

      $this->_fix = & $this->_prop;  

   }

}


there are a couple of things you should be aware of when using overloading.



<?

    class cTest

    {

        function __get($key, &$value)

        {

            echo "get: $key<br />";

            return true;

        }

        function __set($key, $value)

        {

            echo "set: $key value: $value<br />";

            return true;

        }

        function __call($method, $params, &$return)

        {

            echo "call: $method params: " . var_export($params, 1) . "<br />";

            return true;

        }

    }

overload('cTest');

$cake = new cTest;

?>



firstly it should be noted that nested classes don't work.

secondly if you try to set an array it somehow becomes a get

and thirdly, if you call a nested class it picks the last nest as the method name, as opposed to a nested get which picks the first in the list.

<?

$x = $cake->hello->moto; //outputs "get: hello" moto is nowhere to be seen



$cake->hello['moto'] = 4; //outputs "get: hello"



$cake->moo->cow("hello"); //outputs "call: cow params: array ( 0 => 'hello', )"

?>

bit strange, these occur on php4.3.2. havn't tried other versions


Some useful things to know about overloading:

__call($m,$p,&$r) returns $r back to you, not whatever you put after the keyword return.  What you return determines whether or not the parser consideres the function defined.

__get($var,&$val) returns $val back to you, so fill up $val with what you want then return true or false, same as above.



when extending classes, you must overload the most extended level class for it to work:



class TestClass

{

    var $x = "x";

    var $y = "y";

    var $z = "z";

    function __call($method,$params,&$return)

    {

        $return = "Hello, you called $method with ".var_export($params,true)."<br>\n";

        return true;

    }

    function __get($var,&$val)

    {

        if($var == "l") { $val = $this->x; return true; }

        return false;

    }

}

overload('TestClass');



$test = new TestClass;

print $test->hello();

print $test->goodbye();

print $test->x;

print $test->l;

print $test->n;



class Test2 extends TestClass

{

}



$test2 = new Test2;

print $test2->hello();



/* output:

Hello, you called hello with array()

Hello, you called goodbye with array()

xx



Fatal Error: Call to undefined function hello() in ...

*/


This extension has not much to do with overloading as we know it in Java or C++



We can sort of mimic overloading using call_user_func_array()



<?php



class OverloadTest{



    var $message ;



    function OverloadTest(){



        $numArgs = func_num_args() ; //number of args



        $args = func_get_args() ;  //array containing args



        call_user_func_array( array( &$this, 'OverloadTest'.$numArgs),  $args) ; 



    }



    function overloadTest0(){



       $this->message = 'There are no args' ;



    }



    function overloadTest1($arg){



       $this->message = 'There\'s just one arg, its value is '.$arg ;



    }

        

        function overloadTest2($arg1, $arg2){



       $this->message = 'There are 2 args, their values are '.join( func_get_args(), ', ') ;



    }

        

        function getMessage(){

        

            return($this->message) ;

        

        }



}//end class



$x = new OverloadTest('fooA', 'fooB') ;



echo( $x->getMessage() ) ;



?>