PHP小码农

Appearance

function_exists / is_callable / method_exists / class_exists ​

概述 ​

PHP 提供了多个用于检查函数、方法和类是否存在的函数。这些函数在动态调用、插件系统和条件加载中至关重要，可以避免因调用不存在的函数/方法而产生的 Fatal Error。掌握这些检查函数是编写健壮 PHP 代码的基本功。

PHP 版本说明

  • function_exists() 和 class_exists() 自 PHP 4 起可用
  • method_exists() 自 PHP 5 起可用
  • is_callable() 自 PHP 4 起可用
  • class_exists() 支持 autoload 参数
  • enum_exists() 自 PHP 8.1 引入

基础概念 ​

检查函数对比 ​

函数检查目标返回值使用场景
function_exists全局函数bool检查函数是否定义
is_callable任何可调用结构bool检查是否可调用
method_exists对象方法bool检查方法是否存在
class_exists类/接口bool检查类是否已加载
enum_exists枚举bool检查枚举是否已加载（PHP 8.1+）
property_exists对象属性bool检查属性是否存在
interface_exists接口bool检查接口是否已加载
trait_existsTraitbool检查 Trait 是否已加载

语法与代码 ​

function_exists() ​

检查函数是否已定义。只检查全局命名空间的函数。

php
<?php

declare(strict_types=1);

// 检查内置函数
var_dump(function_exists('strlen'));         // true
var_dump(function_exists('strtoupper'));     // true
var_dump(function_exists('nonexistent_func')); // false

// 检查用户自定义函数
function myCustomFunction(): string
{
    return 'Hello!';
}

var_dump(function_exists('myCustomFunction')); // true

// 在调用前检查
$funcName = 'array_map';
if (function_exists($funcName)) {
    echo $funcName('strtoupper', ['a', 'b']) . "\n";
}

// 检查命名空间中的函数需要完整名称
namespace App\Utils;
function helper(): string { return 'helper'; }

// 全局命名空间检查
var_dump(function_exists('App\\Utils\\helper')); // true

is_callable() ​

检查值是否可以被调用。比 function_exists 更通用，支持闭包、数组回调、对象方法等。

php
<?php

declare(strict_types=1);

// 检查函数名
var_dump(is_callable('strlen'));              // true
var_dump(is_callable('nonexistent'));         // false

// 检查闭包
var_dump(is_callable(fn() => true));          // true
var_dump(is_callable(function() {}));         // true

// 检查对象方法
class Example
{
    public function publicMethod(): void {}
    protected function protectedMethod(): void {}
    private function privateMethod(): void {}
    public static function staticMethod(): void {}
}

$ex = new Example();
var_dump(is_callable([$ex, 'publicMethod']));    // true
var_dump(is_callable([$ex, 'protectedMethod'])); // false（即使方法存在）
var_dump(is_callable([$ex, 'staticMethod']));    // true
var_dump(is_callable([$ex, 'nonexistent']));     // false

// 检查静态方法（字符串语法）
var_dump(is_callable('Example::staticMethod')); // true
var_dump(is_callable(['Example', 'staticMethod'])); // true

// is_callable 的第二个参数：仅检查语法（不检查方法是否存在）
var_dump(is_callable([$ex, 'nonexistent'], true));  // true（语法合法）
var_dump(is_callable([$ex, 'nonexistent'], false)); // false（方法不存在）

// is_callable 的第三个参数：获取可调用名称
$callableName = null;
is_callable([$ex, 'publicMethod'], false, $callableName);
echo $callableName . "\n"; // Example::publicMethod

// 检查数组值
var_dump(is_callable(['function_name'])); // false（数组本身不是可调用的）
var_dump(is_callable(['strlen', 'hello'])); // false（字符串数组不是回调）
var_dump(is_callable([new Example(), 'publicMethod'])); // true

method_exists() ​

检查对象或类的方法是否存在（包括受保护和私有方法）。

php
<?php

declare(strict_types=1);

class UserService
{
    public function createUser(string $name): array
    {
        return ['name' => $name];
    }

    protected function validateUser(array $data): bool
    {
        return !empty($data['name']);
    }

    private function hashPassword(string $password): string
    {
        return password_hash($password, PASSWORD_DEFAULT);
    }

    public static function find(int $id): ?self
    {
        return $id === 1 ? new self() : null;
    }
}

$service = new UserService();

// 检查实例方法
var_dump(method_exists($service, 'createUser'));     // true
var_dump(method_exists($service, 'validateUser'));   // true（包括受保护方法）
var_dump(method_exists($service, 'hashPassword'));     // true（包括私有方法）
var_dump(method_exists($service, 'deleteUser'));     // false

// 检查静态方法
var_dump(method_exists(UserService::class, 'find'));  // true
var_dump(method_exists('UserService', 'find'));      // true

// method_exists 检查的是方法是否存在，不管可见性
// 但不能调用不可见的方法
// $service->validateUser([]); // Error: Call to protected method

method_exists 包含所有可见性

method_exists() 返回 true 无论方法是 public、protected 还是 private。它只检查方法是否存在，不检查调用权限。实际调用时仍受可见性限制。

class_exists() ​

检查类或接口是否已定义。

php
<?php

declare(strict_types=1);

// 检查内置类
var_dump(class_exists('stdClass'));       // true
var_dump(class_exists('DateTime'));       // true
var_dump(class_exists('Nonexistent'));    // false

// 检查自定义类
class MyService {}
var_dump(class_exists('MyService'));     // true

// 检查接口
interface MyInterface {}
var_dump(class_exists('MyInterface'));   // true（class_exists 也检查接口）

// autoload 参数：是否触发自动加载
var_dump(class_exists('SomeClass', false)); // false（不触发 autoload）
var_dump(class_exists('SomeClass', true));  // 可能触发 autoload

// interface_exists 和 trait_exists（更精确）
var_dump(interface_exists('Traversable')); // true
var_dump(trait_exists('Countable'));       // false（Countable 是接口，不是 trait）

enum_exists (PHP 8.1+) ​

php
<?php

declare(strict_types=1);

enum Status: string
{
    case Active = 'active';
    case Inactive = 'inactive';
}

var_dump(enum_exists('Status')); // true
var_dump(enum_exists('NonExistentEnum')); // false

详细说明 ​

function_exists vs is_callable 的区别 ​

php
<?php

declare(strict_types=1);

// function_exists 只检查函数是否存在
var_dump(function_exists('strlen'));  // true
var_dump(function_exists(fn() => true)); // false（闭包没有函数名）

// is_callable 检查是否可以被调用
var_dump(is_callable('strlen'));   // true
var_dump(is_callable(fn() => true)); // true（闭包是可调用的）

// 对于不存在的方法
class Foo {}
var_dump(method_exists(new Foo(), 'bar')); // false
var_dump(is_callable([new Foo(), 'bar'])); // false

// 对于受保护/私有方法
class Bar {
    private function secret(): void {}
}

var_dump(method_exists(new Bar(), 'secret'));      // true（方法存在）
var_dump(is_callable([new Bar(), 'secret']));      // false（不可调用）
var_dump(is_callable([new Bar(), 'secret'], true)); // true（语法合法）

动态调用前的安全检查 ​

php
<?php

declare(strict_types=1);

// 安全的全局函数调用
function safeCallFunction(string $funcName, mixed ...$args): mixed
{
    if (!function_exists($funcName)) {
        throw new BadFunctionCallException("Function '{$funcName}' does not exist");
    }

    return $funcName(...$args);
}

// 安全的方法调用
function safeCallMethod(object $obj, string $methodName, mixed ...$args): mixed
{
    if (!method_exists($obj, $methodName)) {
        throw new BadMethodCallException("Method '{$methodName}' does not exist on " . get_class($obj));
    }

    if (!is_callable([$obj, $methodName])) {
        throw new BadMethodCallException("Method '{$methodName}' is not callable (visibility issue)");
    }

    return $obj->{$methodName}(...$args);
}

// 安全的类实例化
function safeNewInstance(string $className, mixed ...$args): object
{
    if (!class_exists($className)) {
        throw new ClassNotFoundException("Class '{$className}' does not exist");
    }

    return new $className(...$args);
}

// 使用示例
echo safeCallFunction('strtoupper', 'hello') . "\n"; // HELLO

try {
    safeCallFunction('nonexistent_function', 'test');
} catch (BadFunctionCallException $e) {
    echo $e->getMessage() . "\n";
}

实战示例 ​

插件加载器 ​

php
<?php

declare(strict_types=1);

class PluginLoader
{
    /** @var array<string, object> */
    private array $instances = [];

    /** @var array<string, string> */
    private array $classMap = [];

    public function register(string $name, string $className): void
    {
        $this->classMap[$name] = $className;
    }

    public function get(string $name): object
    {
        if (isset($this->instances[$name])) {
            return $this->instances[$name];
        }

        $className = $this->classMap[$name] ?? null;

        if ($className === null || !class_exists($className)) {
            throw new RuntimeException("Plugin '{$name}' not found or class '{$className}' not loaded");
        }

        if (!method_exists($className, '__construct')) {
            $this->instances[$name] = new $className();
        } else {
            $this->instances[$name] = new $className();
        }

        return $this->instances[$name];
    }

    public function has(string $name): bool
    {
        $className = $this->classMap[$name] ?? null;

        return $className !== null && class_exists($className);
    }
}

// 注册插件
$loader = new PluginLoader();
$loader->register('cache', FileCache::class);
$loader->register('logger', DatabaseLogger::class);

if ($loader->has('cache')) {
    $cache = $loader->get('cache');
    echo "Cache plugin loaded: " . get_class($cache) . "\n";
}

命令路由系统 ​

php
<?php

declare(strict_types=1);

class CommandRouter
{
    private string $controllerNamespace;
    private string $defaultController = 'HomeController';
    private string $defaultAction = 'index';

    public function __construct(string $namespace)
    {
        $this->controllerNamespace = $namespace;
    }

    public function dispatch(string $controller, string $action, array $params = []): mixed
    {
        $className = $this->controllerNamespace . '\\' . ucfirst($controller) . 'Controller';

        if (!class_exists($className)) {
            $className = $this->controllerNamespace . '\\' . $this->defaultController;
            $action = $this->defaultAction;
        }

        $controllerInstance = new $className();

        $methodName = $action . 'Action';

        if (!method_exists($controllerInstance, $methodName)) {
            throw new RuntimeException("Action '{$action}' not found in " . get_class($controllerInstance));
        }

        if (!is_callable([$controllerInstance, $methodName])) {
            throw new RuntimeException("Action '{$action}' is not accessible");
        }

        return $controllerInstance->{$methodName}(...$params);
    }
}

// 模拟控制器
namespace App\Controllers;

class HomeController
{
    public function indexAction(): string
    {
        return 'Home page';
    }

    public function aboutAction(): string
    {
        return 'About page';
    }
}

// 使用
$router = new CommandRouter('App\\Controllers');
echo $router->dispatch('home', 'index') . "\n";  // Home page
echo $router->dispatch('home', 'about') . "\n";   // About page

注意事项 ​

常见陷阱 ​

  1. function_exists 不检查命名空间
php
<?php

declare(strict_types=1);

namespace App;

function myFunction(): string { return 'app'; }

// function_exists 使用全局命名空间
var_dump(function_exists('myFunction'));      // false
var_dump(function_exists('App\\myFunction')); // true
  1. is_callable 与 method_exists 的差异
php
<?php

declare(strict_types=1);

class Foo
{
    private function privateMethod(): void {}
}

$obj = new Foo();

var_dump(method_exists($obj, 'privateMethod'));   // true
var_dump(is_callable([$obj, 'privateMethod']));   // false
  1. class_exists 的自动加载
php
<?php

declare(strict_types=1);

// class_exists(true) 会触发 spl_autoload_register 注册的自动加载器
// 如果不需要自动加载，传入 false
var_dump(class_exists('SomeUnregisteredClass', false)); // false（快速）

最佳实践 ​

1. 调用前总是检查 ​

php
<?php

declare(strict_types=1);

// 推荐：调用前检查
if (function_exists('mb_strlen')) {
    $length = mb_strlen($text, 'UTF-8');
} else {
    $length = strlen($text);
}

// 推荐：方法调用前检查
if (method_exists($obj, 'process') && is_callable([$obj, 'process'])) {
    $obj->process();
}

2. 使用条件函数定义 ​

php
<?php

declare(strict_types=1);

// 安全的函数定义方式
if (!function_exists('array_column')) {
    function array_column(array $array, mixed $columnKey): array
    {
        return array_map(fn(array $row) => $row[$columnKey] ?? null, $array);
    }
}

3. 选择合适的检查函数 ​

php
<?php

declare(strict_types=1);

// 检查全局函数：function_exists
// 检查闭包/回调：is_callable
// 检查方法是否存在：method_exists
// 检查方法是否可调用：is_callable
// 检查类是否加载：class_exists
// 检查接口：interface_exists
// 检查枚举：enum_exists

参考链接 ​