［PHP］runkit7_method_remove関数を完全解説!メソッドを削除する方法

こんにちは!今回は、PHPのrunkit7拡張機能で提供されるrunkit7_method_remove()関数について詳しく解説していきます。既存のクラスメソッドを実行時に削除できる、特殊な関数です!

runkit7_method_remove関数とは?

runkit7_method_remove()関数は、既存のクラスから特定のメソッドを実行時に削除することができる関数です。

通常、クラスのメソッドは一度定義したら削除できませんが、この関数を使えばメソッドを「存在しなかったこと」にできます!

基本的な構文

runkit7_method_remove(string $classname, string $methodname): bool

• $classname: メソッドを削除するクラス名
• $methodname: 削除するメソッドの名前
• 戻り値: 成功時にtrue、失敗時にfalse

前提条件

runkit7拡張機能のインストール

pecl install runkit7

php.iniに以下を追加:

extension=runkit7.so
runkit.internal_override=1

インストール確認:

<?php
if (function_exists('runkit7_method_remove')) {
    echo "runkit7が利用可能です!";
} else {
    echo "runkit7がインストールされていません";
}
?>

基本的な使用例

シンプルなメソッドの削除

class User {
    private $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    public function getName() {
        return $this->name;
    }
    
    public function greet() {
        return "こんにちは、{$this->name}さん!";
    }
}

$user = new User('田中');
echo $user->getName() . "\n";  // 出力: 田中
echo $user->greet() . "\n";    // 出力: こんにちは、田中さん!

// greetメソッドが存在することを確認
var_dump(method_exists('User', 'greet')); // bool(true)

// greetメソッドを削除
runkit7_method_remove('User', 'greet');

// 削除されたことを確認
var_dump(method_exists('User', 'greet')); // bool(false)

echo $user->getName() . "\n";  // 出力: 田中（まだ使える）
// echo $user->greet();        // Fatal error: Call to undefined method

複数のメソッドを削除

class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }
    
    public function subtract($a, $b) {
        return $a - $b;
    }
    
    public function multiply($a, $b) {
        return $a * $b;
    }
    
    public function divide($a, $b) {
        return $a / $b;
    }
}

$calc = new Calculator();

echo $calc->add(10, 5) . "\n";      // 出力: 15
echo $calc->multiply(10, 5) . "\n"; // 出力: 50

// 不要なメソッドを削除
runkit7_method_remove('Calculator', 'subtract');
runkit7_method_remove('Calculator', 'divide');

// 削除されたメソッドは使用不可
// echo $calc->subtract(10, 5); // Fatal error

// 残りのメソッドは使用可能
echo $calc->add(10, 5) . "\n";      // 出力: 15
echo $calc->multiply(10, 5) . "\n"; // 出力: 50

実践的な使用例

例1: 一時的なヘルパーメソッドのクリーンアップ

class DataProcessor {
    private $data = [];
    
    public function addData($key, $value) {
        $this->data[$key] = $value;
        return $this;
    }
    
    public function getData() {
        return $this->data;
    }
}

class TemporaryMethodManager {
    private $tempMethods = [];
    
    public function addTemporaryMethod($className, $methodName, $args, $code) {
        runkit7_method_add($className, $methodName, $args, $code);
        
        if (!isset($this->tempMethods[$className])) {
            $this->tempMethods[$className] = [];
        }
        
        $this->tempMethods[$className][] = $methodName;
        
        echo "一時メソッド追加: {$className}::{$methodName}\n";
    }
    
    public function cleanup($className = null) {
        if ($className === null) {
            // すべてのクラスをクリーンアップ
            foreach ($this->tempMethods as $class => $methods) {
                $this->cleanup($class);
            }
            return;
        }
        
        if (!isset($this->tempMethods[$className])) {
            echo "クリーンアップ対象なし: {$className}\n";
            return;
        }
        
        echo "クリーンアップ中: {$className}\n";
        
        foreach ($this->tempMethods[$className] as $methodName) {
            if (method_exists($className, $methodName)) {
                runkit7_method_remove($className, $methodName);
                echo "  削除: {$methodName}\n";
            }
        }
        
        unset($this->tempMethods[$className]);
    }
    
    public function listTemporaryMethods() {
        echo "=== 一時メソッド一覧 ===\n";
        foreach ($this->tempMethods as $className => $methods) {
            echo "{$className}:\n";
            foreach ($methods as $method) {
                echo "  - {$method}\n";
            }
        }
    }
}

// 使用例
$processor = new DataProcessor();
$manager = new TemporaryMethodManager();

// 一時的なメソッドを追加
$manager->addTemporaryMethod(
    'DataProcessor',
    'validate',
    '',
    'return count($this->data) > 0;'
);

$manager->addTemporaryMethod(
    'DataProcessor',
    'clear',
    '',
    '$this->data = []; return $this;'
);

$manager->addTemporaryMethod(
    'DataProcessor',
    'toJson',
    '',
    'return json_encode($this->data);'
);

// 一時メソッドを使用
$processor->addData('name', '田中')
          ->addData('age', 30);

var_dump($processor->validate()); // bool(true)
echo $processor->toJson() . "\n"; // {"name":"田中","age":30}

$manager->listTemporaryMethods();

// クリーンアップ
$manager->cleanup('DataProcessor');

// クリーンアップ後は使用不可
var_dump(method_exists('DataProcessor', 'validate')); // bool(false)

例2: プラグインシステムでの動的な機能管理

class Application {
    private $name;
    
    public function __construct($name) {
        $this->name = $name;
    }
    
    public function getName() {
        return $this->name;
    }
}

class PluginManager {
    private $plugins = [];
    
    public function loadPlugin($pluginName, $methods) {
        echo "プラグイン '{$pluginName}' を読み込み中...\n";
        
        $this->plugins[$pluginName] = [];
        
        foreach ($methods as $methodName => $methodData) {
            list($args, $code) = $methodData;
            
            runkit7_method_add('Application', $methodName, $args, $code);
            
            $this->plugins[$pluginName][] = $methodName;
            echo "  メソッド追加: {$methodName}\n";
        }
        
        echo "プラグイン '{$pluginName}' の読み込み完了\n";
    }
    
    public function unloadPlugin($pluginName) {
        if (!isset($this->plugins[$pluginName])) {
            echo "エラー: プラグイン '{$pluginName}' は読み込まれていません\n";
            return false;
        }
        
        echo "プラグイン '{$pluginName}' をアンロード中...\n";
        
        foreach ($this->plugins[$pluginName] as $methodName) {
            if (method_exists('Application', $methodName)) {
                runkit7_method_remove('Application', $methodName);
                echo "  メソッド削除: {$methodName}\n";
            }
        }
        
        unset($this->plugins[$pluginName]);
        echo "プラグイン '{$pluginName}' のアンロード完了\n";
        
        return true;
    }
    
    public function listPlugins() {
        echo "=== 読み込まれているプラグイン ===\n";
        foreach ($this->plugins as $pluginName => $methods) {
            echo "{$pluginName}:\n";
            foreach ($methods as $method) {
                echo "  - {$method}\n";
            }
        }
    }
    
    public function reloadPlugin($pluginName, $methods) {
        $this->unloadPlugin($pluginName);
        $this->loadPlugin($pluginName, $methods);
    }
}

// 使用例
$app = new Application('MyApp');
$manager = new PluginManager();

// ロギングプラグインを読み込み
$manager->loadPlugin('LoggingPlugin', [
    'log' => [
        '$message',
        'echo "[" . $this->getName() . "] {$message}\n";'
    ],
    'logError' => [
        '$error',
        'echo "[ERROR] {$error}\n";'
    ]
]);

// キャッシュプラグインを読み込み
$manager->loadPlugin('CachePlugin', [
    'cacheSet' => [
        '$key, $value',
        'static $cache = []; $cache[$key] = $value;'
    ],
    'cacheGet' => [
        '$key',
        'static $cache = []; return $cache[$key] ?? null;'
    ]
]);

echo "\n";
$manager->listPlugins();

echo "\n=== プラグイン使用 ===\n";
$app->log('アプリケーション起動');
$app->cacheSet('user_id', 123);
echo "キャッシュ値: " . $app->cacheGet('user_id') . "\n";

echo "\n";
// ロギングプラグインをアンロード
$manager->unloadPlugin('LoggingPlugin');

echo "\n";
$manager->listPlugins();

// ロギングメソッドはもう使えない
// $app->log('テスト'); // Fatal error

例3: デバッグメソッドの動的管理

class Product {
    private $id;
    private $name;
    private $price;
    
    public function __construct($id, $name, $price) {
        $this->id = $id;
        $this->name = $name;
        $this->price = $price;
    }
    
    public function getPrice() {
        return $this->price;
    }
}

class DebugHelper {
    private static $debugMethods = [];
    private static $enabled = false;
    
    public static function enable($className) {
        if (self::$enabled) {
            echo "デバッグモードは既に有効です\n";
            return;
        }
        
        echo "デバッグモードを有効化中...\n";
        
        // デバッグメソッドを追加
        $methods = [
            'dump' => [
                '',
                '
                    echo "=== オブジェクトダンプ ===\n";
                    echo "ID: {$this->id}\n";
                    echo "Name: {$this->name}\n";
                    echo "Price: {$this->price}\n";
                    return $this;
                '
            ],
            'inspect' => [
                '',
                '
                    return [
                        "id" => $this->id,
                        "name" => $this->name,
                        "price" => $this->price
                    ];
                '
            ],
            'trace' => [
                '$message',
                '
                    $trace = debug_backtrace();
                    $caller = isset($trace[1]) ? $trace[1]["function"] : "unknown";
                    echo "[TRACE from {$caller}] {$message}\n";
                    return $this;
                '
            ]
        ];
        
        foreach ($methods as $methodName => $methodData) {
            list($args, $code) = $methodData;
            runkit7_method_add($className, $methodName, $args, $code);
            
            if (!isset(self::$debugMethods[$className])) {
                self::$debugMethods[$className] = [];
            }
            
            self::$debugMethods[$className][] = $methodName;
        }
        
        self::$enabled = true;
        echo "デバッグメソッドを追加しました: " . implode(', ', array_keys($methods)) . "\n";
    }
    
    public static function disable($className) {
        if (!self::$enabled) {
            echo "デバッグモードは既に無効です\n";
            return;
        }
        
        echo "デバッグモードを無効化中...\n";
        
        if (!isset(self::$debugMethods[$className])) {
            echo "デバッグメソッドが見つかりません\n";
            return;
        }
        
        foreach (self::$debugMethods[$className] as $methodName) {
            if (method_exists($className, $methodName)) {
                runkit7_method_remove($className, $methodName);
            }
        }
        
        unset(self::$debugMethods[$className]);
        self::$enabled = false;
        
        echo "デバッグメソッドを削除しました\n";
    }
}

// 使用例
$product = new Product(1, 'ノートパソコン', 100000);

echo "通常モード:\n";
echo "価格: " . $product->getPrice() . "円\n";

echo "\n";
DebugHelper::enable('Product');

echo "\nデバッグモード有効:\n";
$product->dump();
$product->trace('価格を取得します');
print_r($product->inspect());

echo "\n";
DebugHelper::disable('Product');

echo "\n通常モードに戻りました:\n";
var_dump(method_exists('Product', 'dump')); // bool(false)

例4: 機能フラグによるメソッドの有効/無効化

class PaymentService {
    private $amount;
    
    public function __construct($amount) {
        $this->amount = $amount;
    }
    
    public function process() {
        return "処理完了: {$this->amount}円";
    }
}

class FeatureManager {
    private static $enabledFeatures = [];
    private static $featureMethods = [
        'discount' => [
            'applyDiscount' => [
                '$percentage',
                '
                    $discount = $this->amount * ($percentage / 100);
                    $this->amount -= $discount;
                    return "割引適用: {$discount}円引き";
                '
            ],
            'getDiscountedAmount' => [
                '',
                'return $this->amount;'
            ]
        ],
        'tax' => [
            'calculateTax' => [
                '$rate = 0.1',
                'return $this->amount * $rate;'
            ],
            'getTotalWithTax' => [
                '$rate = 0.1',
                'return $this->amount * (1 + $rate);'
            ]
        ],
        'coupon' => [
            'applyCoupon' => [
                '$couponCode',
                '
                    // クーポンコードに応じた処理
                    $discount = 1000; // 仮の値
                    $this->amount -= $discount;
                    return "クーポン適用: {$couponCode}";
                '
            ]
        ]
    ];
    
    public static function enableFeature($featureName) {
        if (!isset(self::$featureMethods[$featureName])) {
            echo "エラー: 不明な機能 '{$featureName}'\n";
            return false;
        }
        
        if (in_array($featureName, self::$enabledFeatures)) {
            echo "機能 '{$featureName}' は既に有効です\n";
            return true;
        }
        
        echo "機能 '{$featureName}' を有効化中...\n";
        
        foreach (self::$featureMethods[$featureName] as $methodName => $methodData) {
            list($args, $code) = $methodData;
            runkit7_method_add('PaymentService', $methodName, $args, $code);
            echo "  メソッド追加: {$methodName}\n";
        }
        
        self::$enabledFeatures[] = $featureName;
        echo "機能 '{$featureName}' を有効化しました\n";
        
        return true;
    }
    
    public static function disableFeature($featureName) {
        if (!in_array($featureName, self::$enabledFeatures)) {
            echo "機能 '{$featureName}' は有効になっていません\n";
            return false;
        }
        
        echo "機能 '{$featureName}' を無効化中...\n";
        
        foreach (self::$featureMethods[$featureName] as $methodName => $methodData) {
            if (method_exists('PaymentService', $methodName)) {
                runkit7_method_remove('PaymentService', $methodName);
                echo "  メソッド削除: {$methodName}\n";
            }
        }
        
        self::$enabledFeatures = array_diff(self::$enabledFeatures, [$featureName]);
        echo "機能 '{$featureName}' を無効化しました\n";
        
        return true;
    }
    
    public static function listFeatures() {
        echo "=== 利用可能な機能 ===\n";
        foreach (self::$featureMethods as $featureName => $methods) {
            $status = in_array($featureName, self::$enabledFeatures) ? '有効' : '無効';
            echo "{$featureName}: {$status}\n";
            foreach ($methods as $methodName => $methodData) {
                echo "  - {$methodName}\n";
            }
        }
    }
}

// 使用例
$payment = new PaymentService(10000);

echo "基本機能のみ:\n";
echo $payment->process() . "\n";

echo "\n";
FeatureManager::enableFeature('discount');

echo "\n割引機能使用:\n";
echo $payment->applyDiscount(20) . "\n";
echo "割引後の金額: " . $payment->getDiscountedAmount() . "円\n";

echo "\n";
FeatureManager::enableFeature('tax');

echo "\n税金計算:\n";
echo "税額: " . $payment->calculateTax(0.1) . "円\n";
echo "税込合計: " . $payment->getTotalWithTax(0.1) . "円\n";

echo "\n";
FeatureManager::listFeatures();

echo "\n";
FeatureManager::disableFeature('discount');

echo "\n";
var_dump(method_exists('PaymentService', 'applyDiscount')); // bool(false)

例5: テスト環境でのメソッド隔離

class UserService {
    public function createUser($name, $email) {
        // 実際のDB処理
        return [
            'id' => rand(1000, 9999),
            'name' => $name,
            'email' => $email
        ];
    }
    
    public function sendWelcomeEmail($email) {
        // 実際のメール送信
        return "ウェルカムメールを送信: {$email}";
    }
    
    public function logActivity($action) {
        // 実際のログ記録
        return "ログ記録: {$action}";
    }
}

class TestEnvironment {
    private $disabledMethods = [];
    
    public function setUp() {
        echo "テスト環境をセットアップ中...\n";
        
        // 危険なメソッドを無効化
        $this->disableMethod('UserService', 'sendWelcomeEmail', '実際のメール送信を防ぐため');
        $this->disableMethod('UserService', 'logActivity', 'テスト中のログ記録を防ぐため');
        
        // テスト用の代替メソッドを追加
        runkit7_method_add(
            'UserService',
            'sendWelcomeEmail_test',
            '$email',
            'echo "[TEST] メール送信をシミュレート: {$email}\n"; return "[TEST] 送信完了";'
        );
        
        runkit7_method_add(
            'UserService',
            'logActivity_test',
            '$action',
            'echo "[TEST] ログ記録をシミュレート: {$action}\n"; return "[TEST] 記録完了";'
        );
        
        echo "テスト環境のセットアップ完了\n";
    }
    
    private function disableMethod($className, $methodName, $reason = '') {
        if (!method_exists($className, $methodName)) {
            echo "警告: {$className}::{$methodName} は存在しません\n";
            return false;
        }
        
        runkit7_method_remove($className, $methodName);
        
        $this->disabledMethods[] = [
            'class' => $className,
            'method' => $methodName,
            'reason' => $reason
        ];
        
        echo "  無効化: {$className}::{$methodName}";
        if ($reason) echo " ({$reason})";
        echo "\n";
        
        return true;
    }
    
    public function tearDown() {
        echo "\nテスト環境をクリーンアップ中...\n";
        
        // テスト用メソッドを削除
        if (method_exists('UserService', 'sendWelcomeEmail_test')) {
            runkit7_method_remove('UserService', 'sendWelcomeEmail_test');
            echo "  削除: sendWelcomeEmail_test\n";
        }
        
        if (method_exists('UserService', 'logActivity_test')) {
            runkit7_method_remove('UserService', 'logActivity_test');
            echo "  削除: logActivity_test\n";
        }
        
        echo "テスト環境のクリーンアップ完了\n";
    }
    
    public function showDisabledMethods() {
        echo "\n=== 無効化されたメソッド ===\n";
        foreach ($this->disabledMethods as $info) {
            echo "{$info['class']}::{$info['method']}";
            if ($info['reason']) echo " - {$info['reason']}";
            echo "\n";
        }
    }
}

// 使用例
$service = new UserService();
$testEnv = new TestEnvironment();

echo "=== 本番環境の動作 ===\n";
$user = $service->createUser('田中太郎', 'tanaka@example.com');
print_r($user);
// echo $service->sendWelcomeEmail('tanaka@example.com') . "\n";

echo "\n";
$testEnv->setUp();
$testEnv->showDisabledMethods();

echo "\n=== テスト環境の動作 ===\n";
$user = $service->createUser('テストユーザー', 'test@example.com');
print_r($user);

// 危険なメソッドは使えない
// $service->sendWelcomeEmail('test@example.com'); // Fatal error

// テスト用メソッドを使用
echo $service->sendWelcomeEmail_test('test@example.com') . "\n";
echo $service->logActivity_test('ユーザー作成') . "\n";

$testEnv->tearDown();

例6: セキュリティ上危険なメソッドの削除

class AdminPanel {
    private $isAdmin = false;
    
    public function setAdmin($status) {
        $this->isAdmin = $status;
    }
    
    public function dangerousOperation() {
        if (!$this->isAdmin) {
            throw new Exception("権限がありません");
        }
        return "危険な操作を実行";
    }
    
    public function deleteAllData() {
        if (!$this->isAdmin) {
            throw new Exception("権限がありません");
        }
        return "全データ削除";
    }
    
    public function resetPassword($userId) {
        return "パスワードリセット: ユーザーID {$userId}";
    }
}

class SecurityManager {
    private static $removedMethods = [];
    
    public static function lockdownMode() {
        echo "ロックダウンモードを開始...\n";
        
        $dangerousMethods = [
            'dangerousOperation' => '危険な操作のため',
            'deleteAllData' => 'データ削除の危険性のため'
        ];
        
        foreach ($dangerousMethods as $method => $reason) {
            if (method_exists('AdminPanel', $method)) {
                // バックアップを作成
                $backupName = "{$method}_disabled";
                runkit7_method_copy('AdminPanel', $backupName, 'AdminPanel', $method);
                
                // メソッドを削除
                runkit7_method_remove('AdminPanel', $method);
                
                self::$removedMethods[$method] = [
                    'backup' => $backupName,
                    'reason' => $reason
                ];
                
                echo "  削除: {$method} ({$reason})\n";
            }
        }
        
        echo "ロックダウンモード完了\n";
    }
    
    public static function normalMode() {
        echo "通常モードに復帰...\n";
        
        foreach (self::$removedMethods as $method => $info) {
            $backupName = $info['backup'];
            
            // バックアップから復元
            if (method_exists('AdminPanel', $backupName)) {
                runkit7_method_copy('AdminPanel', $method, 'AdminPanel', $backupName);
                runkit7_method_remove('AdminPanel', $backupName);
                
                echo "  復元: {$method}\n";
            }
        }
        
        self::$removedMethods = [];
        echo "通常モードに復帰完了\n";
    }
    
    public static function showStatus() {
        echo "\n=== セキュリティ状態 ===\n";
        if (empty(self::$removedMethods)) {
            echo "通常モード: すべてのメソッドが利用可能\n";
        } else {
            echo "ロックダウンモード: 以下のメソッドが無効化されています\n";
            foreach (self::$removedMethods as $method => $info) {
                echo "  - {$method}: {$info['reason']}\n";
            }
        }
    }
}

// 使用例
$admin = new AdminPanel();
$admin->setAdmin(true);

echo "=== 通常モード ===\n";
echo $admin->resetPassword(123) . "\n";
// echo $admin->dangerousOperation() . "\n";

echo "\n";
SecurityManager::lockdownMode();
SecurityManager::showStatus();

echo "\n=== ロックダウンモード ===\n";
echo $admin->resetPassword(456) . "\n"; // これは使える

// 危険なメソッドは削除されている
var_dump(method_exists('AdminPanel', 'dangerousOperation')); // bool(false)
// $admin->dangerousOperation(); // Fatal error

echo "\n";
SecurityManager::normalMode();
SecurityManager::showStatus();

echo "\n=== 通常モードに復帰 ===\n";
var_dump(method_exists('AdminPanel', 'dangerousOperation')); // bool(true)

例7: 一時的な拡張メソッドのスコープ管理

class Document {
    private $content = '';
    
    public function setContent($content) {
        $this->content = $content;
        return $this;
    }
    
    public function getContent() {
        return $this->content;
    }
}

class ScopedMethodManager {
    private $scopeMethods = [];
    
    public function enterScope($scopeName, $className, $methods) {
        echo "スコープ '{$scopeName}' に入ります...\n";
        
        $this->scopeMethods[$scopeName] = [
            'class' => $className,
            'methods' => []
        ];
        
        foreach ($methods as $methodName => $methodData) {
            list($args, $code) = $methodData;
            
            runkit7_method_add($className, $methodName, $args, $code);
            
            $this->scopeMethods[$scopeName]['methods'][] = $methodName;
            echo "  追加: {$methodName}\n";
        }
        
        echo "スコープ '{$scopeName}' に入りました\n";
    }
    
    public function exitScope($scopeName) {
        if (!isset($this->scopeMethods[$scopeName])) {
            echo "エラー: スコープ '{$scopeName}' は存在しません\n";
            return false;
        }
        
        echo "スコープ '{$scopeName}' から出ます...\n";
        
        $scope = $this->scopeMethods[$scopeName];
        $className = $scope['class'];
        
        foreach ($scope['methods'] as $methodName) {
            if (method_exists($className, $methodName)) {
                runkit7_method_remove($className, $methodName);
                echo "  削除: {$methodName}\n";
            }
        }
        
        unset($this->scopeMethods[$scopeName]);
        echo "スコープ '{$scopeName}' から出ました\n";
        
        return true;
    }
    
    public function listScopes() {
        echo "=== アクティブなスコープ ===\n";
        foreach ($this->scopeMethods as $scopeName => $scope) {
            echo "{$scopeName} ({$scope['class']}):\n";
            foreach ($scope['methods'] as $method) {
                echo "  - {$method}\n";
            }
        }
    }
}

// 使用例
$doc = new Document();
$scopeManager = new ScopedMethodManager();

$doc->setContent('これは文書です');

echo "=== グローバルスコープ ===\n";
echo $doc->getContent() . "\n";

echo "\n";
// 編集スコープに入る
$scopeManager->enterScope('editing', 'Document', [
    'toUpperCase' => [
        '',
        '$this->content = strtoupper($this->content); return $this;'
    ],
    'toLowerCase' => [
        '',
        '$this->content = strtolower($this->content); return $this;'
    ],
    'reverse' => [
        '',
        '$this->content = strrev($this->content); return $this;'
    ]
]);

echo "\n=== 編集スコープ内 ===\n";
$doc->toUpperCase();
echo $doc->getContent() . "\n";

echo "\n";
// 分析スコープに入る
$scopeManager->enterScope('analysis', 'Document', [
    'wordCount' => [
        '',
        'return str_word_count($this->content);'
    ],
    'charCount' => [
        '',
        'return mb_strlen($this->content);'
    ]
]);

echo "\n=== 分析スコープ内 ===\n";
echo "文字数: " . $doc->charCount() . "\n";

echo "\n";
$scopeManager->listScopes();

echo "\n";
// 編集スコープから出る
$scopeManager->exitScope('editing');

echo "\n";
var_dump(method_exists('Document', 'toUpperCase')); // bool(false)
var_dump(method_exists('Document', 'wordCount'));   // bool(true) - まだ分析スコープ内

echo "\n";
// 分析スコープからも出る
$scopeManager->exitScope('analysis');

var_dump(method_exists('Document', 'wordCount')); // bool(false)

重要な注意点と制限事項

1. 存在しないメソッドの削除

class MyClass {
    public function existingMethod() {
        return "existing";
    }
}

// 存在しないメソッドの削除は失敗
$result = runkit7_method_remove('MyClass', 'nonExistentMethod');
var_dump($result); // bool(false)

2. 組み込みクラスのメソッド

// 組み込みクラスのメソッドは削除できない
$result = runkit7_method_remove('DateTime', 'format');
var_dump($result); // bool(false)

3. 削除後の呼び出し

class TestClass {
    public function testMethod() {
        return "test";
    }
}

$obj = new TestClass();
echo $obj->testMethod() . "\n"; // 出力: test

// メソッドを削除
runkit7_method_remove('TestClass', 'testMethod');

// 削除後は呼び出せない
// echo $obj->testMethod(); // Fatal error: Call to undefined method

4. 継承されたメソッド

class ParentClass {
    public function parentMethod() {
        return "parent";
    }
}

class ChildClass extends ParentClass {
    public function childMethod() {
        return "child";
    }
}

$child = new ChildClass();
echo $child->parentMethod() . "\n";  // 出力: parent
echo $child->childMethod() . "\n";   // 出力: child

// 親クラスのメソッドを削除
runkit7_method_remove('ParentClass', 'parentMethod');

// 子クラスからも使えなくなる
// echo $child->parentMethod(); // Fatal error

エラーハンドリングとベストプラクティス

安全な削除関数

function safeRemoveMethod($className, $methodName) {
    // クラスの存在確認
    if (!class_exists($className)) {
        echo "エラー: クラス {$className} が存在しません\n";
        return false;
    }
    
    // メソッドの存在確認
    if (!method_exists($className, $methodName)) {
        echo "エラー: メソッド {$className}::{$methodName} が存在しません\n";
        return false;
    }
    
    // 組み込みクラスかチェック
    $reflection = new ReflectionClass($className);
    if ($reflection->isInternal()) {
        echo "エラー: {$className} は組み込みクラスです\n";
        return false;
    }
    
    // 削除実行
    $result = runkit7_method_remove($className, $methodName);
    
    if ($result) {
        echo "成功: {$className}::{$methodName} を削除しました\n";
    } else {
        echo "エラー: メソッドの削除に失敗しました\n";
    }
    
    return $result;
}

// 使用例
class TestClass {
    public function method1() { return "m1"; }
    public function method2() { return "m2"; }
}

safeRemoveMethod('TestClass', 'method1');         // 成功
safeRemoveMethod('TestClass', 'method1');         // エラー: 既に削除済み
safeRemoveMethod('TestClass', 'nonExistent');     // エラー: 存在しない
safeRemoveMethod('DateTime', 'format');           // エラー: 組み込みクラス

削除履歴の管理

class MethodRemovalTracker {
    private static $removedMethods = [];
    
    public static function remove($className, $methodName) {
        if (!method_exists($className, $methodName)) {
            return false;
        }
        
        // メソッド情報を記録
        $reflection = new ReflectionMethod($className, $methodName);
        $info = [
            'class' => $className,
            'method' => $methodName,
            'file' => $reflection->getFileName(),
            'line' => $reflection->getStartLine(),
            'removed_at' => date('Y-m-d H:i:s')
        ];
        
        // 削除実行
        $result = runkit7_method_remove($className, $methodName);
        
        if ($result) {
            self::$removedMethods[] = $info;
            echo "削除: {$className}::{$methodName}\n";
        }
        
        return $result;
    }
    
    public static function getHistory() {
        return self::$removedMethods;
    }
    
    public static function showHistory() {
        echo "=== 削除されたメソッドの履歴 ===\n";
        foreach (self::$removedMethods as $info) {
            echo "[{$info['removed_at']}] {$info['class']}::{$info['method']}\n";
            if ($info['file']) {
                echo "  定義場所: {$info['file']}:{$info['line']}\n";
            }
        }
    }
}

// 使用例
class SampleClass {
    public function method1() { return "m1"; }
    public function method2() { return "m2"; }
    public function method3() { return "m3"; }
}

MethodRemovalTracker::remove('SampleClass', 'method1');
MethodRemovalTracker::remove('SampleClass', 'method2');
MethodRemovalTracker::remove('SampleClass', 'method3');

MethodRemovalTracker::showHistory();

パフォーマンスへの影響

// パフォーマンステスト
class PerformanceTest {
    public static function benchmark() {
        // 100個のメソッドを持つクラスを作成
        $methodCode = '';
        for ($i = 1; $i <= 100; $i++) {
            $methodCode .= "public function method{$i}() { return {$i}; }\n";
        }
        
        eval("class TestClass { {$methodCode} }");
        
        // 削除の速度測定
        $start = microtime(true);
        
        for ($i = 1; $i <= 100; $i++) {
            runkit7_method_remove('TestClass', "method{$i}");
        }
        
        $time = microtime(true) - $start;
        echo "100個のメソッド削除: {$time}秒\n";
        
        // 確認
        $remainingMethods = get_class_methods('TestClass');
        echo "残っているメソッド: " . count($remainingMethods ?? []) . "個\n";
    }
}

PerformanceTest::benchmark();

より安全な代替手段

実際の開発では、以下の方法を検討することをお勧めします:

1. インターフェースの使用

interface BasicInterface {
    public function basicMethod();
}

interface ExtendedInterface extends BasicInterface {
    public function extendedMethod();
}

class BasicImplementation implements BasicInterface {
    public function basicMethod() {
        return "basic";
    }
}

class ExtendedImplementation implements ExtendedInterface {
    public function basicMethod() {
        return "basic";
    }
    
    public function extendedMethod() {
        return "extended";
    }
}

// 必要に応じて使い分ける

2. 条件分岐での制御

class ConditionalClass {
    private $advancedMode = false;
    
    public function enableAdvanced() {
        $this->advancedMode = true;
    }
    
    public function advancedMethod() {
        if (!$this->advancedMode) {
            throw new Exception("高度な機能は有効になっていません");
        }
        
        return "高度な処理";
    }
}

3. ヌルオブジェクトパターン

interface LoggerInterface {
    public function log($message);
}

class RealLogger implements LoggerInterface {
    public function log($message) {
        echo "[LOG] {$message}\n";
    }
}

class NullLogger implements LoggerInterface {
    public function log($message) {
        // 何もしない
    }
}

// 使用
$logger = $debugMode ? new RealLogger() : new NullLogger();
$logger->log('メッセージ');

まとめ

runkit7_method_remove()関数の特徴をまとめると:

できること:

• 既存のメソッドを実行時に削除
• プラグインシステムでの動的な機能管理
• デバッグメソッドの一時的な追加と削除
• セキュリティ上危険なメソッドの無効化
• 機能フラグによる動的な制御

注意点:

• runkit7拡張機能のインストールが必要
• 存在しないメソッドは削除できない
• 組み込みクラスのメソッドは削除できない
• 削除後の呼び出しはエラーになる
• 継承関係にも影響する

推奨される使用場面:

• プラグインシステムの実装
• テスト環境でのメソッド隔離
• デバッグ機能の動的管理
• セキュリティ上の理由での一時的な無効化

より良い代替手段:

• インターフェースの使用
• 条件分岐での制御
• ヌルオブジェクトパターン
• ストラテジーパターン

runkit7_method_remove()は特定の状況では便利ですが、通常のアプリケーション開発ではデザインパターンや条件分岐を使った方が安全で保守性の高いコードになります。メソッドの削除はコードの予測可能性を損なう可能性があるため、特別な理由がない限り標準的な方法を使うことをお勧めします!