lets say i have the following:

class myclass {
public $output = ”;
function __construct(){
$this->output = “hello world”;
}
function __destruct(){
echo “lord of destruction\n”;
unset($this->output);
}
protected function Main(){ return null; }
}

$mycall = new myClass();
var_dump($mycall);
$mycall = null;

i would expect something like this:

mycall
hello world

what i get instead is:

hello world
mycall

it has probably something to do with what christian datculescu pointed out… though i at this point cannot quite wrap my had around the results…

The author’s premise is that destructors should not be called explicitly because ‘they don’t actively unset the object’. Mentioning this makes absolutely zero sense. The language specifies clearly enough that destructors are what they are (and only that): methods automatically called upon an object’s actual internal destruction. The author justifies his recommendation not to call destructors based on a purported semantic incongruence (‘they seem to actively destroy the object, but they do not’), except that incongruence exists only in his own mind. The parenthetical part (what they ‘seem’ to do) has zero basis in the actual language, and therefore, any prescription following from it is baseless as well.

And then, he contributes to a baseless AND harmful a priori notion that there never exists reason to execute whatever a destructor does before the object’s actual destruction. In fact, no doubt unwittingly, but he as good as proven himself wrong by the very examples he provided. It is perfectly reasonable to imagine a case where, for instance, a string message has to be signalled at destruction, but optionally, at the writer’s discretion, at n instances before that. This misconception may result from assuming that a destructor has to contribute to resource cleanup; but in reality, it very well can be used to communication (any action, in fact, that MAY be performed more than once but MUST be performed once).

The author’s authoritative tone while violating all the above points is particularly egregious.

FAILED.

Btw: interestingly enough, all comments in this post were made in November, the last two from different years.

$b = new A();
$d = $c = $b;

is different from

$obj = new A();
$newObj = $obj;

I am sorry and i hope i haven’t offended you with this response.

Thanks for the response, Cristian.

it seems like you haven’t read the post. An excerpt from one of the examples clearly explains yours “… if $x is a object, $a = $x, $x = NULL, will only eliminate the variable $x, because $a still holds a valid reference to the initial object.”

$obj = new A();
 
// $newObj is pointing to $obj
$newObj = $obj;
 
// this doesn't destroy $newObj
// as it appears both $obj and $newObj point to the same memory
// so PHP doesn't free this memory
$obj = null;

Also please beware that destroying a object will not actually destroy the object because an object can be destroyed only when there are no references to it anymore. Since in php5 all assignments of objects are done by reference, if $x is a object, $a = $x, $x = NULL, will only eliminate the variable $x, because $a still holds a valid reference to the initial object.