【PHP8.x】is_callable()関数の使い方

Copy
1<?php
2
3/**
4 * is_callable と method_exists の違いを示すサンプルコード。
5 */
6
7class MyClass {
8    public function myMethod() {
9        return true;
10    }
11}
12
13$obj = new MyClass();
14
15// 文字列でメソッド名を指定
16$methodName = 'myMethod';
17
18// method_exists は、クラスにメソッドが存在するかどうかをチェックする
19if (method_exists($obj, $methodName)) {
20    echo "method_exists: MyClass に myMethod は存在します。\n";
21} else {
22    echo "method_exists: MyClass に myMethod は存在しません。\n";
23}
24
25// is_callable は、コールバックとして呼び出し可能かどうかをチェックする
26// コールバックは、関数名を表す文字列、メソッド名を表す配列、または Closure オブジェクトのいずれか
27if (is_callable([$obj, $methodName])) {
28    echo "is_callable: \$obj->myMethod は呼び出し可能です。\n";
29} else {
30    echo "is_callable: \$obj->myMethod は呼び出し可能ではありません。\n";
31}
32
33// 文字列のみの場合の挙動の違い
34$nonExistentMethod = 'nonExistentMethod';
35
36if (!method_exists($obj, $nonExistentMethod)) {
37    echo "method_exists: MyClass に nonExistentMethod は存在しません。\n";
38} else {
39    echo "method_exists: MyClass に nonExistentMethod は存在します。\n";
40}
41
42if (!is_callable([$obj, $nonExistentMethod])) {
43    echo "is_callable: \$obj->nonExistentMethod は呼び出し可能ではありません。\n";
44} else {
45    echo "is_callable: \$obj->nonExistentMethod は呼び出し可能です。\n";
46}
47
48// 関数名の場合
49function myFunction() {
50    return true;
51}
52
53if (is_callable('myFunction')) {
54    echo "is_callable: myFunction は呼び出し可能です。\n";
55} else {
56    echo "is_callable: myFunction は呼び出し可能ではありません。\n";
57}

is_callable関数は、PHPの組み込み関数で、指定された変数がコールバックとして呼び出し可能かどうかを判定します。PHP8で利用可能です。引数 $value には、判定したい変数を指定します。オプションの引数 $syntax_only は、構文チェックのみを行うかを指定するbool値で、デフォルトは false です。$callable_name には、呼び出し可能な名前が文字列で返されます。戻り値は、呼び出し可能であれば true、そうでなければ false を返します。

このサンプルコードでは、is_callable と method_exists の違いを示しています。method_exists は、クラス内に指定された名前のメソッドが存在するかどうかをチェックするのに対し、is_callable は、変数が関数として呼び出し可能かどうかをチェックします。例えば、存在しないメソッド名を指定した場合、method_exists は false を返しますが、is_callable は配列 [$obj, 'nonExistentMethod'] の形式で、メソッドとして呼び出し可能かどうかを判定します。関数名の場合は、is_callable('myFunction') のように文字列で指定することで、その関数が定義されているかどうかを確認できます。is_callable は、文字列で関数名が指定された場合にも、グローバル空間にその関数が存在するかどうかを確認できます。この例では、myFunction が定義されているため、is_callable('myFunction') は true を返します。is_callable は、コールバック関数を扱う際に、事前に有効性を確認するために役立ちます。

Copy
1<?php
2
3/**
4 * 静的メソッドを持つシンプルなクラスの例。
5 * システムの共通処理やユーティリティ関数をまとめる際によく使われます。
6 */
7class MyLogger
8{
9    /**
10     * これは静的メソッドです。
11     * インスタンスを作成せずに `MyLogger::log()` のように直接クラス名から呼び出せます。
12     *
13     * @param string $message ログに記録するメッセージ
14     * @return void
15     */
16    public static function log(string $message): void
17    {
18        echo "[" . date('Y-m-d H:i:s') . "] LOG: " . $message . "\n";
19    }
20
21    /**
22     * これはインスタンスメソッドです。
23     * このメソッドを呼び出すには、まず `(new MyLogger())` のようにクラスのインスタンスを作成する必要があります。
24     * is_callable で静的に参照した場合、true が返ることもありますが、実際に静的に呼び出すとエラーになる点に注意が必要です。
25     *
26     * @return string
27     */
28    public function getUniqueId(): string
29    {
30        return "インスタンスID: " . spl_object_hash($this);
31    }
32}
33
34echo "--- PHPの `is_callable` 関数による静的メソッドの呼び出し可能性チェック ---\n\n";
35
36// 1. 静的メソッドを配列形式で指定してチェックします。
37//    `MyLogger::class` は PHP 5.5 以降で推奨される、クラス名を文字列として取得する方法です。
38$staticMethodRef1 = [MyLogger::class, 'log'];
39$callableName1 = null; // is_callable が認識した呼び出し可能な名前を格納する変数
40
41echo "■ チェック対象: ['MyLogger', 'log'] (配列形式の静的メソッド参照)\n";
42if (is_callable($staticMethodRef1, false, $callableName1)) {
43    echo "  → 結果: 呼び出し可能です。\n";
44    echo "  → is_callableが認識した名前: " . $callableName1 . "\n";
45    // 実際に静的メソッドを呼び出す例 (call_user_func関数を使用)
46    echo "  → 実行結果: ";
47    call_user_func($staticMethodRef1, "配列形式でMyLogger::logが呼び出されました。");
48} else {
49    echo "  → 結果: 呼び出し可能ではありません。\n";
50}
51echo "\n";
52
53// 2. 静的メソッドを文字列形式で指定してチェックします。
54//    'ClassName::methodName' の形式です。
55$staticMethodRef2 = 'MyLogger::log';
56$callableName2 = null;
57
58echo "■ チェック対象: 'MyLogger::log' (文字列形式の静的メソッド参照)\n";
59if (is_callable($staticMethodRef2, false, $callableName2)) {
60    echo "  → 結果: 呼び出し可能です。\n";
61    echo "  → is_callableが認識した名前: " . $callableName2 . "\n";
62    // 実際に静的メソッドを呼び出す例
63    echo "  → 実行結果: ";
64    call_user_func($staticMethodRef2, "文字列形式でMyLogger::logが呼び出されました。");
65} else {
66    echo "  → 結果: 呼び出し可能ではありません。\n";
67}
68echo "\n";
69
70// 3. 存在しない静的メソッドを指定してチェックします。
71$nonExistentMethodRef = [MyLogger::class, 'nonExistentMethod'];
72$callableName3 = null;
73
74echo "■ チェック対象: ['MyLogger', 'nonExistentMethod'] (存在しないメソッド)\n";
75if (is_callable($nonExistentMethodRef, false, $callableName3)) {
76    echo "  → 結果: 呼び出し可能です。\n";
77    echo "  → is_callableが認識した名前: " . $callableName3 . "\n";
78} else {
79    echo "  → 結果: 呼び出し可能ではありません。\n";
80}
81echo "\n";
82
83// 4. `syntax_only` 引数を `true` にしてチェックします。
84//    この引数が `true` の場合、is_callable は実際にそのクラスやメソッドが存在するかどうかをチェックせず、
85//    与えられた値が「構文的に呼び出し可能に見えるか」のみを判断します。
86//    そのため、存在しないクラスやメソッドであっても true を返すことがあります。
87$syntaxOnlyRef = 'NonExistentClass::anyMethod';
88$callableName4 = null;
89
90echo "■ チェック対象: 'NonExistentClass::anyMethod' (syntax_only=true)\n";
91if (is_callable($syntaxOnlyRef, true, $callableName4)) {
92    echo "  → 結果: 構文上は呼び出し可能です。\n"; // クラスやメソッドが存在しなくてもtrueになることがある
93    echo "  → is_callableが認識した名前: " . $callableName4 . "\n";
94    echo "    (注意: syntax_only=true のため、実際には存在しない可能性もあります。)\n";
95} else {
96    echo "  → 結果: 構文上呼び出し可能ではありません。\n";
97}
98echo "\n";
99
100// 補足: インスタンスメソッドを静的に参照した場合の is_callable の挙動
101// is_callable は、与えられた形式が「呼び出し可能である」という構文上の可能性を見るため、
102// インスタンスメソッドであっても 'ClassName::methodName' という形式では true を返すことがあります。
103// しかし、実際に静的に呼び出そうとするとエラーになることがほとんどです。
104$instanceMethodStaticRef = 'MyLogger::getUniqueId';
105$callableName5 = null;
106
107echo "■ チェック対象: 'MyLogger::getUniqueId' (インスタンスメソッドを静的に参照)\n";
108if (is_callable($instanceMethodStaticRef, false, $callableName5)) {
109    echo "  → 結果: 呼び出し可能です (is_callableは構文上可能と判断)。\n";
110    echo "  → is_callableが認識した名前: " . $callableName5 . "\n";
111    echo "    (注意: このメソッドはインスタンスメソッドなので、実際に静的に呼び出すとエラーになります。)\n";
112    // 例: call_user_func($instanceMethodStaticRef); // Fatal error: Uncaught Error: Call to private method MyLogger::getUniqueId() from non-static context
113} else {
114    echo "  → 結果: 呼び出し可能ではありません。\n";
115}
116echo "\n";

PHPのis_callable関数は、指定された値が呼び出し可能であるかを真偽値で判断します。これにより、関数やメソッドを実際に実行する前に、その存在や形式が正しいかを確認できます。

この関数は主に3つの引数を取ります。最初の$valueにはチェックしたい対象を渡し、例えばMyLogger::logのような静的メソッドは、['MyLogger', 'log']という配列形式や、'MyLogger::log'という文字列形式で指定可能です。is_callableはこれらの形式を認識し、指定された静的メソッドが呼び出し可能であればtrueを返します。

2つ目の$syntax_only引数をtrueに設定すると、is_callableは実際にそのメソッドやクラスが存在するかどうかは確認せず、構文上「呼び出し可能に見えるか」だけをチェックします。そのため、存在しないクラスやメソッドであってもtrueを返す場合があります。

3つ目の&$callable_name引数には、呼び出し可能と判断された場合にis_callableが認識した完全な名前が文字列として格納されます。

注意点として、MyLogger::getUniqueIdのようにインスタンスメソッドを静的に参照する形式で指定した場合、is_callableは構文上呼び出し可能と判断してtrueを返すことがありますが、実際に静的に呼び出そうとするとエラーになるため注意が必要です。この関数は、動的な処理を安全に実装するために役立ちます。

Copy
1<?php
2
3// MyCallableClass クラスを定義します。
4class MyCallableClass
5{
6    /**
7     * 静的メソッドです。
8     */
9    public static function staticMethod(): string
10    {
11        return "Static method called.";
12    }
13
14    /**
15     * インスタンスメソッドです。
16     */
17    public function instanceMethod(): string
18    {
19        return "Instance method called.";
20    }
21
22    /**
23     * プライベートメソッドです。外部からは直接呼び出せません。
24     */
25    private function privateMethod(): string
26    {
27        return "Private method called.";
28    }
29}
30
31/**
32 * グローバルスコープの関数を定義します。
33 */
34function globalFunction(): string
35{
36    return "Global function called.";
37}
38
39/**
40 * is_callable() 関数を使って、様々な呼び出し可能な要素をチェックし、結果を表示します。
41 *
42 * @param mixed $candidate チェック対象の呼び出し可能な要素。関数名、メソッドの配列、クロージャなど。
43 * @param string $description チェック対象の説明。
44 * @param bool $syntaxOnly true の場合、構文的に呼び出し可能かのみをチェックし、
45 *                         実際に存在するか、アクセス可能かはチェックしません。
46 */
47function demonstrateIsCallableChecks(mixed $candidate, string $description, bool $syntaxOnly = false): void
48{
49    // is_callable() を使用して、指定された要素が呼び出し可能かを確認します。
50    // 第2引数は $syntax_only、第3引数は &$callable_name で、呼び出し可能な名前が格納されます。
51    $callableName = ''; // 呼び出し可能な名前を格納する変数
52    $isCallable = is_callable($candidate, $syntaxOnly, $callableName);
53
54    echo sprintf(
55        "%s '%s' は%s呼び出し可能です。(名前: '%s')\n",
56        $isCallable ? "✅" : "❌", // 呼び出し可能であれば「✅」、そうでなければ「❌」を表示
57        $description,
58        $syntaxOnly ? "構文的に" : "実際に", // syntaxOnlyがtrueなら「構文的に」、falseなら「実際に」
59        $callableName // is_callableがtrueを返した場合に設定される呼び出し可能な名前
60    );
61}
62
63// --- is_callable() の使用例 ---
64
65echo "--- 関数とクロージャのチェック ---\n";
66
67// 1. 通常の関数をチェックします。
68demonstrateIsCallableChecks('globalFunction', 'グローバル関数');
69
70// 2. 無名関数（クロージャ）をチェックします。
71$myClosure = function (): string {
72    return "Closure called.";
73};
74demonstrateIsCallableChecks($myClosure, '無名関数 (クロージャ)');
75
76// 3. 存在しない関数をチェックします。
77//    - $syntaxOnly = true の場合、PHPの文法として関数名と認識できるためtrueを返します。
78demonstrateIsCallableChecks('nonExistentFunction', '存在しない関数', true);
79//    - $syntaxOnly = false の場合、関数が実際に存在しないためfalseを返します。
80demonstrateIsCallableChecks('nonExistentFunction', '存在しない関数');
81
82echo "\n--- クラスメソッドのチェック ---\n";
83
84// 4. 静的メソッドを配列形式でチェックします (PHPにおける推奨される方法)。
85demonstrateIsCallableChecks(['MyCallableClass', 'staticMethod'], '静的メソッド (MyCallableClass::staticMethod, 配列形式)');
86
87// 5. 静的メソッドを文字列形式でチェックします。
88//    - PHP 7.0 以降、この形式は非推奨ではなくなりました。
89demonstrateIsCallableChecks('MyCallableClass::staticMethod', '静的メソッド (MyCallableClass::staticMethod, 文字列形式)');
90
91// 6. インスタンスメソッドをチェックします。
92$instance = new MyCallableClass();
93demonstrateIsCallableChecks([$instance, 'instanceMethod'], 'インスタンスメソッド (MyCallableClass->instanceMethod)');
94
95// 7. 存在しないメソッドをチェックします。
96demonstrateIsCallableChecks([$instance, 'nonExistentMethod'], '存在しないメソッド');
97
98// 8. private メソッドをチェックします。
99//    - is_callable() は外部からのアクセス可能性もチェックするため、private メソッドは呼び出し不可と判断されます。
100demonstrateIsCallableChecks([$instance, 'privateMethod'], 'プライベートメソッド');
101
102// 9. 存在しないクラスのメソッドをチェックします。
103//    - $syntaxOnly = true の場合、構文的にクラスとメソッドの形式として認識できるためtrueを返します。
104demonstrateIsCallableChecks('NonExistentClass::someMethod', '存在しないクラスのメソッド', true);
105//    - $syntaxOnly = false の場合、クラスが実際に存在しないためfalseを返します。
106demonstrateIsCallableChecks('NonExistentClass::someMethod', '存在しないクラスのメソッド');
107
108?>

PHPのis_callable関数は、指定された値がPHPで「呼び出し可能」な要素であるかどうかを判定するために使用されます。この関数は、関数名（文字列）、クロージャ、またはクラスのメソッド（['クラス名', 'メソッド名']のような配列形式や、'クラス名::メソッド名'のような文字列形式）など、さまざまな種類のコールバックをチェックできます。

第1引数$valueには、検査したい関数やメソッドの情報を渡します。第2引数$syntax_onlyをtrueに設定すると、PHPは実際にその関数やメソッドが存在するか、アクセスできるかといった詳細なチェックを行わず、単に構文的に呼び出し可能な形式であるかのみを判断します。第3引数&$callable_nameには、is_callableがtrueを返した場合に、その呼び出し可能な要素の正規化された名前が文字列として格納されます。戻り値はbool型で、呼び出し可能であればtrue、そうでなければfalseを返します。

サンプルコードでは、グローバル関数、無名関数（クロージャ）、MyCallableClassの静的メソッドやインスタンスメソッドが呼び出し可能と判断される例を示しています。一方、外部から直接呼び出せないプライベートメソッドや、存在しない関数・メソッドは、通常は呼び出し不可と判断されます。しかし、$syntax_onlyをtrueに設定した場合は、存在しない関数名やクラス・メソッド名でも、PHPの構文として正しければ呼び出し可能と判断される特殊な挙動が確認できます。この関数は、プログラム内で動的に関数やメソッドを呼び出す前に、安全性を確認する際に特に役立ちます。

Copy
1<?php
2
3/**
4 * is_callable() 関数の様々な使用例を示すサンプルコードです。
5 * システムエンジニアを目指す初心者の方にもわかりやすいように、呼び出し可能な値のチェック方法を解説します。
6 *
7 * この関数は、変数や式が関数として呼び出し可能かどうかを確認します。
8 */
9function checkCallableExamples(): void
10{
11    echo "--- is_callable() の基本的な使用例 ---\n";
12
13    // 1. グローバル関数名のチェック
14    $functionName = 'strlen'; // PHPの標準関数
15    if (is_callable($functionName)) {
16        echo "✅ '{$functionName}' は呼び出し可能です。\n";
17    } else {
18        echo "❌ '{$functionName}' は呼び出し可能ではありません。\n";
19    }
20
21    // 2. クロージャ（無名関数）のチェック
22    $myClosure = function (string $name): string {
23        return "Hello, " . $name;
24    };
25    if (is_callable($myClosure)) {
26        echo "✅ クロージャは呼び出し可能です。\n";
27        echo "  - 実行結果: " . $myClosure('World') . "\n";
28    } else {
29        echo "❌ クロージャは呼び出し可能ではありません。\n";
30    }
31
32    // 3. オブジェクトのメソッドのチェック
33    class MyClass
34    {
35        public function instanceMethod(): string
36        {
37            return "インスタンスメソッドが呼び出されました。";
38        }
39
40        public static function staticMethod(): string
41        {
42            return "静的メソッドが呼び出されました。";
43        }
44    }
45
46    $myObject = new MyClass();
47
48    // インスタンスメソッドのチェック (配列形式: [オブジェクト, メソッド名])
49    $instanceMethodCallable = [$myObject, 'instanceMethod'];
50    if (is_callable($instanceMethodCallable)) {
51        echo "✅ インスタンスメソッドは呼び出し可能です。\n";
52        // is_callable() が true を返した場合、call_user_func() などで呼び出すことができます。
53        echo "  - 実行結果: " . call_user_func($instanceMethodCallable) . "\n";
54    } else {
55        echo "❌ インスタンスメソッドは呼び出し可能ではありません。\n";
56    }
57
58    // 静的メソッドのチェック (配列形式: [クラス名, メソッド名])
59    $staticMethodCallable = ['MyClass', 'staticMethod'];
60    if (is_callable($staticMethodCallable)) {
61        echo "✅ 静的メソッドは呼び出し可能です。\n";
62        echo "  - 実行結果: " . call_user_func($staticMethodCallable) . "\n";
63    } else {
64        echo "❌ 静的メソッドは呼び出し可能ではありません。\n";
65    }
66
67    // 参考: PHP 5.2.3 以降非推奨ですが、文字列形式 ('ClassName::methodName') でもチェック可能です。
68    $staticMethodString = 'MyClass::staticMethod';
69    if (is_callable($staticMethodString)) {
70        echo "✅ 静的メソッド (文字列形式) も呼び出し可能です。\n";
71    }
72
73
74    echo "\n--- is_callable() のオプション引数の使用例 ---\n";
75
76    // 4. `$syntax_only` 引数の利用
77    // `$syntax_only` を `false` (デフォルト) にすると、実際に呼び出し可能か（関数/メソッドが存在するか）までチェックします。
78    $nonExistentMethod = [$myObject, 'nonExistentMethod'];
79    if (!is_callable($nonExistentMethod)) {
80        echo "❌ 'nonExistentMethod' は存在しないため、呼び出し可能ではありません。\n";
81    }
82
83    // `$syntax_only` を `true` にすると、構文上呼び出し可能であれば true を返します。
84    // この場合、メソッドが実際に存在するかどうかはチェックしません。
85    if (is_callable($nonExistentMethod, true)) {
86        echo "✅ 'nonExistentMethod' は構文上は呼び出し可能です (`syntax_only=true`)。\n";
87    } else {
88        echo "❌ 'nonExistentMethod' は構文上も呼び出し可能ではありません (`syntax_only=true`)。\n";
89    }
90
91    // 5. `$callable_name` 引数の利用
92    // 呼び出し可能な名前を文字列として取得したい場合に、参照渡しで利用します。
93
94    $callableName = null; // 参照渡しのため、事前に null で初期化します。
95    if (is_callable('array_map', false, $callableName)) {
96        echo "✅ 'array_map' は呼び出し可能で、完全な名前は '{$callableName}' です。\n";
97    }
98
99    $callableName = null;
100    if (is_callable([$myObject, 'instanceMethod'], false, $callableName)) {
101        echo "✅ インスタンスメソッドは呼び出し可能で、完全な名前は '{$callableName}' です。\n";
102    }
103
104    $callableName = null;
105    $closureWithCallableName = function() {}; // 無名関数
106    if (is_callable($closureWithCallableName, false, $callableName)) {
107        // クロージャの場合、$callable_name には内部的な名前（例: "{closure}"）が返されます。
108        echo "✅ クロージャは呼び出し可能で、完全な名前は '{$callableName}' です。\n";
109    }
110
111    // 存在しない関数/メソッドの場合
112    $callableName = null;
113    $nonCallable = 'thisFunctionDoesNotExist';
114    if (!is_callable($nonCallable, false, $callableName)) {
115        echo "❌ '{$nonCallable}' は呼び出し可能ではありません。\n";
116        // 呼び出し可能でない場合、$callable_name には何も設定されないか、null が残ります。
117        echo "  - 完全な呼び出し名: " . ($callableName ?? '設定なし') . "\n";
118    }
119}
120
121// 上記のサンプル関数を実行します。
122checkCallableExamples();

is_callable関数は、PHP 8において、与えられた変数や式が関数として実行可能であるかを安全に確認するための機能です。この関数は、引数$valueに渡されたものが、既存のグローバル関数名、クロージャ（無名関数）、あるいは[オブジェクト, メソッド名]や[クラス名, メソッド名]といった形式のメソッド呼び出しであるかを判断します。呼び出し可能であればtrueを、そうでなければfalseをブール値として返します。

第二引数$syntax_onlyをtrueに設定すると、$valueが構文上呼び出し可能であれば、実際にその関数やメソッドが存在するかどうかに関わらずtrueを返します。この引数のデフォルト値はfalseで、その場合は存在の確認も行います。

第三引数$callable_nameは参照渡しで利用され、$valueが呼び出し可能であった場合に、その完全な呼び出し名（例: "strlen"、"MyClass::instanceMethod"、"{closure}"など）を文字列として取得できます。

この関数を使用することで、プログラムが実際に動的な関数呼び出しを行う前に、対象が有効な関数やメソッドであるかを事前にチェックでき、実行時エラーのリスクを低減し、より堅牢なコードを作成することが可能になります。