destruct() 和 call() 创建无限循环

Question

我简化了我的代码很多，但我正在做的是这样的：

class App{

    protected $apps = [];

    public function __construct($name, $dependencies){
        $this->name = $name;

        $apps = [];
        foreach($dependencies as $dependName){
            $apps[$name] = $dependName($this); // returns an instance of App
        }
        $this->apps = $apps;
    }

    public function __destruct(){
        foreach($this->apps as $dep){
            $result = $dep->cleanup($this);
        }
    }

    public function __call($name, $arguments){
        if(is_callable([$this, $name])){
            return call_user_func_array([$this, $name], $arguments);
        }
    }
}


function PredefinedApp(){
    $app = new App('PredefinedApp', []);

    $app->cleanup = function($parent){
        // Do some stuff
    };
    return $app;
}

然后我创建一个这样的应用程序：

$app = new App('App1', ['PredefinedApp']);

它创建一个 App 实例，然后数组中的项目创建定义的任何新应用程序实例并将它们放入内部应用程序数组中。

当我在主应用程序上执行我的析构函数时，它应该在所有子应用程序上调用 cleanup()。但是正在发生的事情是，它正在执行一个无限循环，我不确定为什么。

我确实注意到，如果我注释掉 call_user_func_array，那么 __call() 只会被调用一次，但它不会执行实际的 closure。

我还注意到，如果我在 __call() 中执行 var_dump()，它会无休止地转储。如果我在 cleanup() 中执行 var_dump() 而不是 http 502 错误。

Answer 1

将您的 __call() 函数替换为以下内容将防止您看到的递归：

public function __call( $method, $arguments ) {
    if ( $this->{$method} instanceof Closure ) {
        return call_user_func_array( $this->{$method}, $arguments );
    } else {
        throw new Exception( "Invalid Function" );
    }
}

查看@Rizier123 的回答了解更多详情，但 TLDR 版本是：

问题是您最初调用 cleanup() 作为方法调用，$dep->cleanup() 调用 __call()。如果你然后使用 call_user_func_array() 并传递 [$this, $method] 它调用它作为一个方法，从而再次调用 _call() 并触发循环（并且永远不会 实际上 调用cleanup() 方法），而使用 $this->{$method} 会将其作为 Closure 调用并防止循环。

Answer 2

那么让我们通过代码看看这里发生了什么以及为什么：

01|    class App{ 
02|
03|        protected $apps = [];
04|
05|        public function __construct($name, $dependencies){
06|            $this->name = $name;
07|
08|            $apps = [];
09|            foreach($dependencies as $dependName){
10|                $apps[$name] = $dependName($this);
11|            }
12|            $this->apps = $apps;
13|        }
14|
15|        public function __destruct(){
16|            foreach($this->apps as $dep){
17|                $result = $dep->cleanup($this);
18|            }
19|        }
20|
21|        public function __call($name, $arguments){
22|            if(is_callable([$this, $name])){
23|                return call_user_func_array([$this, $name], $arguments);
24|            }
25|        }
26|    }
27| 
28|    function PredefinedApp(){
29|        $app = new App('PredefinedApp', []);
30|
31|        $app->cleanup = function($parent){
32|            //Do stuff like: echo "I'm saved";
33|        };
34|        return $app;
35|    }
36|  
37|    $app = new App('App1', ['PredefinedApp']);

_{注意：为代码的每一行添加了行号，因此我可以在下面的答案中引用这些行}

问题

您使用以下行创建了一个实例：App：

$app = new App('App1', ['PredefinedApp']);  //Line: 37

构造函数被调用：
```
public function __construct($name, $dependencies){ /* Code here */ }  //Line: 05
```
2.1。传递了以下参数：
- $name = "App1"
- $dependencies = ["PredefinedApp"]
您使用此行将 $name 分配给 $this->name：
```
$this->name = $name;  //Line: 06
```
你用空数组初始化 $apps:
```
$apps = [];  //Line: 08
```
现在循环遍历 $dependencies 的每个元素，这里有 1 个元素 (["PredefinedApp"])
在循环中执行以下操作：

6.1 将函数调用的 return 值分配给数组索引：
```
$apps[$name] = $dependName($this);  //Line: 10
//$apps["App1"] = PredefinedApp($this);
```

你调用函数：

PredefinedApp(){ /* Code here */}  //Line: 28

现在你再次创建一个新的实例：App in PredefinedApp() 和以前一样（第 2 - 6 点，期望在构造函数中你有其他变量值 + 你不要进入循环，因为数组是空的)

您将 closure 分配给 class 属性:

$app->cleanup = function($parent){  //Line: 31
    //Do stuff like: echo "I'm saved";
};

你return App的新创建对象:
```
return $app;  //Line: 34
```
这里已经是 __destruct() gets called，因为当函数结束时 refcount 变为 zval 的 0 并且 __destruct() 被触发。但是由于 $this->apps 是空的，这里什么也没有发生。
该函数中新创建的对象得到return编辑并分配给数组索引（注意：我们从函数返回到第 6.1 点):
```
$apps[$name] = $dependName($this);  //Line: 10
//$apps["App1"] = PredefinedApp($this);
```
构造函数以将本地数组分配给 class 属性:
```
$this->apps = $apps;  //Line: 12
```
现在整个脚本结束（我们已经完成了第37行）！这意味着对于对象 $app __destruct() is triggered 与之前对于函数 PredefinedApp()
[=171= 中的 $app 相同的原因]

这意味着您现在循环遍历 $this->apps 中的每个元素，它只包含函数的 returned 对象：

public function __destruct(){  //Line: 15
    foreach($this->apps as $dep){
        $result = $dep->cleanup($this);
    }
}

Array(
    "App1" => App Object
        (
            [apps:protected] => Array
                (
                )

            [name] => PredefinedApp
            [cleanup] => Closure Object
                (
                    [parameter] => Array
                        (
                            [$parent] => <required>
                        )

                )

        )
)

对于每个元素（这里只有 1 个）你执行：
```
$result = $dep->cleanup($this);  //Line: 17
```
But you don't call the closure! It tries to call a class method. So there is no cleanup class method, it's just a class property. Which then means __call() gets invoked:
```
public function __call($name, $arguments){  //Line: 21
    if(is_callable([$this, $name])){
        return call_user_func_array([$this, $name], $arguments);
    }
}
```
$arguments 包含自身 ($this)。 is_callable([$this, $name]) 是 TRUE，因为 cleanup 可以作为闭包调用。
所以现在我们进入了无穷无尽的东西，因为：
```
return call_user_func_array([$this, $name], $arguments);  //Line: 23
```
被执行，看起来像这样：
```
return call_user_func_array([$this, "cleanup"], $this);
```
然后再次尝试调用 cleanup 作为方法并再次调用 __call() 等等...

所以在整个脚本的末尾，漏洞灾难开始了。但我有一些好消息，这听起来很复杂，解决方案要简单得多！

解决方案

只需更改：

return call_user_func_array([$this, $name], $arguments);  //Line: 23

有了这个：

return call_user_func_array($this->$name, $arguments);
                           //^^^^^^^^^^^ See here

因为像这样更改它，您不会尝试调用方法，而是调用闭包。因此，如果您还输入：

echo "I'm saved";

在闭包中分配它时，您将得到输出：

I'm saved

destruct() 和 call() 创建无限循环

destruct() and call() create endless loop

php

oop

methods

closures

destructor

问题

解决方案

__destruct() 和 __call() 创建无限循环

__destruct() and __call() create endless loop

php

oop

methods

closures

destructor

问题

解决方案

destruct() 和 call() 创建无限循环

destruct() and call() create endless loop