function foobar($arg, $arg2) {
echo __FUNCTION__, " got $arg and $arg2\n";
}
foobar('one','two'); // OUTPUTS : foobar got one and two
call_user_func_array("foobar", array("one", "two")); // // OUTPUTS : foobar got one and two
我看到常规方法和call_user_func_array方法的输出结果相同，那么为什么应该更喜欢它呢？
在什么情况下普通调用方法会失败但call_user_func_array不会失败？
我可以得到任何这样的例子吗？
谢谢您。
你有一个数组作为函数的参数，但它的长度是不确定的。
$args = someFuncWhichReturnsTheArgs();
foobar( /* put these $args here, you do not know how many there are */ );
另一种选择是：
switch (count($args)) {
case 1:
foobar($args[0]);
break;
case 2:
foobar($args[0], $args[1]);
break;
...
}
哪个不是解决方案。
使用情景可能很少，但当你遇到它时，你需要它。
foobar(...$args);。 - DisgruntledGoatfoobar 函数的定义中参数列表是什么？ - Istiaque Ahmedcall_user_func_array？ - Istiaque Ahmedcall_user_func_array 的作用，我回答的是在什么情况下使用它以及替代方案会是什么样子。 - decezecall_user_func_array需要了解它所扮演的角色。试图理解整个不清晰的情况。 - Istiaque Ahmedcall_user_func_array()；另一个场景是在不提前知道要调用的函数时，例如array($obj, 'method')，这也是可以使用call_user_func()的情况。与之相反，使用常规的调用方法可能会失败。$fn = array($obj, 'method');
$args = [1, 2, 3];
call_user_func_array($fn, $args);
call_user_func_*函数无法调用私有或受保护的方法。myfn([1, 2, 3]);
然而，这样做会消除在函数声明中对每个参数进行类型提示的可能性，通常被认为是代码异味。
$obj 变量的定义以及它的 method。 - Istiaque Ahmed$obj有一个名为method的函数，它需要三个参数... - Ja͢ckcall_user_func_array在这里扮演什么角色？ - Istiaque Ahmed您应该优先像平常一样调用函数。使用 call_user_func_array 和动态参数。例如：
function func(arg1, arg2, arg3) {
return "$arg1, $arg2, $arg3";
}
func(1, 2, 3); //=> "1, 2, 3"
$args = range(5,7); // dynamic arguments
call_user_func_array('func', $args); //=> "5, 6, 7"
call_user_func_array执行“取消柯里化”操作，这是“柯里化”的反义词。
以下内容适用于PHP的所有“可调用函数”（命名函数、闭包、方法、__invoke等），因此为简单起见，让我们忽略差异，只关注闭包。
如果我们想要接受多个参数，PHP让我们使用3种不同的API。通常的方式是：
$usual = function($a, $b, $c, $d) {
return $a + $b + $c + $d;
};
$result = $usual(10, 20, 30, 40); // $result == 100
另一种方式被称为 柯里化 形式：
$curried = function($a) {
return function($b) use ($a) {
return function($c) use ($a, $b) {
return function($d) use ($a, $b, $c) {
return $a + $b + $c + $d;
};
};
};
};
$result = call_user_func(
call_user_func(
call_user_func(
$curried(10),
20),
30),
40); // $result == 100
$curried = curry(function($a, $b, $c, $d) {
return $a + $b + $c + $d;
});
$result1 = $curried(10, 20, 30, 40); // $result1 = 100
$result2 = call_user_func($curried(10, 20), 30, 40); // $result2 = 100
$uncurried = function($args) {
return $args[0] + $args[1] + $args[2] + $args[3];
};
$result = $uncurried([10, 20, 30, 40]); // $result == 100
就像柯里化函数一样，非柯里化函数也可以通过一个参数进行调用，只不过这次参数是一个数组。我们仍然面临着与柯里化函数相同的兼容性问题：如果我们选择使用非柯里化函数，我们不能指望其他人也做出同样的选择。因此，我们还需要一个将非柯里化函数转换为柯里化函数的函数。这就是call_user_func_array所做的事情：
$uncurried = function($args) use ($usual) {
return call_user_func_array($usual, $args);
};
$result1 = $usual(10, 20, 30, 40); // $result1 = 100
$result2 = $uncurried([10, 20, 30, 40]); // $result2 = 100
call_user_func_array来消除多余的function($args)包装（这个过程被称为“Eta-Reduction”）。$uncurried = curry('call_user_func_array', $usual);
$result = $uncurried([10, 20, 30, 40]); // $result == 100
不幸的是，call_user_func_array 没有 curry 那么智能；它无法自动在两者之间转换。我们可以编写自己的 uncurry 函数来实现这个功能：
function uncurry($f)
{
return function($args) use ($f) {
return call_user_func_array(
$f,
(count(func_get_args()) > 1)? func_get_args()
: $args);
};
}
$uncurried = uncurry($usual);
$result1 = $uncurried(10, 20, 30, 40); // $result1 == 100
$result2 = $uncurried([10, 20, 30, 40]); // $result2 == 100
func_get_args期望变量数量的东西以及具有默认参数值的函数会出现问题。$defaults = function($a, $b, $c = 30, $d = 40) {
return $a + $b + $c + $d;
};
$def1 = $defaults(10, 20, 30, 40); // $def1 == 100
$def2 = $defaults(10, 20, 30); // $def2 == 100
$def3 = $defaults(10, 20); // $def3 == 100
$curried = function($d, $c, $a, $b) {
return $a + $b + $c + $d;
};
$curriedD = $curried(40);
$curriedDC = $curriedD(30);
$cur1 = $curried(10, 20, 30, 40); // $cur1 == 100
$cur2 = $curriedD(10, 20, 30); // $cur2 == 100
$cur3 = $curriedDC(10, 20); // $cur3 == 100
function foo($var1, $var2, $var3) {
echo $var1 + $var2 + var3;
}
$array = [1,2,3];
foo(...$array); // 6
// same as call_user_func_array('foo',$array);
call_user_func_array()与变量函数的区别在于变量函数不允许您调用静态方法：$params = [1,2,3,4,5];
function test_function() {
echo implode('+',func_get_args()) .'='. array_sum(func_get_args())."\r\n";
}
// Normal function as callback
$callback_function = 'test_function';
call_user_func_array($callback_function,$params); // 1+2+3+4+5=15
$callback_function(...$params); // 1+2+3+4+5=15
class TestClass
{
static function testStaticMethod() {
echo implode('+',func_get_args()) .'='. array_sum(func_get_args())."\r\n";
}
public function testMethod() {
echo implode('+',func_get_args()) .'='. array_sum(func_get_args())."\r\n";
}
}
// Class method as callback
$obj = new TestClass;
$callback_function = [$obj,'testMethod'];
call_user_func_array($callback_function,$params); // 1+2+3+4+5=15
$callback_function(...$params); // 1+2+3+4+5=15
// Static method callback
$callback_function = 'TestClass::testStaticMethod';
call_user_func_array($callback_function,$params); // 1+2+3+4+5=15
$callback_function(...$params); // Fatal error: undefined function
PHP 7添加了通过变量函数调用静态方法的能力，因此从PHP 7开始，this的区别不再存在。总之，call_user_func_array()使您的代码具有更大的兼容性。
<?php
class Demo {
public function function1() {
echo 'in function 1';
}
}
$obj = new Demo();
$function_list = get_class_methods('Demo');
print_r($function_list); //Array ( [0] => function1 )
call_user_func_array(array($obj, $function_list[0]), array());
// Output => in function 1
?>
call_user_func_array主要用于动态情境，当你事先不知道要调用哪个函数和传递哪些参数时使用。它可以帮助你在运行时决定要调用哪个函数和传递哪些参数。 - knittl