Callbacks / Callables

    Callbacks können mit der Typdeklaration callable gekennzeichnet werden.

    Einige Funktionen wie call_user_func() oder usort() akzeptieren eine benutzerdefinierte Callback-Funktion als Argument. Callback-Funktionen können nicht nur einfache Funktionen sein, sondern auch Methoden eines Objects, inklusive statischer Klassenmethoden.

    Übergabe

    Eine PHP-Funktion wird anhand ihres Namens als String übergeben. Jede eingebaute oder benutzerdefinierte Funktion kann verwendet werden, außer Sprachkonstrukten wie: array(), echo, empty(), eval(), exit(), isset(), list(), print oder unset().

    Eine Methode eines instantiierten Objects wird übergeben als Array mit dem Object an Index-Position 0 und dem Methodennamen an Position 1. Der Zugriff auf als protected oder private markierte Methoden von innerhalb der Klasse ist erlaubt.

    Statische Klassenmethoden können auch übergeben werden, ohne dass ein Object dieser Klasse instantiiert werden muss, indem man entweder den Namen der Klasse statt eines Objects als Index 0 übergibt oder indem man 'ClassName::methodName' übergibt.

    Neben den üblichen benutzerdefinierten Funktionen können auch anonyme Funktionen oder Pfeilfunktionen als Callback-Argumente übergeben werden.

    Hinweis:

    Seit PHP 8.1.0 können anonyme Funktionen auch mit der Callback-Funktionen als Objekte erster Klasse erstellt werden.

    Generell kann jedes Objekt, welches __invoke() implementiert, als Callback-Argument übergeben werden.

    Beispiel #1 Beispiele für Callback-Funktionen

    <?php

    // Eine Beispiel-Callback-Funktion
    function my_callback_function() {
    echo     'hello world!';
    }

    // Eine Beispiel-Callback-Methode
    class MyClass {
    static function     myCallbackMethod() {
    echo     'Hello World!';
    }
    }

    // Typ 1: Einfaches Callback
    call_user_func('my_callback_function');

    // Typ 2: Statischer Methodenaufruf
    call_user_func(array('MyClass', 'myCallbackMethod'));

    // Typ 3: Aufruf einer Objektmethode
    $obj = new MyClass();
    call_user_func(array($obj, 'myCallbackMethod'));

    // Typ 4: Statischer Methodenaufruf
    call_user_func('MyClass::myCallbackMethod');

    // Typ 5: Relativer statischer Methodenaufruf
    class A {
    public static function     who() {
    echo     "A\n";
    }
    }

    class     B extends A {
    public static function     who() {
    echo     "B\n";
    }
    }

    call_user_func(array('B', 'parent::who')); // A, seit PHP 8.2.0 veraltet

    // Typ 6: Objekte die __invoke implementieren können als Callable verwendet werden
    class C {
    public function     __invoke($name) {
    echo     'Hello ', $name, "\n";
    }
    }

    $c = new C();
    call_user_func($c, 'PHP!');
    ?>

    Beispiel #2 Callback-Beispiel mit einem Closure

    <?php
    // Unser Closure
    $double = function($a) {
    return     $a * 2;
    };

    // Dies ist unsere Menge an Zahlen
    $numbers = range(1, 5);

    // Hier verwenden wir das Callback, um
    // den Wert jedes Elements in unserer
    // Menge zu verdoppeln
    $new_numbers = array_map($double, $numbers);

    print     implode(' ', $new_numbers);
    ?>

    Das oben gezeigte Beispiel erzeugt folgende Ausgabe:

     2 4 6 8 10

    Hinweis:

    Callbacks, die für Funktionen wie call_user_func() und call_user_func_array() registriert sind, werden nicht mehr ausgeführt, wenn in einem vorherigen Callback eine Exception geworfen und nicht gefangen wurde.

    To Top