public
Last active

  • Download Gist
oo.php
PHP
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
<?php
 
// Define the 'class' class
$class = Obj()
->fn('new', function ($class) {
$newClass = Obj($class->methods)
->fn('new', function($class) {
$obj = Obj($class->imethods);
$args = func_get_args();
array_shift($args);
call_user_func_array(array($obj, 'init'), $args);
return $obj;
});
return $newClass;
})
->fn('def', function ($t, $name, $fn) {
$t->imethods[$name] = $fn;
return $t;
})
->fn('extend', function ($t) {
return clone $t;
});
 
// Define a new class
$animal = $class->new()
->def('init', function($t, $name) {
$t->name = $name;
})
->def('speak', function($t) {
echo "My name is $t->name\n";
});
 
// Extend a class
$dog = $animal->extend()
->def('speak', function($t) {
echo "My name is $t->name, I have just met you and I love you, SQUIRREL!\n";
})
->def('bark', function($t) {
echo "Woof!\n";
});
 
$jimmy = $animal->new('Jimmy');
$jimmy->speak();
 
$doug = $dog->new('Doug');
$doug->speak();
$doug->bark();
 
 
// ---- The guts...
 
class Obj
{
public function __construct($methods=array())
{
$this->methods = $methods;
}
 
public function method($name)
{
if (!isset($this->methods[$name]))
throw new BadMethodCallException();
 
return $this->methods[$name];
}
 
public function fn($name, $fn)
{
$this->methods[$name] = $fn;
return $this;
}
 
public function __call($name, $args)
{
return call_user_func_array(
$this->method($name),
array_merge(array($this), $args)
);
}
}
 
// Allow chaining method calls off the constructor..
function Obj($methods=array())
{
return new Obj($methods);
}

You come from a js background, right?

This is interesting but the only problem is that PHP does not allow Closure serialisation.... so these classes won't be serializable....
To prevent this problem we would have to clean the 'methods' property when serializing and rebuild it on when unserializing.

Yep, PHP 5.3 only sorry.

Ah yeah, it really sucks that you can't serialise objects with closures. :-(
To be fair, you run into the same problem in Javascript.

yeah .. 5.3 .. I am actually looking forward to the day we upgrade our production environment to that version .. it's going to be a total map/reduce party!

Heh.. it's funny you should mention that. We recently deployed 5.3 on our production servers, which led me to thinking about what kind of crazy evil stuff I could implement using closures. This is the result.

a good amount of overhead, but you can get around the serialization problem via:
http://github.com/jeremeamia/super_closure

Hah, that's a pretty cool hack. /impressed

very interesting!

Very cool, could be a good way to implement inceptors, sequences. tried an implementation http://gist.github.com/594135/ haven't tested it at all though

Definitely not OO !

Forked with view to providing a replacement for StdClass that allows you to attach callable methods to.

This pattern is mostly used in javascript.

Please sign in to comment on this gist.

Something went wrong with that request. Please try again.