L'appel de fermeture assigné à la propriété de l'objet directement

De PHP7, vous pouvez le faire

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

ou de l'utilisation Fermeture::call(), si cela ne fonctionne pas sur un StdClass.

---

Avant PHP7, vous auriez à mettre en œuvre la magie __call méthode pour intercepter l'appel et appeler la fonction de rappel (qui n'est pas possible pour StdClass bien sûr, parce que vous ne pouvez pas ajouter le __call mé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 __call corps, car cela déclencherait __call dans une boucle infinie.

OriginalL'auteur Gordon

De le PHP 7 vous pouvez effectuer les opérations suivantes:

($obj->callback)();

OriginalL'auteur Korikulum

Bien, si vous vraiment insister. Une autre solution serait:

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

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

$obj['callback']();

Mais ce n'est pas la plus belle de la syntaxe.

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

OriginalL'auteur mario

Depuis PHP 7 une clôture peut être appelée à l'aide de la call() méthode:

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

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

($obj->callback)();

Autres communes PHP 5 approches sont les suivantes:

• à l'aide de la méthode magique __invoke() (comme expliqué par Brilliand)

  $obj->callback->__invoke();

• à l'aide de la call_user_func() fonction

  call_user_func($obj->callback);

• à l'aide d'un variable intermédiaire dans une expression

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

Chacune a ses propres avantages et inconvénients, mais le changement le plus radical et définitif de la solution reste encore l'un présenté 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();

OriginalL'auteur Daniele Orlando

eh bien, il devrait être emphisized que le stockage de la fermeture dans une variable, et d'appeler la varible est en fait (wierdly) plus rapide, selon l'appel montant, il devient tout à fait un lot, avec xdebug (donc très précis de mesure), nous parlons de 1,5 (le facteur, en utilisant une varible, au lieu de directement de l'appel de la __invoke. donc , il suffit de stocker la fermeture d'une varible et de l'appeler.

OriginalL'auteur Kmtdk

Si vous utilisez PHP 5.4 ou au-dessus, vous pouvez lier un objet appelable à la portée de votre objet pour invoquer un comportement personnalisé. Ainsi par exemple, si vous avez le jeu suivant..

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

Et vous étiez d'exploitation sur une classe comme si..

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

Vous pouvez exécuter votre propre logique, comme si vous étiez d'exploitation à partir de la portée de votre objet

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

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

OriginalL'auteur Lee Davis