浅析PHP call_user_func函数

1.官方描述

1.1在PHP官方手册中是这么描述call_user_func函数的:

1.1.1说明

  call_user_func_array(callable $callback, array $args): mixed

把第一个参数作为回调函数(callback)调用,把参数数组作(args)为回调函数的的参数传入。

1.1.2参数

  • callback:被调用的回调函数。
  • args: 0个或以上的参数,被传入回调函数。

1.1.3返回值

返回回调函数的结果。如果出错的话就返回 false 。

1.2什么是回调函数

将一个函数作为参数传递给另一个函数,并在特定时机由后者“回调”(调用)这个函数,不是立即执行,而是在未来某个条件满足或事件发生时才被调用

JavaScript

// 异步操作:3秒后执行回调
function fetchData(callback) {
    setTimeout(() => {
        const data = "用户数据";
        callback(data); // 回调
    }, 3000);
}

// 传入回调函数
fetchData((result) => {
    console.log("收到数据:", result);
});

python

def greet(name):
    print(f"Hello, {name}!")

def process_user(callback):
    user = "Alice"
    callback(user)  # 回调函数在此被调用

# 将 greet 函数作为参数传入
process_user(greet)  # 输出: Hello, Alice!

php

function sendEmail() {
    echo "邮件已发送!";
}

$callback = 'sendEmail';
call_user_func($callback); // 回调执行

这里其实已经可以看到call_user_func的特殊点了

2.参数描述

我们跟进这个函数,看看在存根中对参数的描述:

什么意思呢,翻译翻译:

@param callable $callback

要被调用的回调函数。

  • 你可以通过传入 array($classname, $methodname) 的形式,静态调用类的方法。
  • 你也可以通过传入 array($objectinstance, $methodname) 的形式,调用某个对象实例的方法。

这里其实就可以看出来了,这个函数的传入可以是array类型,这是在别的编程语言中没有出现的,底层实现我们待会会说

当然,这并不是call_user_func支持的所有回调类型,下面这些也是合法的:

2.1合法的 callable 形式

类型

示例

普通函数

'strlen'

匿名函数

function($x) { return $x*2; }

静态方法(数组)

['MyClass', 'myMethod']

静态方法(字符串)

'MyClass::myMethod'

实例方法

[$obj, 'methodName']

可调用对象(实现 __invoke)

$obj(如果 $obj 有 __invoke 方法)

3.call_user_func支持的所有callabe形式及其底层实现

网上对于这个函数的回调类型汇总很碎,这里我列出全部的调用方法,示例代码及其底层实现(php官方源码):

在 PHP 的底层(即 Zend Engine,C 语言实现),所有 callable 类型的识别、验证和调用都通过一组核心函数完成,主要是:

  • zend_is_callable_ex() / zend_is_callable()
  • zend_fcall_info_init()
  • zend_call_function()

这些函数会根据传入的 zval(PHP 变量的底层表示)类型,判断其是否为合法的 callable,并将其标准化为一个统一的结构体 zend_fcall_info,然后执行调用

无论哪种 callable,最终都会被转换成 zend_fcall_info fci 结构:

3.1 调用普通函数(字符串形式)

function sayHello($name) {
    echo "Hello, $name!\n";
}

call_user_func('sayHello', 'Alice');
// 输出: Hello, Alice!

底层实现

类型:IS_STRING

调用路径:

if (Z_TYPE_P(name) == IS_STRING) {
    zend_function *func = zend_hash_find_ptr(EG(function_table), Z_STR_P(name));
    if (func) {
        fci->function_name = *name;
        fci->object = NULL;
        fci->called_scope = NULL;
        // 标记为函数调用
    }
}

查找位置:全局函数表 EG(function_table)

函数指针:func->internal_function.handler(内部函数)或 func->op_array.opcodes(用户函数)

2. 调用内置函数

$result = call_user_func('strlen', 'PHP is great!');
echo $result; // 输出: 13

底层实现:

// 1. callable 解析(Zend/zend_API.c)
if (Z_TYPE_P(callback) == IS_STRING) {
    zend_function *func = zend_hash_find_ptr(EG(function_table), Z_STR_P(callback));
    if (func && func->type == ZEND_INTERNAL_FUNCTION) {
        fci->function_handler = func;
        fci->object = NULL;
    }
}

// 2. 内置函数注册(ext/standard/string.c)
ZEND_FUNCTION(strlen) {
    zend_string *str;
    ZEND_PARSE_PARAMETERS_START(1, 1)
        Z_PARAM_STR(str)
    ZEND_PARSE_PARAMETERS_END();
    RETURN_LONG(ZSTR_LEN(str));
}

const zend_function_entry basic_functions[] = {
    ZEND_FE(strlen, arginfo_strlen),
    {NULL, NULL, NULL}
};

// 3. 函数调用分发(Zend/zend_execute_API.c)
if (fci->function_handler->type == ZEND_INTERNAL_FUNCTION) {
    fci->function_handler->internal_function.handler(
        INTERNAL_FUNCTION_PARAM_PASSTHRU
    );
}

3. 调用匿名函数(Closure)

$double = function($x) {
    return $x * 2;
};

echo call_user_func($double, 7); // 输出: 14

底层实现

类型:IS_OBJECT,且 instanceof Closure

Closure 是一个特殊内部类(zend_ce_closure)

处理逻辑:

if (Z_TYPE_P(cb) == IS_OBJECT && instanceof_function(Z_OBJCE_P(cb), zend_ce_closure)) {
    // Closure 对象内部存储了 op_array(字节码)
    zend_closure *closure = (zend_closure*)Z_OBJ_P(cb);
    fci->function_handler = &closure->func;
    fci->object = Z_OBJ_P(cb); // 用于绑定 $this 和 use 变量
    fci->called_scope = closure->called_scope;
}

Closure 的 use 变量存储在 closure->func.op_array.vars 中

4. 调用静态方法(数组形式)

class Math {
    public static function add($a, $b) {
        return $a + $b;
    }
}

echo call_user_func(['Math', 'add'], 5, 3); // 输出: 8

底层实现

类型:IS_ARRAY,长度为 2

第一个元素是 IS_STRING(类名)

第二个元素是 IS_STRING(方法名)

处理逻辑:

if (zend_hash_num_elements(Z_ARRVAL_P(callback)) == 2) {
    zval *class_zv = /* first element */;
    zval *method_zv = /* second element */;

    if (Z_TYPE_P(class_zv) == IS_STRING && Z_TYPE_P(method_zv) == IS_STRING) {
        zend_class_entry *ce = zend_lookup_class(Z_STR_P(class_zv));
        zend_function *func = zend_hash_find_ptr(&ce->function_table, Z_STR_P(method_zv));

        // 必须是 public 或 protected(静态上下文允许 protected)
        if (func && (func->common.fn_flags & ZEND_ACC_PUBLIC ||
                    (func->common.fn_flags & ZEND_ACC_PROTECTED && ...))) {

            fci->object = NULL;
            fci->called_scope = ce;
            fci->function_handler = func;
        }
    }
}

5. 调用静态方法(字符串形式)

这个方法对php版本有限制,需 PHP 5.2.3+,且类名官方建议用全限定名

class Greeter {
    public static function hi($name) {
        return "Hi, $name!";
    }
}

echo call_user_func('Greeter::hi', 'Bob');

输出: Hi, Bob!

底层实现

类型:IS_STRING,包含 ::

解析逻辑(在 zend_is_callable_ex 中):

if (memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name))) {
    // 分割 "Class::method"
    char *sep = strchr(Z_STRVAL_P(name), ':');
    size_t class_len = sep - Z_STRVAL_P(name);
    zend_string *class_name = zend_string_init(...);
    zend_string *method_name = zend_string_init(sep + 2, ...);

    // 查找类
    zend_class_entry *ce = zend_lookup_class(class_name);
    // 查找静态方法
    zend_function *func = zend_hash_find_ptr(&ce->function_table, method_name);

    fci->object = NULL;
    fci->called_scope = ce;
    fci->function_handler = func;
}

6. 调用对象的实例方法(数组形式)

class User {
    public function greet($name) {
        echo "Greetings, $name!\n";
    }
}

$user = new User();
call_user_func([$user, 'greet'], 'Charlie');

输出: Greetings, Charlie!

底层实现

类型:IS_ARRAY,长度为 2

第一个元素是 IS_OBJECT

第二个元素是 IS_STRING

处理逻辑:

if (Z_TYPE_P(obj_zv) == IS_OBJECT && Z_TYPE_P(method_zv) == IS_STRING) {
    zend_object *obj = Z_OBJ_P(obj_zv);
    zend_class_entry *ce = obj->ce;
    zend_function *func = zend_hash_find_ptr(&ce->function_table, Z_STR_P(method_zv));

    // 方法必须是 public
    if (func && (func->common.fn_flags & ZEND_ACC_PUBLIC)) {
        fci->object = obj;
        fci->called_scope = ce; // 运行时作用域
        fci->function_handler = func;
    }
   }

此时 fci->object != NULL,调用时会作为 $this 传入

7. 调用实现了 __invoke 的对象(可调用对象)

class CallableLogger {
    public function __invoke($message) {
        echo "[LOG] $message\n";
    }
}

$logger = new CallableLogger();
call_user_func($logger, 'User logged in');

输出: [LOG] User logged in

底层实现

类型:IS_OBJECT

检查是否存在 __invoke 方法:

if (Z_TYPE_P(cb) == IS_OBJECT) {
    zend_class_entry *ce = Z_OBJCE_P(cb);
    zend_function *invoke_func = zend_hash_str_find_ptr(&ce->function_table, "__invoke", sizeof("__invoke")-1);
    if (invoke_func) {
        fci->function_handler = invoke_func;
        fci->object = Z_OBJ_P(cb);
        fci->called_scope = ce;
    }
   }

8. 调用带命名空间的类方法

<?php

namespace Foobar;

class Foo {
    static public function test() {
        print "Hello world!\n";
    }
}

call_user_func(__NAMESPACE__ .'\Foo::test');
call_user_func(array(__NAMESPACE__ .'\Foo', 'test'));

?>

输出:
Hello world!
Hello world!

底层实现

  • 字符串函数名会先在当前命名空间查找,再回退到全局
  • 由 zend_fetch_function 实现命名空间解析
typedef struct _zend_fcall_info {
    size_t size;                   // 结构体大小
    zend_object *object;           // $this(实例方法/Closure)
    zend_function *function_handler; // 要调用的函数
    zend_class_entry *called_scope; // 静态调用时的类作用域
    uint32_t param_count;          // 参数数量
    zval *params;                  // 参数数组
    zval *retval;                  // 返回值
    // ...
} zend_fcall_info;

然后调用:

zend_call_function(&fci, &fcic); // fcic = fcall info cache

该函数会根据 function_handler->type(ZEND_INTERNAL_FUNCTION / ZEND_USER_FUNCTION)分发到:

  • 内部函数 → 直接调用 C 函数指针
  • 用户函数 → 执行 Zend VM 字节码

9. 调用继承的 public 方法

class Base {
    public function info($msg) {
        echo "Base: $msg\n";
    }
}

class Child extends Base {}

$child = new Child();
call_user_func([$child, 'info'], 'from child');

输出: Base: from child

底层实现

1. 解析 callable

call_user_func([$obj, 'method']) → 调用 zend_fcall_info_init()
检测到数组形式,提取对象和方法名:

// Zend/zend_API.c
if (zend_hash_num_elements(Z_ARRVAL_P(callback)) == 2) {
    zval *obj_zv = /* first */;
    zval *method_zv = /* second */;
    if (Z_TYPE_P(obj_zv) == IS_OBJECT && Z_TYPE_P(method_zv) == IS_STRING) {
        zend_object *obj = Z_OBJ_P(obj_zv);
        zend_class_entry *ce = obj->ce;          // ← 子类 CE
        zend_string *method_name = Z_STR_P(method_zv);
2. 查找方法(沿继承链)

调用 zend_hash_find_ptr(&ce->function_table, method_name)
若子类未定义,
自动回溯父类(实际在类初始化时已合并方法表):

// 方法查找本质由继承机制预处理(Zend/zend_inheritance.c)
void zend_do_inheritance(zend_class_entry *child, zend_class_entry *parent) {
    // 将 parent 的 public/protected 方法导入 child 的 function_table(除非被重写)
}

因此运行时直接 zend_hash_find_ptr(&child_ce->function_table, name) 即可命中父类方法

3. 权限检查

在 zend_is_callable_ex() 中验证:

// Zend/zend_API.c
if (fptr->op_array.fn_flags & ZEND_ACC_PUBLIC) {
    /* OK */
} else if (fptr->op_array.fn_flags & ZEND_ACC_PROTECTED) {
    /* 检查是否在继承链内 */
} else {
    /* private: fail */
}
4. 执行调用

构建 zend_fcall_info 并调用:

fci.object = obj;               // $this = 子类实例
fci.called_scope = obj->ce;     // 运行时类 = 子类
fci.function_handler = fptr;    // 函数体 = 父类定义

zend_call_function(&fci, &fcic); // 执行


与call_user_func_array()的辨析:

这两个函数很像,主要区别是参数传入的方式不同:

args: 要被传入回调函数的数组

  • 如果 args 的 key 都是数字,则会忽略 key,并按顺序将每个元素作为位置参数传递给 callback
  • 如果 args 的任一 key 是字符串,则这些元素将作为命名参数传递给 callback,名称由 key 指定
  • 在 args 中,如果数字 key 在 字符串 key 之后出现,或者字符串 key 与 callback 的任何参数名称不匹配,将会导致 fatal error

1. call_user_func() —— 参数逐个输入

function greet($name, $title) {
    echo "Hello, $title $name!\n";
}

// 逐个传参
call_user_func('greet', 'Alice', 'Dr.');
// 输出: Hello, Dr. Alice!

适合参数数量固定且已知的场景

2. call_user_func_array() —— 参数通过数组传入

function greet($name, $title) {
    echo "Hello, $title $name!\n";
}

// 所有参数放在一个数组中
$args = ['Alice', 'Dr.'];
call_user_func_array('greet', $args);
// 输出: Hello, Dr. Alice!

适合参数数量不固定、或参数来自数组/动态生成的场景

值得注意的是:

在函数中注册有多个回调内容时(如使用 call_user_func() 与 call_user_func_array()),如在前一个回调中有未捕获的异常,其后的将不再被调用