PHP 5.4.45 Released

Fonctions de rappel / Types Callable

Les fonctions de rappel peuvent être identifiées via le type callable depuis PHP 5.4. Cette documentation utilise le type callback qui revient exactement au même.

Certaines fonctions, comme call_user_func() ou usort(), acceptent comme paramètre des fonctions de rappel définies par l'utilisateur. Les fonctions de rappel peuvent être de simples fonctions, mais aussi des méthodes d'objets, y compris des méthodes statiques de classe.

Passage d'une fonction de rappel

Une fonction PHP est passée par son nom, sous la forme d'une chaîne de caractères. Toute fonction interne ou définie par l'utilisateur peut être utilisée, sauf les constructions de langage comme : array(), echo, empty(), eval(), exit(), isset(), list(), print, ou unset().

Une méthode d'un objet instancié est passée comme un tableau contenant un objet à l'index 0, et le nom de la méthode à l'index 1.

Les méthodes statiques de classe peuvent aussi être passées sans instancier d'objet de cette classe, en passant le nom de la classe au lieu d'un objet à l'index 0. Depuis PHP 5.2.3, il est également possible de passer 'NomDeLaClasse::NomDeLaMethode'.

En dehors des fonctions définies normalement par l'utilisateur, une closure peut aussi être utilisée comme paramètre de type callback.

Exemple #1 Exemples de fonctions de rappel

<?php 

// Un exemple de fonction de rappel
function my_callback_function() {
    echo 
'hello world!';
}

// Un exemple de méthode de rappel
class MyClass {
    static function 
myCallbackMethod() {
        echo 
'Hello World!';
    }
}

// Type 1 : Fonction de rappel simple
call_user_func('my_callback_function'); 

// Type 2 : Appel d'une méthode statique de classe
call_user_func(array('MyClass''myCallbackMethod')); 

// Type 3 : Appel d'une méthode objet
$obj = new MyClass();
call_user_func(array($obj'myCallbackMethod'));

// Type 4 : Appel d'une méthode statique de classe (depuis PHP 5.2.3)
call_user_func('MyClass::myCallbackMethod');

// Type 5 : Appel à une méthode statique de classe relative (depuis PHP 5.3.0)
class {
    public static function 
who() {
        echo 
"A\n";
    }
}

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

call_user_func(array('B''parent::who')); // A
// Type 6 : Les objets implémentants __invoke peuvent être utilisés comme callables (depuis PHP 5.3)
class {
    public function 
__invoke($name) {
        echo 
'Hello '$name"\n";
    }
}

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

Exemple #2 Exemple d'une fonction de rappel utilisant une closure

<?php
// Notre closure
$double = function($a) {
    return 
$a 2;
};

// Ceci est notre intervalle de nombres
$numbers range(15);

// Utilisation de la closure comme fonction de rappel.
// Ici, pour doubler la taille de chaque élément de notre intervalle
$new_numbers array_map($double$numbers);

print 
implode(' '$new_numbers);
?>

L'exemple ci-dessus va afficher :

2 4 6 8 10

Note: En PHP 4, il était nécessaire d'utiliser une référence pour créer une fonction de rappel qui pointe vers un objet, et non une copie de celui-ci. Pour plus de détails, reportez-vous à l'explication sur les références.

Note:

Notez que les fonctions de rappel enregistrées avec des fonctions comme call_user_func() et call_user_func_array() ne seront pas appelées si une exception n'est pas interceptée alors qu'elle a été lancée dans une précédente fonction de rappel.

add a note add a note

User Contributed Notes 7 notes

up
142
andrewbessa at gmail dot com
3 years ago
You can also use the $this variable to specify a callback:

<?php
class MyClass {

    public
$property = 'Hello World!';

    public function
MyMethod()
    {
       
call_user_func(array($this, 'myCallbackMethod'));
    }

    public function
MyCallbackMethod()
    {
        echo
$this->property;
    }

}
?>
up
135
steve at mrclay dot org
2 years ago
Performance note: The callable type hint, like is_callable(), will trigger an autoload of the class if the value looks like a static method callback.
up
122
computrius at gmail dot com
1 year ago
When specifying a call back in array notation (ie. array($this, "myfunc") ) the method can be private if called from inside the class, but if you call it from outside you'll get a warning:

<?php

class mc {
   public function
go(array $arr) {
      
array_walk($arr, array($this, "walkIt"));
   }

   private function
walkIt($val) {
       echo
$val . "<br />";
   }

    public function
export() {
        return array(
$this, 'walkIt');
    }
}

$data = array(1,2,3,4);

$m = new mc;
$m->go($data); // valid

array_walk($data, $m->export()); // will generate warning

?>

Output:
1<br />2<br />3<br />4<br />
Warning: array_walk() expects parameter 2 to be a valid callback, cannot access private method mc::walkIt() in /in/tfh7f on line 22
up
116
edanschwartz at gmail dot com
7 months ago
You can use 'self::methodName' as a callable, but this is dangerous. Consider this example:

<?php
class Foo {
    public static function
doAwesomeThings() {
       
FunctionCaller::callIt('self::someAwesomeMethod');
    }

    public static function
someAwesomeMethod() {
       
// fantastic code goes here.
   
}
}

class
FunctionCaller {
    public static function
callIt(callable $func) {
       
call_user_func($func);
    }
}

Foo::doAwesomeThings();
?>

This results in an error:
Warning: class 'FunctionCaller' does not have a method 'someAwesomeMethod'.

For this reason you should always use the full class name:
<?php
FunctionCaller
::callIt('Foo::someAwesomeMethod');
?>

I believe this is because there is no way for FunctionCaller to know that the string 'self' at one point referred to to `Foo`.
up
117
metamarkers at gmail dot com
2 years ago
you can pass an object as a callable if its class defines the __invoke() magic method..
up
96
Riikka K
3 months ago
A note on differences when calling callbacks as "variable functions" without the use of call_user_func() (e.g. "<?php $callback = 'printf'; $callback('Hello World!') ?>"):

- Using the name of a function as string has worked since at least 4.3.0
- Calling anonymous functions and invokable objects has worked since 5.3.0
- Using the array structure [$object, 'method'] has worked since 5.4.0

Note, however, that the following are not supported when calling callbacks as variable functions, even though they are supported by call_user_func():

- Calling static class methods via strings such as 'foo::doStuff'
- Calling parent method using the [$object, 'parent::method'] array structure

All of these cases are correctly recognized as callbacks by the 'callable' type hint, however. Thus, the following code will produce an error "Fatal error: Call to undefined function foo::doStuff() in /tmp/code.php on line 4":

<?php
class foo {
    static function
callIt(callable $callback) {
       
$callback();
    }
   
    static function
doStuff() {
        echo
"Hello World!";
    }
}

foo::callIt('foo::doStuff');
?>

The code would work fine, if we replaced the '$callback()' with 'call_user_func($callback)' or if we used the array ['foo', 'doStuff'] as the callback instead.
up
105
Yzmir Ramirez
1 year ago
> As of PHP 5.2.3, it is also possible to pass 'ClassName::methodName'

You can also use 'self::methodName'.  This works in PHP 5.2.12 for me.
To Top