Javascript Prototype Behaviour in PHP

2008-09-29T00:55:09-04:00

One of the “neat” things in Javascript is you are able to dynamically add or change methods of a class and automatically update every instance of that class. Some of the things I usually find useful are adding to the String class, like so:

/g,'>');
}
String.prototype.trim = function() {
    return this.replace(/^\s+|\s+$/g, '');
}
]]>

Obviously we cannot do this in PHP, and why would we, right? However we can emulate this behaviour to a certain extent using my “neat” little Prototype class. With this Prototype class we can dynamically add properties and methods to any class, and they will be inherited by all instances of that class.

Let’s look at the following “normal” PHP code.

name, $this->gender);
    }
}

$matt = new Person;
$matt->name = 'Matt';
$matt->gender = 'male';
$matt->gender();

// Matt is male
]]>

Now, there is nothing magical or out-of-the-ordinary going on here. We just instantiate the Person class and setup some properties. Calling the gender() method outputs a nice little string for us.

However, you see that the Person class is actually a child of the Prototype class. This will allow us to do some of that “neat” Javascript stuff. Using Prototype, let us expand the Person class to add an $age property and an age() method to output a nice string. Like so:

name, $this->age, $this->gender);');

$matt->age = 28;
$matt->age();

// Matt is a 28 year old male
]]>

Now all instances of Person inherit the $age property and age() method. So we can create a new Person, Susie, and this object will now have the age stuff.

name = 'Susie';
$susie->gender = 'female';
$susie->age = 21;
$susie->age();

// Susie is a 21 year old female
]]>

One limitation of the Prototype class though, is you cannot overload a current method. So the following code, that attempts to overload the gender() method, will not work.

name, $this->age, $this->gender);');

$matt->gender();

// Matt is male
]]>

There are also many, many, many other problems with this Prototype class. Some of which are:

The ‘$this’ keyword is reserved, so it actually does a string replace and uses ‘$self’ instead.
You cannot access/add new methods or properties statically (until PHP 5.3 with __callStatic()).
It uses create_function, so every “method” is actually defined in the global namespace.
Iteration does not work, although it could possibly be done with Iterator, Countable, et al.
You cannot reference static variables/methods in your add method.
You cannot share methods between classes.
And so on and so forth…

This class was just an experiment to see if it was at all possible to implement something like Javascript’s prototype behaviour in PHP with out using the Runkit PECL extension. I had no intention of actually making this usable in production, for many reasons ;), although it was fun.

Persistent Static Variables

2008-06-12T01:44:33-04:00

Wait, What? Yeah that’s what I thought too. Still no Idea what I’m talking about? Well, let’s take a look at the following code. Let’s call it “fred”.

class foo {
    function bar( $b = 0 )
    {
        static $a = 0;
        if ( $b ) {
            $a = $b;
        }   
         echo $a;
    }
}

$faz = new foo;
$faz->bar(3);
$baz = new foo;
$baz->bar();
foo::bar();
foo:bar(1); 
$faz->bar();

The code above, named “fred”, basically creates a static variable $a inside the function foo(). When you call foo(0) it outputs the value of $a. When you call foo('x') , where x can be anything, it updates the value of $a with 'x', and outputs the new result.

Now, what would expect “fred” to output? If your like me, then you are completely wrong. “fred” will actually output the following code.

bar(3); ==> 3
$baz->bar();  ==> 3
foo::bar();      ==> 3
foo:bar(1);     ==> 1
$faz->bar();   ==> 1
 
Expected outputs:
$faz->bar(3); ==> 3
$baz->bar();  ==> 0
foo::bar();      ==> 0
foo:bar(1);     ==> 1
$faz->bar();   ==> 3
*/
]]>

Yes, that’s what I said at the start, “Persistent Static Variables Across Instances”. The static variable $a actually persists across the two instances of foo that “fred” created, and even into the static method call. This was completely unexpected, at least by me. So I’ll ask, does anyone know if this is actually the expected behaviour, and why it is or is not?

Matt Read, Weblog

Javascript Prototype Behaviour in PHP

Persistent Static Variables