predefinidas - listado funciones php

Algo así como una función de delegado de devolución de llamada en php

Question

Me gustaría implementar algo similar al método delegado ac # en PHP. Una palabra rápida para explicar lo que trato de hacer en general: estoy tratando de implementar algunas funcionalidades asincrónicas. Básicamente, algunas llamadas de uso intensivo de recursos que se ponen en cola, se almacenan en caché y se envían cuando el sistema subyacente se acerca. Cuando la llamada asíncrona finalmente recibe una respuesta, me gustaría que se produzca un evento de devolución de llamada.

Tengo algunos problemas para crear un mecanismo para hacer devoluciones de llamada en PHP. He encontrado un método que funciona por ahora pero no estoy contento con él. Básicamente implica pasar una referencia al objeto y el nombre del método que servirá como la devolución de llamada (tomando la respuesta como argumento) y luego usar eval para llamar al método cuando sea necesario. Esto no es óptimo por una variedad de razones, ¿hay alguna manera mejor de hacer esto que nadie sepa?

Answer 1

¿Cómo te sientes al usar el patrón Observer ? De lo contrario, puede implementar una devolución de llamada verdadera de esta manera:

// This function uses a callback function. 
function doIt($callback) 
{ 
    $data = "this is my data";
    $callback($data); 
} 


// This is a sample callback function for doIt(). 
function myCallback($data) 
{ 
    print ''Data is: '' .  $data .  "/n"; 
} 


// Call doIt() and pass our sample callback function''s name. 
doIt(''myCallback''); 

Displays: Data is: this is my data

Answer 2

Me preguntaba si podríamos usar el método __invoke magic para crear una especie de "primera clase" y así implementar una devolución de llamada

Suena algo así, para PHP 5.3

interface Callback 
{
    public function __invoke(); 
}

class MyCallback implements Callback
{
    private function sayHello () { echo "Hello"; }
    public function __invoke ()  { $this->sayHello(); } 
}

class MySecondCallback implements Callback
{
    private function sayThere () { echo "World"; }
    public function __invoke ()  { $this->sayThere(); }
}

class WhatToPrint
{
    protected $callbacks = array();
    public function register (Callback $callback) 
    {
        $this->callbacks[] = $callback;
        return $this;
    }
    public function saySomething ()
    {
        foreach ($this->callbacks as $callback) $callback(); 
    }
}

$first_callback = new MyCallback;
$second_callback = new MySecondCallback;
$wrapper = new WhatToPrint;
$wrapper->register($first_callback)->register($second_callback)->saySomething();

Se imprimirá HelloWorld

Espero que ayude;)

Pero preferiría el patrón del Controlador con SPL para esa característica.

Answer 3

(Además del patrón de observador) también puede usar call_user_func() o call_user_func_array() .

Si pasa una array(obj, methodname) como primer parámetro, se invocará como $obj->methodname() .

<?php
class Foo {
    public function bar($x) {
        echo $x;
    }
}

function xyz($cb) {
    $value = rand(1,100);
    call_user_func($cb, $value);
}

$foo = new Foo;
xyz( array($foo, ''bar'') );
?>