Doğrudan nesne özelliğine atanan kapatma çağrısı

Bir nesnenin özelliğine atadığım bir closure'u bir değişkene yeniden atamadan ve sonra onu çağırmadan doğrudan çağırabilmek istiyorum. Mümkün mü?

Aşağıdaki kod çalışmıyor ve nedenleri Fatal error: Call to undefined method stdClass::callback().

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

PHP7'den itibaren şunları yapabilirsiniz:

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

veya Closure :: call () kullanın , ancak bu bir StdClass.

PHP7'den önce __call, çağrıyı durdurmak ve geri aramayı başlatmak için sihirli yöntemi uygulamanız gerekir (bu StdClasselbette mümkün değildir , çünkü __callyöntemi ekleyemezsiniz )

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

Yapamayacağınızı unutmayın

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

içinde __callvücutta bu tetikleyecek çünkü __callsonsuz döngüye.

Bunu kapanışta __invoke çağırarak yapabilirsiniz, çünkü nesnelerin işlevler gibi davranmak için kullandığı sihirli yöntem budur:

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

Elbette geriçağırım bir dizi veya dizge ise (PHP'de de geçerli geri çağırmalar olabilir) - sadece __invoke davranışına sahip kapanışlar ve diğer nesneler için bu işe yaramaz.

İtibariyle PHP 7 aşağıdakileri yapabilirsiniz:

($obj->callback)();

PHP 7'den beri şu call()yöntem kullanılarak bir kapatma çağrılabilir :

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

Yana PHP 7 keyfi işlemleri yürütmek mümkündür (...)(açıklanabilir olarak çok ifadeler Korikulum ):

($obj->callback)();

Diğer yaygın PHP 5 yaklaşımları şunlardır:

• sihirli yöntemi kullanarak __invoke()( Brilliand tarafından açıklandığı gibi )

  $obj->callback->__invoke();

• call_user_func()işlevi kullanarak

  call_user_func($obj->callback);

• bir ifadede bir ara değişken kullanmak

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

Her yolun kendi artıları ve eksileri vardır, ancak en radikal ve kesin çözüm hala Gordon tarafından sunulan çözümdür .

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

Kullanmak mümkün görünüyor call_user_func().

call_user_func($obj->callback);

Yine de zarif değil .... @Gordon'un söylediği muhtemelen gitmenin tek yolu.

Eğer gerçekten ısrar ediyorsan . Başka bir geçici çözüm şudur:

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

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

$obj['callback']();

Ama bu en güzel sözdizimi değil.

Ancak, PHP çözümleyici hep davranır T_OBJECT_OPERATOR, IDENTIFIER, (yöntem çağrısı gibi. ->Yöntem tablosunu atlamak ve bunun yerine özniteliklere erişmek için bir çözüm yok gibi görünüyor .

Bunun eski olduğunu biliyorum, ancak PHP 5.4+ kullanıyorsanız Traits'in bu sorunu iyi bir şekilde ele aldığını düşünüyorum.

İlk olarak, özellikleri çağrılabilir kılan bir özellik oluşturun:

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

Ardından, bu özelliği sınıflarınızda kullanabilirsiniz:

class CallableStdClass extends stdClass {
    use CallableProperty;
}

Artık özellikleri anonim işlevler aracılığıyla tanımlayabilir ve bunları doğrudan çağırabilirsiniz:

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

Peki, kapanışı bir değişkene kaydetmenin ve değişken olarak adlandırmanın aslında (garip) daha hızlı olduğu vurgulanmalı, çağrı miktarına bağlı olarak, xdebug ile (çok hassas ölçüm) oldukça fazla oluyor, bundan bahsediyoruz 1,5 (__invoke'u doğrudan çağırmak yerine bir değişken kullanarak çarpan. Bunun yerine, kapanışı bir değişkende saklayın ve çağırın.

İşte kabul edilen yanıta dayalı ancak stdClass'ı doğrudan genişleten başka bir alternatif:

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

Kullanım örneği:

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

Kullanmanız call_user_funcya __invokeda kullanmanız muhtemelen daha iyidir .

Güncellenmiş:

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

PHP> = 7:

($obj->callback)();

PHP> = 5.4:

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

PHP 5.4 veya üstünü kullanıyorsanız, özel davranışı çağırmak için çağrılabilir bir nesneyi nesnenizin kapsamına bağlayabilirsiniz. Öyleyse, örneğin aşağıdaki ayarları yaparsanız ..

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

Ve böyle bir sınıfta çalışıyordun ..

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

Kendi mantığınızı, sanki nesnenizin kapsamı dahilinde çalışıyormuşsunuz gibi çalıştırabilirsiniz.

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

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

Bunun PHP5.5'te çalıştığını not ediyorum

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

Birinin bir psuedo-nesne kapanış koleksiyonu oluşturmasına izin verir.