How to call a PHP constructor like call_user_func_array

Tidals Blog

Entry's Links

Tuesday, February 23. 2010

How to call a PHP constructor like call_user_func_array

PHP´s native function call_user_func_array comes in very handy when dynamically calling a
callable (instance-method, static-method, function, lamdba/closure) with an arbitrary number of arguments.
  1. class TestClass1 {
  2.    public static function argsToArray($arg1, $arg2, $arg3){
  3.       return array($arg1, $arg2, $arg3);
  4.    }
  5. }
  6.  
  7. $array = call_user_func_array(array('TestClass1', 'argsToArray'), array(1,2,3));
  8. // array(1,2,3)

However this function has one drawback since it doesnt support the creation of an object
through its class´ constructor.
The following code will not construct a new TestClass2 instance, but result in a warning:
"call_user_func_array() expects parameter 1 to be a valid callback, non-static method
TestClass2::__construct() cannot be called statically in [...]"
  1. class TestClass2 {
  2.     public function __construct($arg1, $arg2, $arg3){
  3.       [...]
  4.    }
  5. }
  6. $o = call_user_func_array(array('TestClass2', '__construct'), array(1,2,3));
  7. var_dump($o);
  8. // null

Luckily there are some solutions to this problem:

The "nasty, ugly and evil approach"
This solution is definitely not recommended (at least when you are on PHP5 or higher),
since it relies on the execution of dynamically created code through the 'eval' function.
This is not safe nor reliable, however it´s the only way to do the magic in PHP4.
  1. class TestClass3 {
  2.     public function __construct($arg1, $arg2, $arg3){
  3.        $this->arg1 = $arg1;  
  4.        $this->arg2 = $arg2;
  5.        $this->arg3 = $arg3;    
  6.    }
  7. }
  8.  
  9. function call_constructor_array_eval($cls, $arguments){
  10.    $code = '$obj = new '.$cls.'('.implode(',', $arguments).');';
  11.    eval($code);
  12.    return $obj;
  13. }
  14.  
  15. $o = call_constructor_array_eval('TestClass3', array(1,2,3));
  16. var_dump($o);
  17. // object(TestClass3)[1]
  18. //  public 'arg1' => int 1
  19. //  public 'arg2' => int 2
  20. //  public 'arg3' => int 3

The "Reflection approach"
Luckily PHP5 introduced back then the Reflection set of classes, which can be used to
examine and reverse-engineer classes, functions, methods, etc. Additionally the Reflection
classes provide delegate methods to call on methods or functions.
In this (recommended) approach, we use 'newInstanceArgs' method of ReflectionClass,
which gives us a clean and reliable way to construct objects dynamically.
  1. class TestClass4 {
  2.     public function __construct($arg1, $arg2, $arg3){
  3.        $this->arg1 = $arg1;  
  4.        $this->arg2 = $arg2;
  5.        $this->arg3 = $arg3;    
  6.    }
  7. }
  8.  
  9. function call_constructor_array_reflection($cls, $arguments){
  10.    $rc = new ReflectionClass('TestClass');
  11.    return $rc->newInstanceArgs($arguments);
  12. }
  13.  
  14. $o = call_constructor_array_reflection('TestClass4', array(7,8,9));
  15. var_dump($o);
  16. // object(TestClass4)[1]
  17. //  public 'arg1' => int 7
  18. //  public 'arg2' => int 8
  19. //  public 'arg3' => int 9

The "polymorphic approach"
This last solution is just a variation of the "Reflection approach", but it serves in places
where a (building) part of application should not be aware of wether it´s calling a native
constructor or an arbitrary method ('build', 'getInstance', etc.). For the latter we have to
use call_user_func_array in any way and it´s very simple to make the "Reflection approach"
work in the same way.
  1. class TestClass5 {
  2.     public function __construct($arg1, $arg2, $arg3){
  3.        $this->arg1 = $arg1;  
  4.        $this->arg2 = $arg2;
  5.        $this->arg3 = $arg3;    
  6.    }
  7.    public function argsToArray($arg1, $arg2, $arg3){
  8.       return array($arg1, $arg2, $arg3);
  9.    }
  10. }
  11. $rc = new ReflectionClass('TestClass5');
  12. $o = call_user_func_array(array($rc, 'newInstanceArgs'), array('a','b','c'));
  13. var_dump($o);
  14. // object(TestClass5)[1]
  15. //  public 'arg1' => string 'a' (length=1)
  16. //  public 'arg2' => string 'b' (length=1)
  17. //  public 'arg3' => string 'c' (length=1)
  18. $res = call_user_func_array(array($o, 'argsToArray'), array('x','y','z'));
  19. var_dump($res);
  20. //array
  21. //  0 => string 'x' (length=1)
  22. //  1 => string 'y' (length=1)
  23. //  2 => string 'z' (length=1)



Posted by
Timo Michna
in php at 16:38 | Comment (1) | Trackbacks (0)
Trackbacks
Trackback specific URI for this entry
No Trackbacks
Comments
Display comments as (Linear | Threaded)
You are a lifesaver!
I'd almost come to the conclusion that this wasn't possible.
It even works on the clunky old CentOS 5.5 with PHP 5.1.6 I'm forced to use at work!
#1 Anonymous on 2010-08-27 13:54 (Reply)
Add Comment
Enclosing asterisks marks text as bold (*word*), underscore are made via _word_.
Standard emoticons like :-) and ;-) are converted to images.

To prevent automated Bots from commentspamming, please enter the string you see in the image below in the appropriate input box. Your comment will only be submitted if the strings match. Please ensure that your browser supports and accepts cookies, or your comment cannot be verified correctly.
CAPTCHA

 
   
 

Calendar

Back May '13
Mo Tu We Th Fr Sa Su
Tuesday, May 21. 2013
    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    

Quicksearch

Archives

Categories



All categories

Syndicate This Blog

Blog Administration

Open login screen

Powered by

ma.gnolia

A ma.gnolia error occured!
Error Message: rss failed(More)

Show tagged entries