Appel de la fermeture affectée directement à la propriété de l'objet

Je voudrais pouvoir appeler une fermeture que j'attribue directement à la propriété d'un objet sans réaffecter la fermeture à une variable puis l'appeler. Est-ce possible?

Le code ci-dessous ne fonctionne pas et provoque Fatal error: Call to undefined method stdClass::callback().

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

Depuis PHP7, vous pouvez faire

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

ou utilisez Closure :: call () , bien que cela ne fonctionne pas sur un StdClass.

Avant PHP7, vous deviez implémenter la __callméthode magique pour intercepter l'appel et invoquer le rappel (ce qui n'est pas possible pour StdClassbien sûr, car vous ne pouvez pas ajouter la __callméthode)

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');

Notez que vous ne pouvez pas faire

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

dans le __callcorps, car cela se déclencherait __calldans une boucle infinie.

Vous pouvez le faire en appelant __invoke sur la fermeture, car c'est la méthode magique que les objets utilisent pour se comporter comme des fonctions:

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

Bien sûr, cela ne fonctionnera pas si le rappel est un tableau ou une chaîne (qui peuvent également être des rappels valides en PHP) - juste pour les fermetures et autres objets avec le comportement __invoke.

À partir de PHP 7, vous pouvez effectuer les opérations suivantes:

($obj->callback)();

Depuis PHP 7, une fermeture peut être appelée en utilisant la call()méthode:

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

Puisque PHP 7 est également possible d'exécuter des opérations sur des (...)expressions arbitraires (comme expliqué par Korikulum ):

($obj->callback)();

Les autres approches courantes de PHP 5 sont:

• en utilisant la méthode magique __invoke()(comme expliqué par Brilliand )

  $obj->callback->__invoke();

• en utilisant la call_user_func()fonction

  call_user_func($obj->callback);

• utilisation d'une variable intermédiaire dans une expression

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

Chaque voie a ses avantages et ses inconvénients, mais la solution la plus radicale et la plus définitive reste celle présentée par 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();

Il semble possible d'utiliser call_user_func().

call_user_func($obj->callback);

pas élégant, cependant ... Ce que @Gordon dit est probablement la seule voie à suivre.

Eh bien, si vous insistez vraiment . Une autre solution de contournement serait:

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

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

$obj['callback']();

Mais ce n'est pas la meilleure syntaxe.

Cependant, l'analyseur PHP traite toujours T_OBJECT_OPERATOR, IDENTIFIER, (comme appel de méthode. Il ne semble y avoir aucune solution de contournement pour ->contourner la table de méthodes et accéder aux attributs à la place.

Je sais que c'est vieux, mais je pense que Traits gère bien ce problème si vous utilisez PHP 5.4+

Tout d'abord, créez un trait qui rend les propriétés appelables:

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

Ensuite, vous pouvez utiliser ce trait dans vos classes:

class CallableStdClass extends stdClass {
    use CallableProperty;
}

Désormais, vous pouvez définir des propriétés via des fonctions anonymes et les appeler directement:

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

eh bien, il faut bien comprendre que stocker la fermeture dans une variable, et appeler la variable est en fait (bizarrement) plus rapide, en fonction du montant de l'appel, ça devient pas mal, avec xdebug (donc mesure très précise), on parle 1,5 (le facteur, en utilisant une variable, au lieu d'appeler directement __invoke. Donc à la place, stockez simplement la fermeture dans une variable et appelez-la.

Actualisé:

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

PHP> = 7:

($obj->callback)();

PHP> = 5.4:

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

Voici une autre alternative basée sur la réponse acceptée mais en étendant directement stdClass:

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

Exemple d'utilisation:

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

Vous êtes probablement mieux d'utiliser call_user_funcou __invokecependant.

Si vous utilisez PHP 5.4 ou supérieur, vous pouvez lier un appelable à la portée de votre objet pour invoquer un comportement personnalisé. Par exemple, si vous devez configurer la configuration suivante.

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

Et vous travailliez sur une classe comme ça ...

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

Vous pouvez exécuter votre propre logique comme si vous opériez dans le cadre de votre objet

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

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

Je note que cela fonctionne en PHP5.5

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

Permet de créer une collection de fermetures psuedo-object.