Llamar al cierre asignado a la propiedad del objeto directamente

Me gustaría poder llamar a un cierre que asigno a la propiedad de un objeto directamente sin reasignar el cierre a una variable y luego llamarlo. es posible?

El siguiente código no funciona y causa Fatal error: Call to undefined method stdClass::callback().

$obj = new stdClass();
$obj->callback = function() {
    print "HelloWorld!";
};
$obj->callback();

A partir de PHP7, puede hacer

$obj = new StdClass;
$obj->fn = function($arg) { return "Hello $arg"; };
echo ($obj->fn)('World');

o use Closure :: call () , aunque eso no funciona en un StdClass.

Antes de PHP7, tendría que implementar el __callmétodo mágico para interceptar la llamada e invocar la devolución de llamada (lo cual no es posible, por StdClasssupuesto, porque no puede agregar el __callmétodo)

class Foo
{
    public function __call($method, $args)
    {
        if(is_callable(array($this, $method))) {
            return call_user_func_array($this->$method, $args);
        }
        // else throw exception
    }
}

$foo = new Foo;
$foo->cb = function($who) { return "Hello $who"; };
echo $foo->cb('World');

Tenga en cuenta que no puede hacer

return call_user_func_array(array($this, $method), $args);

en el __callcuerpo, porque esto se dispararía __callen un bucle infinito.

Puede hacer esto llamando a __invoke en el cierre, ya que ese es el método mágico que usan los objetos para comportarse como funciones:

$obj = new stdClass();
$obj->callback = function() {
    print "HelloWorld!";
};
$obj->callback->__invoke();

Por supuesto, eso no funcionará si la devolución de llamada es una matriz o una cadena (que también pueden ser devoluciones de llamada válidas en PHP), solo para cierres y otros objetos con comportamiento __invoke.

A partir de PHP 7 , puede hacer lo siguiente:

($obj->callback)();

Desde PHP 7, se puede llamar a un cierre usando el call()método:

$obj->callback->call($obj);

Dado que PHP 7 también es posible ejecutar operaciones en (...)expresiones arbitrarias (como lo explica Korikulum ):

($obj->callback)();

Otros enfoques comunes de PHP 5 son:

• usando el método mágico __invoke()(como lo explica Brilliand )

  $obj->callback->__invoke();

• usando la call_user_func()función

  call_user_func($obj->callback);

• usando una variable intermedia en una expresión

  ($_ = $obj->callback) && $_();

Cada camino tiene sus pros y sus contras, pero la solución más radical y definitiva sigue siendo la que presenta Gordon .

class stdKlass
{
    public function __call($method, $arguments)
    {
        // is_callable([$this, $method])
        //   returns always true when __call() is defined.

        // is_callable($this->$method)
        //   triggers a "PHP Notice: Undefined property" in case of missing property.

        if (isset($this->$method) && is_callable($this->$method)) {
            return call_user_func($this->$method, ...$arguments);
        }

        // throw exception
    }
}

$obj = new stdKlass();
$obj->callback = function() { print "HelloWorld!"; };
$obj->callback();

Parece ser posible usar call_user_func().

call_user_func($obj->callback);

aunque no es elegante ... Lo que dice @Gordon es probablemente el único camino a seguir.

Bueno, si realmente insistes. Otra solución alternativa sería:

$obj = new ArrayObject(array(),2);

$obj->callback = function() {
    print "HelloWorld!";
};

$obj['callback']();

Pero esa no es la mejor sintaxis.

Sin embargo, el intérprete PHP siempre trata T_OBJECT_OPERATOR, IDENTIFIER, (como llamada al método. Parece que no hay una solución alternativa para ->omitir la tabla de métodos y acceder a los atributos.

Sé que esto es antiguo, pero creo que Traits maneja muy bien este problema si está utilizando PHP 5.4+

Primero, cree un rasgo que haga que las propiedades sean invocables:

trait CallableProperty {
    public function __call($method, $args) {
        if (property_exists($this, $method) && is_callable($this->$method)) {
            return call_user_func_array($this->$method, $args);
        }
    }
}

Luego, puedes usar ese rasgo en tus clases:

class CallableStdClass extends stdClass {
    use CallableProperty;
}

Ahora, puede definir propiedades a través de funciones anónimas y llamarlas directamente:

$foo = new CallableStdClass();
$foo->add = function ($a, $b) { return $a + $b; };
$foo->add(2, 2); // 4

bueno, debe enfatizarse que almacenar el cierre en una variable y llamar a la variable es en realidad (extrañamente) más rápido, dependiendo de la cantidad de la llamada, se vuelve bastante, con xdebug (medición tan precisa), estamos hablando de 1,5 (el factor, al usar una variable, en lugar de llamar directamente a __invoke. Así que en su lugar, simplemente almacene el cierre en una variable y llámelo.

Actualizado:

$obj = new stdClass();
$obj->callback = function() {
     print "HelloWorld!";
};

PHP> = 7:

($obj->callback)();

PHP> = 5.4:

$callback = $obj->callback;  
$callback();

Aquí hay otra alternativa basada en la respuesta aceptada pero extendiendo stdClass directamente:

class stdClassExt extends stdClass {
    public function __call($method, $args)
    {
        if (isset($this->$method)) {
            $func = $this->$method;
            return call_user_func_array($func, $args);
        }
    }
}

Ejemplo de uso:

$foo = new stdClassExt;
$foo->blub = 42;
$foo->whooho = function () { return 1; };
echo $foo->whooho();

Probablemente sea mejor usar call_user_funco __invokeaunque.

Si está utilizando PHP 5.4 o superior, puede vincular un invocable al alcance de su objeto para invocar un comportamiento personalizado. Entonces, por ejemplo, si tuviera que configurar lo siguiente ...

function run_method($object, Closure $method)
{
    $prop = uniqid();
    $object->$prop = \Closure::bind($method, $object, $object);
    $object->$prop->__invoke();
    unset($object->$prop);
}

Y estabas operando en una clase como esa ...

class Foo
{
    private $value;
    public function getValue()
    {
        return $this->value;
    }
}

Puede ejecutar su propia lógica como si estuviera operando desde dentro del alcance de su objeto

$foo = new Foo();
run_method($foo, function(){
    $this->value = 'something else';
});

echo $foo->getValue(); // prints "something else"

Observo que esto funciona en PHP5.5

$a = array();
$a['callback'] = function() {
    print "HelloWorld!";
};
$a['callback']();

Permite a uno crear una colección de cierres de objetos pseudo-objetos.