|
|
 |
LXXIX. Proprietà object e method call overloading| Attenzione | Questo modulo è
SPERIMENTALE. Ovvero, il comportamento di queste
funzioni, i nomi di queste funzioni, in definitiva tutto ciò
che è documentato qui può cambiare nei futuri rilasci
del PHP senza preavviso. Siete avvisati, l'uso di questo modulo
è a vostro rischio. |
Lo scopo di questa estensione è di permettere l'overloading delle proprietà
di accesso agli oggetti e dei metodi di chiamata. Solo una funzione è definita
in questa estensione, overload() che prende il
nome dalla classe che ha questa funzionalità abilitata.
La classe nominata ha da definire metodi appropriati se
vuole avere questa funzionalità: __get(),
__set() and __call()
rispettivamente per ricevere/impostare una proprietà, o chiamare un metodo.
Questa strada del sovraccarico può essere selettiva. Dentro queste
funzioni handler l'overloading è disabilitato così si può accedere
alle proprietà dell'oggetto normalmente.
Alcuni semplici esempi sull'uso della funzione
overload()
Esempio 1. Overloading di una classe PHP |
<?php
class OO
{
var $a = 111;
var $elem = array('b' => 9, 'c' => 42);
function __get($prop_name, &$prop_value)
{
if (isset($this->elem[$prop_name])) {
$prop_value = $this->elem[$prop_name];
return true;
} else {
return false;
}
}
function __set($prop_name, $prop_value)
{
$this->elem[$prop_name] = $prop_value;
return true;
}
}
overload('OO');
$o = new OO;
print "\$o->a: $o->a\n"; print "\$o->b: $o->b\n"; print "\$o->c: $o->c\n"; print "\$o->d: $o->d\n"; $o->x = 56;
$val = new stdclass;
$val->prop = 555;
$o->a = array($val);
var_dump($o->a[0]->prop);
?>
|
|
| Attenzione |
Siccome è una estensione sperimentale, non tutto
funziona. Non c'è attualmente il supporto per
__call(),
puoi solo overloadare le operazioni di ricezione e di impostazione
per le proprietà. Non puoi invocare l'overloading
handlers originale della classe, e
__set() funziona solo su un livello
di proprietà di accesso.
|
- Sommario
- overload -- Abilita le proprietà e il method call overloading per una classe
 add a note
User Contributed Notes
Proprietà object e method call overloading
Metal
15-Mar-2004 05:11
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.
josh at uncommonprojects dot com
28-Feb-2004 12:45
One thing about __get is that if you return an array it doesn't work directly within a foreach...
<?php
class Foo {
function __get($prop,&$ret) {
$ret = array(1,2,3);
return true;
}
}
overload ('Foo');
$foo = new Foo;
$bar = $foo->bar;
foreach($bar as $n) {
echo "$n \n";
}
foreach($foo->bar as $n) {
echo "$n \n";
}
?>
for loops also work fine..
upphpdoc at upcd dot de
25-Feb-2004 06:58
While this is a nice Feature it has nothing to do with Overloading as it is known in other OO-Languages.
What this feature does is allowing the dynamic addition of instance variables as e.g in Python.
Overloading means defining several methods with the same name in a single class. Which method will be called depends on the number and type of arguments specified. With dynamic and weak typed languages (like PHP) this can of course not work.
jw at jwscripts dot com
14-Feb-2004 05:10
The following backwards compatible code demonstrates the differences between the PHP version 4 and 5 implementation of overloading:
<?
class Foo {
var $array = array('a' => 1, 'b' => 2, 'c' => 4);
function __get($n, $val = "") {
if (phpversion() >= 5) {
return $this->array[$n];
} else {
$val = $this->array[$n];
return true;
}
}
function __set($n, $val) {
$this->array[$n] = $val;
if (phpversion() < 5) return true;
}
function __call($function, $arguments) {
if ($function != __CLASS__) {
$this->$arguments[0] = $arguments[1];
}
if (phpversion() < 5) return true;
}
}
if (function_exists("overload") && phpversion() < 5) {
overload("Foo");
}
$foo = new Foo;
$foo->set_array('c', 3);
$foo->c = 3;
echo 'The value of $foo->array["c"] is: ', $foo->c;
?>
sdavey at datalink dot net dot au
23-Jan-2004 07:45
It wasn't quite clear, but I found out that __get() and __set() only overload attributes that _don't_ exist.
For example:
<?
class Foo
{
var $a = "normal attribute";
function __get($key, &$ret)
{
$ret = "overloaded return value";
return true;
}
}
overload("Foo");
$foo = new Foo();
print "get a: $foo->a \n"; print "get b: $foo->b \n"; ?>
The important thing to note here is that $foo->a did not pass through __get(), because the attibute has been defined.
So it's more like "underloading" than "overloading", as it only virtualises attributes that _do not_ exist.
John Martin
09-Dec-2003 08:47
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;
}
}
admin (hat) solidox (dawt) org
25-Aug-2003 02:51
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; $cake->hello['moto'] = 4; $cake->moo->cow("hello"); ?>
bit strange, these occur on php4.3.2. havn't tried other versions
Justin B
13-Aug-2003 09:16
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 ...
*/
fabiostt[X_AT_X]libero[X_DOT_X]it
12-Aug-2003 07:56
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() ; $args = func_get_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) ;
}
}$x = new OverloadTest('fooA', 'fooB') ;
echo( $x->getMessage() ) ;
?>
muell-spam-trash-abfall at kcet dot de
14-Mar-2003 01:53
This is the syntax of __get(), __set() and __call():
__get ( [string property_name] , [mixed return_value] )
__set ( [string property_name] , [mixed value_to_assign] )
__call ( [string method_name] , [array arguments] , [mixed return_value] )
__call() seems to work with PHP 4.3.0
See http://www.phppatterns.com/index.php/article/articleview/28/1/2/ for using this extension in detail.
steve at walkereffects dot com
25-Feb-2003 04:32
If you are a perfectionist when it comes to your class interfaces, and you are unable to use overload(), there is another viable solution:
Use func_num_args() to determine how many arguments were sent to the function in order to create virtual polymorphism. You can create different scenarios by making logical assumptions about the parameters sent. From the outside the interface works just like an overloaded function.
The following shows an example of overloading a class constructor:
class Name
{
var $FirstName;
var $LastName;
function Name($first, $last)
{
$numargs = func_num_args();
if($numargs >= 2)
{
$this->FirstName = $first;
$this->LastName = $last;
}
else
{
$names = explode($first);
$this->FirstName = $names[0];
$this->LastName = $names[1]
}
}
}
| |
output_reset_rewrite_vars
