How does __set() function call works?

[masood131]

I copied this code from phpmanual.com. There is a part of it that I don't understand.

function set() gets two parameters ($nm, $val). Now, I am assuming that the function set() is called implicitely. My question is:

1) when is function __set is actually called the first time, what trigers it to be called?

2) I don't see two parameters being passed on to function set(), but yet when I look at how the function is wrtten it has two parameters. How or where does set() gets these parameters?

<?php
class Setter
{
   public $n;
   private $x = array("a" => 1, "b" => 2, "c" => 3);

   function __get($nm)
   {
       print "Getting [$nm]\n";

   if (isset($this->x[$nm])) {
       $r = $this->x[$nm];
       print "Returning: $r\n";
       return $r;
   } else {
       echo "Nothing!\n";
   }
   }

   function __set($nm, $val)
   {
       print "Setting [$nm] to $val\n";

   if (isset($this->x[$nm])) {
       $this->x[$nm] = $val;
       echo "OK!\n";
   } else {
       echo "Not OK!\n";
   }
   }
}

$foo = new Setter();
$foo->n = 1;
$foo->a = 100;
$foo->a++;
$foo->z++;
var_dump($foo);
?> 

The above example will output:

Setting [a] to 100
OK!
Getting [a]
Returning: 100
Setting [a] to 101
OK!
Getting [z]
Nothing!
Setting [z] to 1
Not OK!
object(Setter)#1 (2) {
["n"]=>
int(1)
["x:private"]=>
array(3) {
["a"]=>
int(101)
["b"]=>
int(2)
["c"]=>
int(3)
}
}

Thanks

[matto]

hello, here's the explanation as far as I understood it.

these methods (set, get, _call) are php5 features. they provide a kind of fallback mechanisms that are active when you try to access an object's property which is not defined.

normally you don't call them explicitly.

if you - as in the poorly explained manual example - try to access an object variable "a", and it is not there so far (no var/public/private etc. declaration in the class), PHP tries to invoke a standard getter or setter (get, set). if you have programmed one - as in the example - you can handle these cases regularly.

that's why in the example you can set "n" silently (because it is directly accessible due to it having been declared "private $n;") but when trying to set the inexistent "a" variable, the fallback setter is triggered (which says "Setting [a] to 100").

this works alike with get, and it works with method calls, too (call).

I hope (a) I am correct and (b) I could help you.

PS: regarding your question who is the caller of these methods ... it's the php runtime itself. if someone tries to access a non-existing object property, php converts it into a function call such as:

echo $object->notexisting;

-> PHP: what the ...??? ->

echo $object->__get("notexisting");

or:

$object->unknown = "huh";

-> PHP: ha? ->

$object->__set('unknown', 'huh');

and:

$object->doSomethingNew("bli", "bla", "blo");

-> PHP: don't know such a method ... ->

$object->__call("doSomethingNew", array("bli", "bla", "blo"));

[masood131]

matto,

You not only were very helpful, but you also have a great sense of humor. Thank you, that helped alot.

Just to be sure: I am a little ambigious about why "$foo->n = 1" did not invoke the set() function. You are saying because it has already been decleared as a "public $n" in the class is the reason it was not sent before "a" to set() function. Am I right?

Well, as I see it "a" is also decleared in the array as being equal to one, isn't it? So, That shouldn't have invoked the __set() function, but it did!! "huh".. where did I go wrong here?

Ty