Wie implementiere ich einen Rückruf in PHP?

Wie werden Rückrufe in PHP geschrieben?

Das Handbuch verwendet die Begriffe "Rückruf" und "aufrufbar" synonym. "Rückruf" bezieht sich jedoch traditionell auf einen Zeichenfolgen- oder Arraywert, der wie ein Funktionszeiger fungiert und auf eine Funktion oder Klassenmethode für zukünftige Aufrufe verweist. Dies hat einige Elemente der funktionalen Programmierung seit PHP 4 ermöglicht. Die Aromen sind:

$cb1 = 'someGlobalFunction';
$cb2 = ['ClassName', 'someStaticMethod'];
$cb3 = [$object, 'somePublicMethod'];

// this syntax is callable since PHP 5.2.3 but a string containing it
// cannot be called directly
$cb2 = 'ClassName::someStaticMethod';
$cb2(); // fatal error

// legacy syntax for PHP 4
$cb3 = array(&$object, 'somePublicMethod');

Dies ist eine sichere Methode, um aufrufbare Werte im Allgemeinen zu verwenden:

if (is_callable($cb2)) {
    // Autoloading will be invoked to load the class "ClassName" if it's not
    // yet defined, and PHP will check that the class has a method
    // "someStaticMethod". Note that is_callable() will NOT verify that the
    // method can safely be executed in static context.

    $returnValue = call_user_func($cb2, $arg1, $arg2);
}

In modernen PHP-Versionen können die ersten drei oben genannten Formate direkt als aufgerufen werden $cb(). call_user_funcund call_user_func_arrayunterstütze alle oben genannten.

Siehe: http://php.net/manual/en/language.types.callable.php

Anmerkungen / Vorsichtsmaßnahmen:

1. Wenn die Funktion / Klasse einen Namespace hat, muss die Zeichenfolge den vollständig qualifizierten Namen enthalten. Z.B['Vendor\Package\Foo', 'method']
2. call_user_funcunterstützt die Übergabe von Nichtobjekten als Referenz nicht, daher können Sie call_user_func_arrayden Rückruf entweder verwenden oder in späteren PHP-Versionen in einer Variablen speichern und die direkte Syntax verwenden : $cb();
3. Objekte mit einer __invoke()Methode (einschließlich anonymer Funktionen) fallen unter die Kategorie "aufrufbar" und können auf die gleiche Weise verwendet werden, aber ich persönlich verbinde diese nicht mit dem alten Begriff "Rückruf".
4. Das Erbe create_function()erstellt eine globale Funktion und gibt ihren Namen zurück. Es ist ein Wrapper für eval()und anonyme Funktionen sollten stattdessen verwendet werden.

Mit PHP 5.3 können Sie dies jetzt tun:

function doIt($callback) { $callback(); }

doIt(function() {
    // this will be done
});

Endlich ein schöner Weg, es zu tun. Eine großartige Ergänzung zu PHP, denn Rückrufe sind fantastisch.

Die Implementierung eines Rückrufs erfolgt auf diese Weise

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

Anzeigen: Daten sind: Dies sind meine Daten

Ein raffinierter Trick, den ich kürzlich gefunden habe, ist die Verwendung von PHPs create_function(), um eine anonyme / Lambda-Funktion für die einmalige Verwendung zu erstellen. Es ist nützlich für die PHP - Funktionen wie array_map(), preg_replace_callback()oder usort()dass die Verwendung Rückrufe für benutzerdefinierte Verarbeitung. Es sieht ziemlich ähnlich aus wie eval()unter der Decke, aber es ist immer noch eine nette funktionale Art, PHP zu verwenden.

Nun ... mit 5.3 am Horizont wird alles besser, denn mit 5.3 erhalten wir Schließungen und mit ihnen anonyme Funktionen

http://wiki.php.net/rfc/closures

Sie möchten überprüfen, ob Ihr Anruf gültig ist. Im Fall einer bestimmten Funktion möchten Sie beispielsweise überprüfen, ob die Funktion vorhanden ist:

function doIt($callback) {
    if(function_exists($callback)) {
        $callback();
    } else {
        // some error handling
    }
}

create_functionhat in einer Klasse nicht für mich gearbeitet. Ich musste benutzencall_user_func .

<?php

class Dispatcher {
    //Added explicit callback declaration.
    var $callback;

    public function Dispatcher( $callback ){
         $this->callback = $callback;
    }

    public function asynchronous_method(){
       //do asynch stuff, like fwrite...then, fire callback.
       if ( isset( $this->callback ) ) {
            if (function_exists( $this->callback )) call_user_func( $this->callback, "File done!" );
        }
    }

}

Dann zu verwenden:

<?php 
include_once('Dispatcher.php');
$d = new Dispatcher( 'do_callback' );
$d->asynchronous_method();

function do_callback( $data ){
   print 'Data is: ' .  $data .  "\n";
}
?>

[Bearbeiten] Eine fehlende Klammer wurde hinzugefügt. Außerdem habe ich die Rückrufdeklaration hinzugefügt, ich bevorzuge es so.

Ich erschrecke jedes Mal, wenn ich create_function()in PHP benutze .

Parameter sind eine durch Koma getrennte Zeichenfolge, der gesamte Funktionskörper in einer Zeichenfolge ... Argh ... Ich denke, sie hätten es nicht hässlicher machen können, selbst wenn sie es versucht hätten.

Leider ist es die einzige Wahl, wenn eine benannte Funktion erstellt wird, die Mühe nicht wert ist.

Für diejenigen, denen es nicht wichtig ist, die Kompatibilität mit PHP zu beeinträchtigen < 5.4, würde ich die Verwendung von Typhinweisen empfehlen, um eine sauberere Implementierung zu erzielen.

function call_with_hello_and_append_world( callable $callback )
{
     // No need to check $closure because of the type hint
     return $callback( "hello" )."world";
}

function append_space( $string )
{
     return $string." ";
}

$output1 = call_with_hello_and_append_world( function( $string ) { return $string." "; } );
var_dump( $output1 ); // string(11) "hello world"

$output2 = call_with_hello_and_append_world( "append_space" );
var_dump( $output2 ); // string(11) "hello world"

$old_lambda = create_function( '$string', 'return $string." ";' );
$output3 = call_with_hello_and_append_world( $old_lambda );
var_dump( $output3 ); // string(11) "hello world"