Passing static methods as arguments in PHP

Since you've already mentioned that call_user_func() has been used and you're not interested in a solution with that or ones that are passing the static function as a string, here is an alternative: using anonymous functions as a wrapper to the static function.

function myFunction( $method ) {
    $method();
}

myFunction( function() { return MyClass::staticMethod(); } );

I wouldn't recommend doing this, as I think the call_user_func() method is more concise.

If you want to avoid strings, you can use this syntax:

myFunction( function(){ return MyClass::staticMethod(); } );

It is a little verbose, but it has the advantage that it can be statically analysed. In other words, an IDE can easily point out an error in the name of the static function.

Let my try to give a thorough example...

You would make a call like this:

myFunction('Namespace\\MyClass', 'staticMethod');

or like this (if you have arguments you want to pass):

myFunction('Namespace\\MyClass', 'staticMethod', array($arg1, $arg2, $arg3));

And your function to receive this call:

public static function myFunction($class, $method, $args = array())
{
    if (is_callable($class, $method)) {
        return call_user_func_array(array($class, $method), $args);
    }
    else {
        throw new Exception('Undefined method - ' . $class . '::' . $method);
    }
}

Similiar technique is commonly used in the Decorator Pattern in php.

to the question:

In PHP is it possible to do something like this:

myFunction( MyClass::staticMethod );

the answer is yes. you can have the staticMethod() return anonymous function instead. i.e.

private static function staticMethod()
{
    return function($anyParameters)
    {
        //do something here what staticMethod() was supposed to do
        // ...
        // ...
        //return something what staticMethod() was supposed to return;
    };
}

you can then write

myFunction(MyClass::staticMethod());

but note that () is needed to invoke staticMethod(). This is because it now returns the anonymous function that wraps the job of what you initially wanted your staticMethod() to do.

This works perfectly fine when staticMethod() is only being passed in as parameter into another function. If you wish to call staticMethod() that directly does the processing, you have to then write

MyClass::staticMethod()($doPassInParameters);

Note that this may require one extra redundant step to retrieve the function pointer, as compared to when it can work without wrapping it in anonymous function. I only use it to pass as parameter so am not sure of the performance penalty of the extra step. Perhaps negligible ...

As of PHP 7.4, this is convenient and IDE-friendly:

myFunction(fn() => MyClass::staticMethod());

This is because of the difference between passing constant and function. Passing parameter name without parentheses means constant(MyClass::staticMethod) and with parentheses it means a static function(MyClass::staticMethod()).

this will show 6 for the the first call and 9 for the second call in output.

$staticmethod1 = function ($max)
{
    return $max*2;
};

$staticmethod2 = function ($max)
{
    return $max*$max;
};

function myfunction($x){
    echo $x(3);
}

myfunction($staticmethod1);
myfunction($staticmethod2);