What is the point of nulling private variables in destructor?

I have spot the following pattern in code I'm working with: in some classes in destructor I have found private variable being nulled, in example:

public function __destruct()
{
    foreach($this->observers as $observer)
    {
        $observer = null;
    }
    $this->db_build = null;
}

Is 开发者_如何转开发there any point in doing this when PHP has GC? Does it somehow improve performance of script?

It's sometimes just for the cleanliness meme. But in your exmaple both $observer and ->$db_build reference sub-objects. So here the intention is to have them destroyed before the destruction of the current object finishes. (Albeit I'm unsure if Zend core really likes being interrupted when it's on a destroying rampage. It probably has a spool list or something.)

Anyway, it's not necessary from the GC point of view. But it might be sensible if the composite subojects have some inderdependencies; e.g. counters or registry references themselves. So, in most cases not needed I'd say.

I've made a silly example to demonstrate the __destruct order:

class dest {
        function __construct($name, $sub=NULL) {
                $this->name = $name;
                $this->sub = $sub;
        }
        function __destruct() {
                print "<destroying $this->name>\n";
                $this->sub = NULL;
                print "</destroying $this->name>\n";
        }
}

$d = new dest("first", new dest("second", new dest("third")));
exit;

Without the $this->sub = NULL the destruction of the objects would each happen individually, not necessarily in instantiation order. With unsetting composite objects manually however PHP destroys the three objects in a nested fashion:

<destroying first>
    <destroying second>
        <destroying third>
        </destroying third>
    </destroying second>
</destroying first>

It could be because PHP's garbage collection is based on reference countring, and older versions could not handle cyclical dependencies. Then, in some cases it would have been necessary to manually set references to null to enable the GC to do its work, and there may still be some special cases that the cycle detection algorithm does not catch.

More likely though, it's just an example of cargo cult programming (the Wikipedia entry even explicitly lists this as an example).

first - it's a good programming tone, second - it makes script memory free. if right after invoking destructor php script terminates, i see no advantages.