PHP
downloads | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | conferences | my php.net

search for in the

オブジェクトのイタレーション> <オブジェクト インターフェイス
Last updated: Fri, 04 Jul 2008

view this page in

オーバーロード

PHP におけるオーバーロード機能は、 メンバーやメソッドを動的に "作成する" ための手法です。 これらの動的エンティティは、マジックメソッドを用いて処理されます。 マジックメソッドは、クラス内でさまざまなアクションに対して用意することができます。

オーバーロードメソッドが起動するのは、 宣言されていないメンバーやメソッドを操作しようとしたときです。 また、現在のスコープからは アクセス不能な メンバーやメソッドを操作しようとしたときにも起動します。 このセクションでは、これらの (宣言されていない、 あるいは現在のスコープからはアクセス不能な) メンバーやメソッドのことを "アクセス不能メンバー" および "アクセス不能メソッド" と表記することにします。

オーバーロードメソッドは、すべて public で定義しなければなりません。

注意: これらのマジックメソッドの引数は、 参照渡し とすることはできません。

注意: PHP における "オーバーロード" の解釈は、他の多くのオブジェクト指向言語とは異なります。 一般的に「オーバーロード」とは、 「名前は同じだけれども引数の数や型が異なるメソッドを複数用意できる」 という機能のことを指します。

変更履歴

バージョン 説明
5.1.0 __isset() と __unset() が追加されました。
5.3.0 __callStatic() が追加されました。

メンバーのオーバーロード

void __set ( string $name , mixed $value )
mixed __get ( mixed $name )
bool __isset ( string $name )
void __unset ( string $name )

__set() は、 アクセス不能メンバーへデータを書き込む際に実行されます。

__get() は、 アクセス不能メンバーからデータを読み込む際に使用します。

__isset() は、 isset() あるいは empty() をアクセス不能メンバーに対して実行したときに起動します。

__unset() は、 unset() をアクセス不能メンバーに対して実行したときに起動します。

引数 $name は、 操作しようとしたメンバーの名前です。 __set() メソッドの引数 $value は、 $name に設定しようとした値となります。

メンバーのオーバーロードはオブジェクトのコンテキストでのみ動作します。 これらのマジックメソッドは、静的コンテキストでは起動しません。 したがって、これらのメソッドは static 宣言することはできません。

例1 __get, __set, __isset, __unset を使ったオーバーロードの例

<?php
class MemberTest {
    /**  オーバーロードされるデータの場所  */
    private $data = array();

    /**  宣言されているメンバーにはオーバーロードは起動しません */
    public $declared = 1;

    /**  クラス内からアクセスした場合にはオーバーロードは起動しません  */
    private $hidden = 2;

    public function __set($name, $value) {
        echo "Setting '$name' to '$value'\n";
        $this->data[$name] = $value;
    }

    public function __get($name) {
        echo "Getting '$name'\n";
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }

        $trace = debug_backtrace();
        trigger_error(
            'Undefined property: ' . $name .
            ' in ' . $trace[0]['file'] .
            ' on line ' . $trace[0]['line'],
            E_USER_NOTICE);
        return null;
    }

    /**  PHP 5.1.0 以降 */
    public function __isset($name) {
        echo "Is '$name' set?\n";
        return isset($this->data[$name]);
    }

    /**  PHP 5.1.0 以降 */
    public function __unset($name) {
        echo "Unsetting '$name'\n";
        unset($this->data[$name]);
    }

    /**  マジックメソッドではありません。単なる例として示しています  */
    public function getHidden() {
        echo "'hidden' visible here so __get() not used\n";
        return $this->hidden;
    }
}


echo "<pre>\n";

$obj = new MemberTest;

$obj->a = 1;
echo $obj->a . "\n";

var_dump(isset($obj->a));
unset($obj->a);
var_dump(isset($obj->a));

echo $obj->declared . "\n";
echo $obj->getHidden() . "\n";
echo $obj->hidden . "\n";
?>

上の例の出力は以下となります。

Setting 'a' to '1'
Getting 'a'
1
Is 'a' set?
bool(true)
Unsetting 'a'
Is 'a' set?
bool(false)
1
'hidden' visible here so __get() not used
2
Getting 'hidden'


Notice:  Undefined property: hidden in <file> on line 64 in <file> on line 28

メソッドのオーバーロード

mixed __call ( string $name , array $arguments )
mixed __callStatic ( string $name , array $arguments )

__call() は、 アクセス不能メソッドをオブジェクトのコンテキストで実行したときに起動します。

__callStatic() は、 アクセス不能メソッドを静的コンテキストで実行したときに起動します。

引数 $name は、 コールしようとしたメソッドの名前です。 引数 $arguments は配列で、メソッド $name に渡そうとしたパラメータが格納されます。

例2 __call および ___callStatic による、インスタンス化されたメソッドのオーバーロードの例

<?php
class MethodTest {
    public function __call($name, $arguments) {
        // 注意: $name は大文字小文字を区別します
        echo "Calling object method '$name' "
             . implode(', ', $arguments). "\n";
    }

    /**  PHP 5.3.0 以降 */
    public static function __callStatic($name, $arguments) {
        // 注意: $name は大文字小文字を区別します
        echo "Calling static method '$name' "
             . implode(', ', $arguments). "\n";
    }
}

$obj = new MethodTest;
$obj->runTest('in object context');

MethodTest::runTest('in static context');  // PHP 5.3.0 以降
?>

上の例の出力は以下となります。

Calling object method 'runTest' in object context
Calling static method 'runTest' in static context


オブジェクトのイタレーション> <オブジェクト インターフェイス
Last updated: Fri, 04 Jul 2008
 
add a note add a note User Contributed Notes
オーバーロード
daveb at spamless dot davebeta dot com
03-Jul-2008 01:36
In reply to uramihsayibok, gmail, com:

The PHP behaviour is the behaviour I would expect.

You are assigning a value to a property: $obj->a=$b works just the same as $a=$b and I would expect both these expressions to evaluate to $b.

The __set() method is used behind the scenes. As a programmer using the class I might not be aware __set() is used unless I originally wrote the class. The return value of __set() is quite rightly ignored.
justin at redwiredesign dot com
30-Jun-2008 06:59
The documentation isn't explicit in how it describes __get().

So, in your __get function, you return the value that you're trying to get or in my case, the object you've defined.

function __get ($var)
{
    if ($var == 'name')
    {
        return 'fred';
    }
   
    if ($var == 'obj')
    {
        return new MyObj();
    }
}
uramihsayibok, gmail, com
27-May-2008 06:01
Expanding in part on what Hayley Watson said (5 Feb 2008) regarding $a=$b=$c:

My first impression was that <?php $a=$foo->var=$c; ?> would assign $c to $foo->var (by using __set) and the *return value* of __set would be assigned to $a - like what happens in other languages. Perhaps the default (if __set returns void/null) would be $c.

This is not the case. The code above is equivalent to <?php $foo->var=$c; $a=$c; ?>. Regardless of what __set returns, $a will always have the value of $c.

<?php

class Foo {
    public function __set($name,$value) {
        static $var; $var=$value;
        // return "abc"; // comment, uncomment at will
    }
}

$f=new Foo();
$g=($f->var="value");
echo $g;
// $g is always "value", even if the return above is uncommented

?>
bishop
24-May-2008 08:31
If you need __call() and __callStatic() to support pass-by-reference, the current workaround is to use call-time reference.  See:
http://bugs.php.net/bug.php?id=40694

In my case, I implemented a Protection Proxy class (aka "Guard", part of the Protected System pattern) using __call() and __callStatic() and some of the protected object's methods use PBR.
el.pescado
23-May-2008 12:36
@durist at frii dot com:

It is not a bug. "Variables" managed by __set & __get aren't really variables - so there's no way get_object_vars could know them. Example with array is simple, but I can imagine more sophisticated scenarios, eg. __get could retrieve data from a database, or even you could write:
<?php
public function __get($name) {
   return md5($name);
}
?>
If you were correct, it would mean that get_object_vars should return infinite array of "member variables".

get_object_vars returns real variables. If you define a __set method that puts your data into array, you don't create a new variable, you just append some keys into an array;)

Hope I made myself clear;)
durist at frii dot com
16-May-2008 12:58
get_object_vars() cannot see members managed by __get() and __set(). Seems to me this is a bug...

<?php

class MemberTest {
    /**  Location for overloaded data.  */
    private $data = array();

    public function __set($name, $value) {
        echo "Setting '$name' to '$value'\n";
        $this->data[$name] = $value;
    }

    public function __get($name) {
        echo "Getting '$name'\n";
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        }

        $trace = debug_backtrace();
        trigger_error(
            'Undefined property: ' . $name .
            ' in ' . $trace[0]['file'] .
            ' on line ' . $trace[0]['line'],
            E_USER_NOTICE);
        return null;
    }

  }

$obj = new MemberTest;

$obj->a = 1;
echo $obj->a . "\n";    

var_dump( get_object_vars($obj) );

?>
..................................

Setting 'a' to '1'
Getting 'a'
1
durist@yorga:~$ php /tmp/t.php
Setting 'a' to '1'
Getting 'a'
1
array(0) {
}
Anonymous
01-May-2008 05:02
This is a generic implementation to use getter, setter, issetter and unsetter for your own classes.

<?php
abstract class properties
{
  public function __get( $property )
  {
    if( ! is_callable( array($this,'get_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    return call_user_func( array($this,'get_'.(string)$property) );
  }

  public function __set( $property, $value )
  {
    if( ! is_callable( array($this,'set_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    call_user_func( array($this,'set_'.(string)$property), $value );
  }
 
  public function __isset( $property )
  {
    if( ! is_callable( array($this,'isset_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    return call_user_func( array($this,'isset_'.(string)$property) );
  }

  public function __unset( $property )
  {
    if( ! is_callable( array($this,'unset_'.(string)$property) ) )
      throw new BadPropertyException($this, (string)$property);

    call_user_func( array($this,'unset_'.(string)$property) );
  }
}
?>
nospam michael AT netkey DOT at nospam
02-Apr-2008 03:10
you CAN write into ARRAYS by using __set and __get magic functions.

as has been mentioned before $obj->var['key'] = 'test'; does call the __get method of $obj, and there is no way to find out, if the method has been called for setting purposes.

the solution is quite simple: use __get to return the array by reference. then you can write into it:

<?php
class setter{
  private $_arr = array();

  public function __set($name, $value){
    $this->_arr[$name] = $value;
  }

  public function &__get($name){
    if (isset($this->_arr[$name])){
      return $this->_arr[$name];
    } else return null;
  }

}

?>
Matt Creenan
01-Mar-2008 01:34
PHP4 supports using __call but with a twist that I did not see mentioned anywhere on this page.

In 4, you must make the __call method signature with 3 parameters, the 3rd of which is the return value and must be declared by-reference.  Instead of using "return $value;" you would assign the 3rd argument to $value.

Example (both implementations below have the same result when run in the respective PHP versions:

<?php

// Will only work in PHP4
class Foo
{
    function __call($method_name, $parameters, &$return_value)
    {
        $return_value = "Method $method_name was called with " . count($parameters) . " parameters";
    }
}

// Will only work in PHP5
class Foo
{
    function __call($method_name, $parameters)
    {
        return "Method $method_name was called with " . count($parameters) . " parameters";
    }
}

?>
dave at mozaiq dot org
11-Feb-2008 08:58
Several users have mentioned ways to allow setting of array properties via magic methods. In particular, PHP calls the __get() method instead of the __set() method when you try to do: $obj->prop['offset'] = $val.

The suggestions that I've read below all work, except that they do not allow you make properties read-only. After a bit of struggling, I have found a solution. Essentially, if the property is supposed to be a read-only array, create an new ArrayObject() out of it, then clone it and return the clone.

<?php

public function __get($var) {
    if(isset($this->read_only_props[$var])) {
        $ret = null;
        if (is_array($this->read_only_props[$var]))
            return clone new ArrayObject($this->read_only_props[$var]);
        else if (is_object($this->read_only_props[$var]))
            return clone $this->read_only_props[$var];
        else
            return $this->read_only_props[$var];
    }
    else if (!isset($this->writeable_props[$var]))
        $this->writeable_props[$var] = NULL;
    return $this->writeable_props[$var];
}

public function __set($var, $val) {
    if (isset($this->read_only_props[$var]))
        throw new Exception('tried to set a read only property on the event object');
    return $this->writeable_props[$var] = $val;
}
?>

Note that __get() does not explicitly return by reference as many examples have suggested. Also, I have not found a way to detect when __get() is being called for setting purposes, thus my code can not throw an exception when necessary in these cases.
Hayley Watson
06-Feb-2008 10:53
Chained assignments are still right-associative and still work as expected. That is to say, $a = $foo->b = $c is equivalent to $a = ($foo->b = $c) and results in $a being set to the value of $c even if $foo->b is a property handled by __get/__set and even if those methods adjust/validate their arguments (and even if they fail).

In other words, "$a = $b = $c;" and "$a = ($b = $c);" are both equivalent to "$a = $c; $b = $c;" and not to the equally plausible "$b = $c; $a = $b;".

Assignment expressions evaluate to the value that gets assigned - the value that appears on the right-hand side - and what happens to whatever is on the left is treated as a side-effect.
So in the expression $a=$b=$c, $a doesn't care about what does or doesn't happen to $b - all it sees is the *value* of $b=$c, which is just the value of $c. The parentheses make this clearer: in $a=($b=$c) we have $b being assigned the value of $c and $a being assigned the value of ($b=$c).

As already hinted, this is nothing new: it's just made more obvious by __get and __set: $a = $foo->b = $c does NOT involve looking up the value of $foo->b (let alone assigning it to $a), and $foo->__get() isn't called.
timshaw at mail dot NOSPAMusa dot com
29-Jan-2008 02:47
The __get overload method will be called on a declared public member of an object if that member has been unset.

<?php
class c {
  public $p ;
  public function __get($name) { return "__get of $name" ; }
}

$c = new c ;
echo $c->p, "\n" ;    // declared public member value is empty
$c->p = 5 ;
echo $c->p, "\n" ;    // declared public member value is 5
unset($c->p) ;
echo $c->p, "\n" ;    // after unset, value is "__get of p"
?>
jj dhoT maturana aht gmail dhot com
25-Jan-2008 09:16
There isn't some way to overload a method when it's called as a reflection method:

<?php

class TestClass {
  function __call($method, $args) {
    echo "Method {$method} called with args: " . print_r($args, TRUE);
  }
}

$class = new ReflectionClass("TestClass");
$method = $class->getMethod("myMehtod");

//Fatal error:  Uncaught exception 'ReflectionException' with message 'Method myMethod' does not exist'

?>

Juan.
Bjrn Wikkeling
21-Jan-2008 07:25
In response to Anonymous: 09-Jan-2008 10:45.

PHP 5.3 will include the magic method __callStatic to use for static method calls.

see also:
http://bugs.php.net/bug.php?id=26739
v dot umang at gmail dot com
12-Jan-2008 02:20
If you want to be able to overload a variable from within a class and this is your code:
<?php
class myClass
{
    private $data;
    public function __set($var, $val)
    {
        $this->data[$var] = $val;
    }
    public function __get($var)
    {
        $this->data[$var] = $val;
    }
}
?>

There is a problem if you want to call these variables from within the class, as you you want to access data['data'] then you can't say $this->data as it will return the array $data. Therefore a simple solution is to name the array $_data. So in your __get and __set you will say $this->_data ... rather than $this->data. I.E:
<?php
class myClass
{
    private $_data;
    public function __set($var, $val)
    {
        $this->_data[$var] = $val;
    }
    public function __get($var)
    {
        $this->_data[$var] = $val;
    }
}
?>

Umang
soldair at NOSPAM gmail.com
11-Jan-2008 02:21
the documentation states a falsehood:
 "All overloading methods must be defined as public."

<?php
class test{
    #################
    #public use methods#
    #################
    public static function echoData(){
        $obj = self::getInstance();
        echo $obj->find('data');
        return true;
    }
    ######################
    #only use a single instance#
    ######################
    private static $instance;
    private static function getInstance(){
        if(!isset(self::$instance)){
            self::$instance = new test;
        }
        return self::$instance;
    }
    #################
    #private instantiation#
    #################
    private $data = array('data'=>'i am data');
    private function __construct(){}
    private function __call($nm,$args){
        if(isset($this->data[$args[0]])){
            return $this->data[$args[0]];
        }
        return null;
    }
}

test::echoData();
?>
--------------OUTPUT---------------
i am data
-----------------------------------

this test was run using PHP Version 5.2.4
Anonymous
10-Jan-2008 12:45
it should be noted that __call will trigger only for method calls on an instantiated object, and cannot be used to 'overload' static methods.  for example:

<?php

class TestClass {
  function __call($method, $args) {
    echo "Method {$method} called with args: " . print_r($args, TRUE);
  }
}

// this will succeed
$obj = new TestClass();
$obj->method_doesnt_exist();

// this will not
TestClass::method_doesnt_exist();

?>

It would be useful if the PHP devs would include this in a future release, but in the meantime, just be aware of that pitfall.
egingell at sisna dot com
21-Dec-2007 12:54
The PHP devs aren't going to implement true overloading because: PHP is not strictly typed by any stretch of the imagination (0, "0", null, false, and "" are the same, for example) and unlike Java and C++, you can pass as many values as you want to a function. The extras are ignored unless you fetch them using func_get_arg(int) or func_get_args(), which is often how I "overload" a function/method, and fewer than the declared number of arguments will generate an E_WARNING, which can be suppressed by putting '@' before the function call, but the function will still run as if you had passed null where a value was expected.

<?php
class someClass {
    function whatever() {
        $args = func_get_args();
   
        // public boolean whatever(boolean arg1) in Java
        if (is_bool($args[0])) {
            // whatever(true);
            return $args[0];
   
        // public int whatever(int arg1, boolean arg2) in Java
        } elseif(is_int($args[0]) && is_bool($args[1])) {
            // whatever(1, false)
            return $args[0];
   
        } else {
            // public void whatever() in Java
            echo 'Usage: whatever([int], boolean)';
        }
    }
}
?>

// The Java version:
public class someClass {
    public boolean whatever(boolean arg1) {
        return arg1;
    }
   
    public int whatever(int arg1, boolean arg2) {
        return arg1;
    }
   
    public void whatever() {
        System.out.println("Usage: whatever([int], boolean)");
    }
}
matthijs at yourmediafactory dot com
17-Dec-2007 04:09
While PHP does not support true overloading natively, I have to disagree with those that state this can't be achieved trough __call.

Yes, it's not pretty but it is definately possible to overload a member based on the type of its argument. An example:
<?php
class A {
  
  public function __call ($member, $arguments) {
    if(is_object($arguments[0]))
      $member = $member . 'Object';
    if(is_array($arguments[0]))
      $member = $member . 'Array';
    $this -> $member($arguments);
  }
  
  private function testArray () {
    echo "Array.";
  }
  
  private function testObject () {
    echo "Object.";
  }
}

class B {
}

$class = new A;
$class -> test(array()); // echo's 'Array.'
$class -> test(new B); // echo's 'Object.'
?>

Of course, the use of this is questionable (I have never needed it myself, but then again, I only have a very minimalistic C++ & JAVA background). However, using this general principle and optionally building forth on other suggestions a 'form' of overloading is definately possible, provided you have some strict naming conventions in your functions.

It would of course become a LOT easier once PHP'd let you declare the same member several times but with different arguments, since if you combine that with the reflection class 'real' overloading comes into the grasp of a good OO programmer. Lets keep our fingers crossed!
anthony dot parsons at manx dot net
10-Nov-2007 07:57
You can't use __set to set arrays, but if you really want to, you can emulate it yourself:
<?php
class test {
    public $x = array();
    public $y = array();
    function __set($var, $value)
    {
        if ( preg_match('/(.*)\[(.*)\]/', $var, $names) ) {
            $this->y[$names[1]][$names[2]] = $value;
        }
        else {
            $this->x[$var] = $value;
        }
    }
}

$z = new test;
$z->variable = 'abc';
$z->{'somearray[key]'} = 'def';

var_dump($z->x);
var_dump($z->y);
?>
php_is_painful at world dot real
19-Oct-2007 11:49
This is a misuse of the term overloading. This article should call this technique "interpreter hooks".
egingell at sisna dot com
13-Oct-2007 03:26
@ zachary dot craig at goebelmediagroup dot com

I do something like that, too. My way might be even more clunky.

<?php

function sum() {
    $args = func_get_args();
    if (!count($args)) {
        echo 'You have to supply something to the function.';
    } elseif (count($args) == 1) {
        return $args[0];
    } elseif (count($args) == 2) {
        if (is_numeric($args[0]) && is_numeric($args[1])) {
            return $args[0] + $args[1];
        } else {
            return $args[0] . $args[1];
        }
    }
}

?>

I like the "__call" method, though. You can "declare" multiple functions that don't pollute the namespace. Although, it might be better looking to use this instead of a series of if...elseif... statemenets.

<?php
class myClass {
    function __call($fName, $fArgs) {
        switch($fName) {
            case 'sum':
            if (count ($fArgs) === 1) {
                return $fArgs[0];
            } else {
                $retVal = 0;
                foreach( $fArgs as $arg ) {
                    $retVal += $arg;
                }
                return $retVal;
            }
            break;
            case 'other_method':
            ...
            default:
            die ('<div><b>Fetal Error:</b> unknown method ' . $fName . ' in ' . __CLASS__ . '.</div>');
        } // end switch
    }
}

?>

Side note: if you don't force lower/upper case, you will have case sensitive method names. E.g. $myclass->sum() !== $myclass->Sum().
zachary dot craig at goebelmediagroup dot com
09-Oct-2007 02:13
@egingell at sisna dot com -
  Use of __call makes "overloading" possible also, although somewhat clunky...  i.e.
<?php
class overloadExample
{
  function __call($fName, $fArgs)
  {
    if ($fName == 'sum')
    {
      if (count ($fArgs) === 1)
      {
        return $fArgs[0];
      }
      else
      {
        $retVal = 0;
        foreach( $fArgs as $arg )
        {
          $retVal += $arg;
        }
        return $retVal;
      }
    }
  }
}

/*
Simple and trivial I realize, but the point is made.  Now an object of class overloadExample can take
*/
echo $obj->sum(4); // returns 4
echo $obj->sum(4, 5); // returns 9
?>
bgoldschmidt at rapidsoft dot de
28-Sep-2007 05:23
"These methods will only be triggered when your object or inherited object doesn't contain the member or method you're trying to access."
is not quite correct:
they get called when the member you trying to access in not visible:

<?php
class test {

  public $a;
  private $b;

  function __set($name, $value) {
    echo("__set called to set $name to $value\n");
    $this->$name = $value;
  }
}

$t = new test;
$t->a = 'a';
$t->b = 'b';

?>

Outputs:
__set called to set b to b

Be aware that set ist not called for public properties
lokrain at gmail dot com
26-Sep-2007 06:05
Let us look at the following example:

class objDriver {
    private $value;

    public function __construct()
    {
        $value = 1;
    }

    public function doSomething($parameterList)
    {
        //We make actions with the value
    }
}

class WantStaticCall {
    private static $objectList;

    private function __construct()

    public static function init()
    {
         self::$objectList = array();
    }

    public static function register($alias)
    {
        self::$objectList[$alias] = new objDriver();
    }

    public static function __call($method, $arguments)
    {
        $alias = $arguments[0];
    array_shift($arguments);
        call_user_method($method, self::$objectList[$alias], $arguments);
    }
}

// The deal here is to use following code:
WantStaticCall::register('logger');
WantStaticCall::doSomething('logger', $argumentList);

// and we will make objDriver to call his doSomething function with arguments
// $argumentList. This is not common pattern but very usefull in some cases.
// The problem here is that __call() cannot be static, Is there a way to work it around
Typer85 at gmail dot com
19-Sep-2007 12:28
Just to clarify something the manual states about method overloading.

"All overloading methods must be defined as public."

As of PHP 5.2.2, this should be considered more of a coding convention rather than a requirement. In PHP 5.2.2, declaring a __get or __set function with a visibility other than public, will be silently ignored by the parser and will not trigger a parse error!

What is more, PHP will completely ignore the visibility modifier either of these functions are declared with and will always treat them as if they were public.

I am not sure if this is a bug or not so to be on the safe side,
stick with always declaring them public.
egingell at sisna dot com
15-Sep-2007 09:12
Small vocabulary note: This is *not* "overloading", this is "overriding".

Overloading: Declaring a function multiple times with a different set of parameters like this:
<?php

function foo($a) {
    return $a;
}

function foo($a, $b) {
    return $a + $b;
}

echo foo(5); // Prints "5"
echo foo(5, 2); // Prints "7"

?>

Overriding: Replacing the parent class's method(s) with a new method by redeclaring it like this:
<?php

class foo {
    function new($args) {
        // Do something.
    }
}

class bar extends foo {
    function new($args) {
        // Do something different.
    }
}

?>
ac221 at sussex dot ac dot uk
02-Sep-2007 02:07
Just Noting the interesting behavior of __set __get , when modifying objects contained in overloaded properties.

<?php
class foo {
    public $propObj;
    public function __construct(){
        $propObj = new stdClass();
    }
    public function __get($prop){
        echo("I'm Being Got ! \n");
        return $this->propObj->$prop;
    }
    public function __set($prop,$val){
        echo("I'm Being Set ! \n");
        $this->propObj->$prop = $val;
    }
}
$test = new foo();
$test->barProp = new stdClass(); // I should invoke set
$test->barProp->barSubProp = 'As Should I';
$test->barProp->barSubProp = 'As Should I';
$test->barProp = new stdClass(); // As should i
?>

Outputs:

I'm Being Set !
I'm Being Got !
I'm Being Got !
I'm Being Set !

Whats happening, is PHP is acquiring a reference to the object, triggering __get; Then applying the changes to the object via the reference.

Which is the correct behaviour; objects being special creatures, with an aversion to being cloned...

Unfortunately this will never invoke the __set handler, even though it is modifying a property within 'foo', which is slightly annoying if you wanted to keep track of changes to an objects overloaded properties.

I guess Journaled Objects will have to wait till PHP 6 :)
stephen dot cuppett at webmastersinc dot net
16-Aug-2007 11:10
Please note, this example will not work on later PHP versions.  You must return from __get() by reference using &__get()
php at sleep is the enemy dot co dot uk
23-Jul-2007 11:23
Just to reinforce and elaborate on what DevilDude at darkmaker dot com said way down there on 22-Sep-2004 07:57.

The recursion detection feature can prove especially perilous when using __set. When PHP comes across a statement that would usually call __set but would lead to recursion, rather than firing off a warning or simply not executing the statement it will act as though there is no __set method defined at all. The default behaviour in this instance is to dynamically add the specified property to the object thus breaking the desired functionality of all further calls to __set or __get for that property.

Example:

<?php

class TestClass{

    public $values = array();
   
    public function __get($name){
        return $this->values[$name];
    }
   
    public function __set($name, $value){
        $this->values[$name] = $value;
        $this->validate($name);
    }

    public function validate($name){
        /*
        __get will be called on the following line
        but as soon as we attempt to call __set
        again PHP will refuse and simply add a
        property called $name to $this
        */
        $this->$name = trim($this->$name);
    }
}

$tc = new TestClass();

$tc->foo = 'bar';
$tc->values['foo'] = 'boing';

echo '$tc->foo == ' . $tc->foo . '<br>';
echo '$tc ' . (property_exists($tc, 'foo') ? 'now has' : 'still does not have') . ' a property called "foo"<br>';

/*
OUPUTS:
$tc->foo == bar
$tc now has a property called "foo"
*/

?>
Adeel Khan
11-Jul-2007 05:18
Observe:

<?php
class Foo {
    function __call($m, $a) {
        die($m);
    }
}

$foo = new Foo;
print $foo->{'wow!'}();

// outputs 'wow!'
?>

This method allows you to call functions with invalid characters.
alexandre at nospam dot gaigalas dot net
08-Jul-2007 02:59
PHP 5.2.1

Its possible to call magic methods with invalid names using variable method/property names:

<?php

class foo
{
    function __get($n)
    {
        print_r($n);
    }
    function __call($m, $a)
    {
        print_r($m);
    }
}

$test = new foo;
$varname = 'invalid,variable+name';
$test->$varname;
$test->$varname();

?>

I just don't know if it is a bug or a feature :)
BenBE at omorphia dot de
06-May-2007 02:48
While playing a bit with the __call magic method I found you can not emulate implementing methods of an interface as you might think:

<?
class Iteratable implements Iterator {
    public function __call($funcname) {
        if(in_array($funcname, array('current', 'next', /*...*/)) {
            //Redirect the call or perform the actual action
        }
    }
}
?>

Using this code you'll get a "class Iteratable contains abstract methods ..." fatal error message. You'll ALWAYS have to implement those routines by hand.
j dot stubbs at linkthink dot co dot jp
27-Feb-2007 02:53
In reply to james at thunder-removeme-monkey dot net,

Unfortunately it seems that there is no way to have completely transparent array properties with 5.2.x. The code you supplied works until working with built-in functions that perform type-checks:

<?

// Using the same View class
$view = new View();
$view->bar = array();
$view->bar[] = "value";

if (is_array($view->bar))
    print "is array!\n"; // Not printed

// Warning: in_array(): Wrong datatype for second argument in ...
if (in_array("value", $view->bar))
    print "found!\n"; // Not printed

// Successful
if (in_array("value", (array)$view->bar))
    print "found!\n";

?>

It also seems that 5.1.x is no longer maintained as it's not listed on the downloads page.. Quite frustrating. :/
mafu at spammenot-mdev dot dk
25-Feb-2007 07:24
As a reply to james at thunder-removeme-monkey dot net, I found that there is a much simpler way to restore the behavior of __get() to 5.1.x state; just force __get() to return by reference, like this:

<?php
class View {
  /* Somewhere to store our overloaded properties */
  private $v = array();

  /* Store a new property */
  function __set($varName, $varValue) {
   $this->v[$varName] = $varValue;
  }

  /* Retrieve a property */
  function & __get($varName) {
   if(!isset($this->v[$varName])) {
     $this->v[$varName] = NULL;
   }
   return $this->v[$varName];
  }
}
?>

The only problem is that the code generates a notice if null is returned in __get(), because null cannot be returned by reference. If somebody finds a solution, feel free to email me. :)

Cheers
james at thunder-removeme-monkey dot net
01-Feb-2007 06:07
Following up on the comment by "jstubbs at work-at dot co dot jp" and after reading "http://weierophinney.net/matthew/archives/ 131-Overloading-arrays-in-PHP-5.2.0.html", the following methods handle property overloading pretty neatly and return variables in read/write mode.

<?php
class View {
  /* Somewhere to store our overloaded properties */
  private $v = array();

  /* Store a new property */
  function __set($varName, $varValue) {
    $this->v[$varName] = $varValue;
  }

  /* Retrieve a property */
  function __get($varName) {
    if(!isset($this->v[$varName])) {
      $this->v[$varName] = NULL;
    }
    return is_array($this->v[$varName]) ? new ArrayObject($this->v[$varName]) : $this->v[$varName];
  }
}
?>

This is an amalgm of previous solutions with the key difference being the use of ArrayObject in the return value. This is more flexible than having to extend the whole class from ArrayObject.

Using the above class, we can do ...

<?php
$obj = new SomeOtherObject();
$view = new View();

$view->list = array();
$view->list[] = "hello";
$view->list[] = "goat";
$view->list[] = $group;
$view->list[] = array("a", "b", "c");
$view->list[3][] = "D";
$view->list[2]->aprop = "howdy";

/*
$view->list now contains:
[0] => "hello"
[1] => "goat"
[2] => SomeOtherObject { aprop => "howdy" }
[3] => array("a", "b", "c", "D")

and
$obj === $view->list[2] // equates to TRUE
*/
?>
mhherrera31 at hotmail dot com
26-Nov-2006 03:11
example for read only properties in class object. Lets you manage read only properties with var names like $ro_var.

The property must be PRIVATE, otherwise the overload method __get doesn't be called.

class Session {
 private $ro_usrName;

 function __construct (){
  $this->ro_usrName = "Marcos";
 }

 function __set($set, $val){
  if(property_exists($this,"ro_".$set))
    echo "The property '$set' is read only";
  else
    if(property_exists($this,$set))
      $this->{$set}=$val;
    else
      echo "Pr