Memanggil closure yang ditugaskan ke properti objek secara langsung

Saya ingin dapat memanggil closure yang saya tetapkan ke properti objek secara langsung tanpa menetapkan ulang closure ke variabel dan kemudian memanggilnya. Apakah ini mungkin?

Kode di bawah ini tidak berfungsi dan menyebabkan Fatal error: Call to undefined method stdClass::callback().

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

Pada PHP7, Anda dapat melakukannya

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

atau gunakan Closure :: call () , meskipun itu tidak berfungsi pada a StdClass.

Sebelum PHP7, Anda harus menerapkan __callmetode ajaib untuk mencegat panggilan dan memanggil kembali (yang StdClasstentu saja tidak mungkin , karena Anda tidak dapat menambahkan __callmetode)

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

Perhatikan bahwa Anda tidak dapat melakukannya

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

dalam __calltubuh, karena ini akan memicu __calldalam putaran tak terbatas.

Anda bisa melakukan ini dengan memanggil __invoke pada closure, karena itulah metode ajaib yang digunakan objek untuk berperilaku seperti fungsi:

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

Tentu saja itu tidak akan berfungsi jika callback adalah larik atau string (yang juga bisa menjadi callback valid dalam PHP) - hanya untuk closure dan objek lain dengan perilaku __invoke.

Mulai PHP 7, Anda dapat melakukan hal berikut:

($obj->callback)();

Sejak PHP 7 penutupan dapat dipanggil menggunakan call()metode:

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

Karena PHP 7 juga memungkinkan untuk menjalankan operasi pada (...)ekspresi sembarang (seperti yang dijelaskan oleh Korikulum ):

($obj->callback)();

Pendekatan umum PHP 5 lainnya adalah:

• menggunakan metode ajaib __invoke()(seperti yang dijelaskan oleh Brilliand )

  $obj->callback->__invoke();

• menggunakan call_user_func()fungsi tersebut

  call_user_func($obj->callback);

• menggunakan variabel perantara dalam ekspresi

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

Masing-masing cara memiliki pro dan kontranya masing-masing, namun solusi yang paling radikal dan pasti tetap yang dihadirkan oleh 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();

Sepertinya bisa digunakan call_user_func().

call_user_func($obj->callback);

tidak elegan, meskipun .... Apa yang dikatakan @Gordon mungkin satu-satunya cara untuk pergi.

Nah, jika Anda benar-benar bersikeras. Solusi lain adalah:

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

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

$obj['callback']();

Tapi itu bukan sintaks terbaik.

Namun, PHP parser selalu memperlakukan T_OBJECT_OPERATOR, IDENTIFIER, (sebagai metode panggilan. Tampaknya tidak ada solusi untuk membuat ->bypass tabel metode dan mengakses atribut sebagai gantinya.

Saya tahu ini sudah tua, tapi saya pikir Sifat menangani masalah ini dengan baik jika Anda menggunakan PHP 5.4+

Pertama, buat sifat yang membuat properti bisa dipanggil:

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

Kemudian, Anda dapat menggunakan sifat itu di kelas Anda:

class CallableStdClass extends stdClass {
    use CallableProperty;
}

Sekarang, Anda dapat mendefinisikan properti melalui fungsi anonim dan memanggilnya secara langsung:

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

baik, harus ditekankan bahwa menyimpan closure dalam sebuah variabel, dan memanggil varible sebenarnya (anehnya) lebih cepat, tergantung pada jumlah panggilan, itu menjadi cukup banyak, dengan xdebug (pengukuran yang sangat tepat), kita sedang membicarakan 1,5 (faktor, dengan menggunakan varible, alih-alih langsung memanggil __invoke. Jadi sebagai gantinya, cukup simpan closure dalam varible dan panggil.

Diperbarui:

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

PHP> = 7:

($obj->callback)();

PHP> = 5,4:

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

Berikut alternatif lain berdasarkan jawaban yang diterima tetapi memperluas stdClass secara langsung:

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

Contoh penggunaan:

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

Anda mungkin lebih baik menggunakan call_user_funcatau __invokemeskipun.

Jika Anda menggunakan PHP 5.4 atau yang lebih baru, Anda dapat mengikat callable ke cakupan objek Anda untuk menjalankan perilaku kustom. Jadi misalnya jika Anda memiliki pengaturan berikut ..

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

Dan Anda beroperasi di kelas seperti itu ..

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

Anda bisa menjalankan logika Anda sendiri seolah-olah Anda beroperasi dari dalam lingkup objek Anda

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

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

Saya perhatikan bahwa ini berfungsi di PHP5.5

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

Mengizinkan seseorang untuk membuat kumpulan objek psuedo dari penutupan.