Wywołanie domknięcia przypisanego bezpośrednio do właściwości obiektu

Chciałbym móc wywołać zamknięcie, które przypisuję bezpośrednio do właściwości obiektu, bez ponownego przypisywania zamknięcia do zmiennej, a następnie wywoływania jej. czy to możliwe?

Poniższy kod nie działa i powoduje Fatal error: Call to undefined method stdClass::callback().

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

Od PHP7 możesz to zrobić

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

lub użyj Closure :: call () , chociaż to nie działa naStdClass .

Przed PHP7 musiałbyś zaimplementować magiczną __callmetodę, aby przechwycić wywołanie i wywołać wywołanie zwrotne (co StdClassoczywiście nie jest możliwe , ponieważ nie możesz dodać __callmetody)

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

Pamiętaj, że nie możesz tego zrobić

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

w __callciele, ponieważ wywołałoby __callto nieskończoną pętlę.

Możesz to zrobić, wywołując __invoke przy zamykaniu, ponieważ jest to magiczna metoda, której używają obiekty, aby zachowywać 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ż prawidłowymi wywołaniami zwrotnymi w PHP) - tylko dla zamknięć i innych obiektów z zachowaniem __invoke.

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

($obj->callback)();

Od PHP 7 domknięcie można wywołać call()metodą:

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

Ponieważ PHP 7 jest możliwe do wykonywania operacji również na dowolnych (...)wyrażeniach (jak wyjaśniono w Korikulum ):

($obj->callback)();

Inne popularne podejścia do PHP 5 to:

• używając magicznej metody __invoke()(jak wyjaśnił Brilliand )

  $obj->callback->__invoke();

• za pomocą call_user_func()funkcji

  call_user_func($obj->callback);

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

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

Każdy sposób ma swoje wady i zalety, ale najbardziej radykalnym i ostatecznym rozwiązaniem pozostaje to, które przedstawił 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();

Wydaje się, że jest to możliwe przy użyciu call_user_func().

call_user_func($obj->callback);

choć nie eleganckie ... To, co mówi @Gordon, jest prawdopodobnie jedyną drogą.

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

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

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

$obj['callback']();

Ale to nie jest najładniejsza składnia.

Jednakże parsera PHP zawsze traktuje T_OBJECT_OPERATOR, IDENTIFIER, (jako metoda połączenia. Wydaje się, że nie ma obejścia umożliwiającego ->ominięcie tabeli metod i uzyskanie dostępu do atrybutów.

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

Najpierw utwórz cechę, która umożliwia wywołanie właściwości:

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

Następnie możesz użyć tej cechy na swoich zajęciach:

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

cóż, należy podkreślić, że przechowywanie zamknięcia w zmiennej i wywołanie zmiennej jest faktycznie (dziwnie) szybsze, w zależności od kwoty połączenia, staje się całkiem sporo, z xdebug (tak bardzo precyzyjnym pomiarem), o którym mówimy 1,5 (współczynnik, używając zmiennej, zamiast bezpośrednio wywoływać __invoke, więc zamiast tego po prostu zapisz zamknięcie w zmiennej i wywołaj ją.

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

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 jest użyć call_user_funclub __invokechociaż.

Zaktualizowano:

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

PHP> = 7:

($obj->callback)();

PHP> = 5,4:

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

Jeśli używasz PHP 5.4 lub nowszego, możesz powiązać wywołanie z zakresem swojego obiektu, aby wywołać niestandardowe zachowanie. Na przykład, jeśli miałbyś skonfigurować 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);
}

A ty działałeś na takiej klasie ...

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

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

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

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

Zauważam, że działa to w PHP5.5

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

Umożliwia tworzenie kolekcji domknięć typu pseudo-obiektowego.