Wywołanie zamknięcia przypisanego bezpośrednio do Właściwości obiektu

Możesz to zrobić, wywołując _ _ invoke na zamknięciu, ponieważ jest to magiczna metoda, której obiekty używają do zachowania się jak Funkcje:

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

Oczywiście to nie zadziała, jeśli wywołanie zwrotne jest tablicą lub ciągiem znaków (które mogą być również poprawnymi wywołaniami zwrotnymi w PHP) - tylko dla zamknięć i innych obiektów z zachowaniem __invoke.

Od PHP 7 można wykonać następujące czynności:

($obj->callback)();

Wydaje się, że możliwe jest użycie call_user_func().

call_user_func($obj->callback);

Cóż, jeśli naprawdę. nalegaj. Innym obejściem byłoby:

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

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

$obj['callback']();

Jednak parser PHP zawsze traktuje T_OBJECT_OPERATOR, IDENTIFIER, ( jako wywołanie metody. Wydaje się, że nie ma obejścia problemu, aby -> ominąć tabelę metod i uzyskać dostęp do atrybutów.

Wiem, że jest to stare, ale myślę, że cechy dobrze radzą sobie z tym problemem, jeśli używasz PHP 5.4 +

Najpierw Utwórz cechę, która sprawia, że właściwości mogą być wywołane:

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

Wtedy możesz użyć tej cechy w swoich klasach:

class CallableStdClass extends stdClass {
    use CallableProperty;
}

Teraz możesz definiować właściwości za pomocą funkcji anonimowych i wywoływać je bezpośrednio:

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

Od PHP 7 zamknięcie można wywołać za pomocą call() "metoda": {]}

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

Od PHP 7 możliwe jest również wykonywanie operacji na dowolnych wyrażeniach (...) (jak wyjaśniono przez Korikulum):

($obj->callback)();

Inne popularne PHP 5 to:

• Używając magicznej metody __invoke() (Jak wyjaśniono przez )

  $obj->callback->__invoke();
  

• Korzystanie z call_user_func() function

  call_user_func($obj->callback);
  

• Użycie zmiennej pośredniej w wyrażeniu

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

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

Oto inny sposób na pomyślne wywołanie właściwości obiektu jako zamknięcia.
Jeśli nie chcesz zmieniać obiektu core użyj tego :

$obj = new AnyObject(); // with or without __invoke() method
$obj->callback = function() {
     return function () {
          print "HelloWorld!";
     };
};
$obj->callback();  

UPDATE:

$obj = new AnyObject(); // with or without __invoke() method
$obj->callback = function() {
     print "HelloWorld!";
};
$callback = $obj->callback;  
$callback();

Dobrze, należy podkreślić, że przechowywanie zamknięcia w zmiennej i wywołanie zmiennej jest rzeczywiście (dziwnie) szybsze, w zależności od ilości wywołania, staje się to dość dużo, z xdebug (tak bardzo precyzyjny pomiar), mówimy o 1,5 (czynnik, używając zmiennej, zamiast bezpośrednio wywoływać __invoke. więc zamiast tego, po prostu przechowywać zamknięcie w varible i nazwać go.

Oto inna alternatywa oparta na zaakceptowanej odpowiedzi, ale rozszerzająca stdClass bezpośrednio:

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

Przykład użycia:

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

Prawdopodobnie lepiej będzie używać call_user_func lub __invoke.

Jeśli używasz PHP w wersji 5.4 lub wyższej, możesz powiązać wywołanie z zakresem obiektu, aby wywołać niestandardowe zachowanie. Na przykład, jeśli masz mieć następującą konfigurację..

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

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

Możesz uruchomić własną logikę tak, jakbyś operował z zakresu swojego obiektu

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

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