Pseudo-tipos e variáveis utilizados nesta documentação

mixed

mixed indica que um parâmetro pode aceitar vários (mas não necessariamente todos) os tipos

gettype(), por exemplo, aceita todos os tipos do PHP, enquanto str_replace() somente aceita strings e arrays.

number

number indica que um parâmetro pode ser tanto um integer ou float.

callback

Algumas funções como call_user_func() ou usort() aceitam callback de funções definidas por usuário como parâmetro. Funções de callback não podem ser somente simples funções, mas também métodos de objetos incluindo métodos estáticos de classes.

Uma função PHP é simplesmente passado pelo seu nome como uma string. Você pode passar qualquer função nativa ou definida por usuário. Note que construtores da linguagem como array(), echo, empty(), eval(), exit(), isset(), list(), print ou unset() não podem ser chamados usando um callback.

A method of an instantiated object is passed as an array containing an object as the element with index 0 and a method name as the element with index 1.

Static class methods can also be passed without instantiating an object of that class by passing the class name instead of an object as the element with index 0.

Apart from common user-defined function, create_function() can be used to create an anonymous callback function.

Exemplo #1 Exemplo de funções callback

<?php

// Exemplo simples de callback
function my_callback_function() {
    echo 
'Olá Mundo!';
}
call_user_func('my_callback_function');

// Exemplo de método callback
class MyClass {
    static function 
myCallbackMethod() {
        echo 
'Olá Mundo!';
    }
}

// Type 1: Simple callback
call_user_func('my_callback_function'); 

// Type 2: Static class method call
call_user_func(array('MyClass''myCallbackMethod'));

// Type 3: Chamada de método de objeto
$obj = new MyClass();
call_user_func(array(&$obj'myCallbackMethod'));

// Type 4: Static class method call (As of PHP 5.2.3)
call_user_func('MyClass::myCallbackMethod');

// Type 5: Relative static class method call (As of 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

?>

Nota: No PHP 4, vocÊ irá ter que usar a referência para criar um callback que aponta para o objeto atual, e não uma cópia dele. Para mais detalhes, veja Referências explicadas.

void

void no tipo de retorno indica que não há valor a ser retornado. void na lista de parâmetros indica que a função não aceita parâmetros.

...

$... no protótipo de uma função significa e assim por diante. O nome desta variável é usado quando a função suporta infinito número de argumentos.

add a note add a note

User Contributed Notes 8 notes

up
14
phpguy at lifetoward dot com
4 years ago
I noticed two important thing about putting callbacks into an arg list when calling a function:

1. The function to which the callback refers must be defined earlier in the source stream. So for example:

function main() {...; usort($array, 'sortfunction'); ... }
function sortfunction($a, $b){ return 0; }

Will NOT work, but this will:

function sortfunction($a, $b){ return 0; }
function main() {...; usort($array, 'sortfunction'); ... }

2. It's not really just a string. For example, this doesn't work:

usort($array, ($reverse?'reversesorter':'forwardsorter'));

I found these two discoveries quite counterintuitive.
up
9
michael dot martinek at gmail dot com
4 years ago
The documentation is a little confusing, and with the recent OO changes it adds a little more to the confusion.

I was curious whether you could pass an object through the user func, modify it in that callback and have the actual object updated or whether some cloning was going on behind the scenes.

<?php
   
class Test
   
{
        var
$sValue = 'abc';

        function
testing($objTest)
        {
           
$objTest->sValue = '123';
        }
    }

   
$obj = new Test();

   
call_user_func(array($obj, 'testing'), $obj);

   
var_dump($obj);

?>

This works as expected: The object is not cloned, and $sValue is properly set to '123'. With the OO changes in PHP 5, you don't need to do "function testing(&$objTest)" as it is already passed by reference.
up
1
Edward
7 years ago
To recap mr dot lilov at gmail dot com's comment: If you want to pass a function as an argument to another function, for example "array_map", do this:

regular functions:
<?
array_map
(intval, $array)
?>

static functions in a class:
<?
array_map
(array('MyClass', 'MyFunction'), $array)
?>

functions from an object:
<?
array_map
(array($this, 'MyFunction'), $array)
?>

I hope this clarifies things a little bit
up
-1
sahid dot ferdjaoui at gmail dot com
5 years ago
An example with PHP 5.3 and lambda functions

<?php

  array_map
(function ($value) {
    return new
MyFormElement ($value);
  },
$_POST);

?>
up
-1
levi at alliancesoftware dot com dot au
7 years ago
Parent methods for callbacks should be called 'parent::method', so if you wish to call a non-static parent method via a callback, you should use a callback of
<?
 
// always works
 
$callback = array($this, 'parent::method')

 
// works but gives an error in PHP5 with E_STRICT if the parent method is not static
 
$callback array('parent', 'method');
?>
up
-3
mike@EastGhostCom
1 year ago
If you pass a string as the callback function (i.e., 2nd parm to preg_replace_callback()), then PHP will interpret it as a function's name in the current scope -- and Main::dada_cb is not a valid function name in any scope.

If you want to specify a static method of a class as the callback (i.e., "Main::dada_cb"), then you must pass as 2nd parm to preg_replace_callback:

array( 'Main', 'dada_cb')

And, if you want to use as a callback some method of an instantiated object (i.e., $object->dada_cb), then you must pass as the 2nd parm to preg_replace_callback:

array( $object, 'dada_cb' )
up
-5
Hayley Watson
6 years ago
The mixed pseudotype is explained as meaning "multiple but not necessarily all" types, and the example of str_replace(mixed, mixed, mixed) is given where "mixed" means "string or array".
Keep in mind that this refers to the types of the function's arguments _after_ any type juggling.
up
-9
liam at helios-sites dot com
3 years ago
Note that (e.g.) usort calls on static methods of classes in a namespace need to be laid out as follows:

usort($arr, array('\Namespace\ClassName', 'functionName'));
To Top