This chapter is from the book
This chapter is from the book
This chapter is from the book
Creating Destructors
The corollary to the constructor is the destructor. Whereas a constructor is automatically invoked when an object is created, the destructor is called when the object is destroyed. This may occur when you overtly remove the object:
$obj = new ClassName(); unset($obj); // Calls destructor, too.
Or this may occur when a script ends (at which point PHP releases the memory used by variables).
Being the smart reader that you are, you have probably already assumed that the destructor is created like so:
class ClassName {
// Attributes and methods.
function _ _destruct() {
// Function code.
}
}
Destructors do differ from constructors and other methods in that they cannot take any arguments.
The Rectangle class used in the last two examples doesn’t lend itself to a logical destructor (there’s nothing you need to do when you’re done with a rectangle). And rather than do a potentially confusing but practical example, I’ll run through a dummy example that shows how and when constructors and destructors are called.
To create a destructor:
Create a new PHP document in your text editor or IDE, to be named demo.php, beginning with the standard HTML (Script 4.7):
<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Constructors and Destructors</title> <link rel="stylesheet" href="style.css"> </head> <body> <?php # Script 4.7 - demo.php
Begin defining the class:
class Demo {To make this example even simpler, I’ll define and use the class in the same script.
Create the constructor:
function _ _construct() { echo '<p>In the constructor.</p>'; }The constructor doesn’t do anything but print a message indicating that it has been invoked. This will allow you to trace when the class’s automatic methods are called.
Create the destructor:
function _ _destruct() { echo '<p>In the destructor.</p>'; }Complete the class:
}
It’s a very simple class!
Script 4.7. This script doesn’t do anything except best convey when constructors and destructors are called.
1 <!doctype html>
2 <html lang="en">
3 <head>
4 <meta charset="utf-8">
5 <title>Constructors and Destructors</title>
6 <link rel="stylesheet" href="style.css">
7 </head>
8 <body>
9 <?php # Script 4.7 - demo.php
10 /* This page defines a Demo class
11 * and a demo() function.
12 * Both are used to show when
13 * constructors and destructors are called.
14 */
15
16 // Define the class:
17 class Demo {
18
19 // No attributes.
20
21 // Constructor:
22 function _ _construct() {
23 echo '<p>In the constructor.</p>';
24 }
25
26 // Destructor:
27 function _ _destruct() {
28 echo '<p>In the destructor.</p>';
29 }
30
31 } // End of Demo class.
32
33 // Define a test() function:
34 function test() {
35 echo '<p>In the function. Creating a new object...</p>';
36 $f = new Demo();
37 echo '<p>About to leave the function.</p>';
38 }
39
40 // Create the object:
41 echo '<p>Creating a new object...</p>';
42 $o = new Demo();
43
44 // Call the test() function:
45 echo '<p>Calling the function...</p>';
46 test();
47
48 // Delete the object:
49 echo '<p>About to delete the object...</p>';
50 unset($o);
51
52 echo '<p>End of the script.</p>';
53 ?>
54 </body>
55 </html>
Define a simple function that also creates an object:
function test() { echo '<p>In the function. Creating a new object...</p>'; $f = new Demo(); echo '<p>About to leave the function.</p>'; }To best illuminate the life of objects, which affects when constructors and destructors are called, I’m adding this simple function. It prints messages and creates its own object, which will be a variable that’s local to this function.
Create an object of class Demo:
echo '<p>Creating a new object...</p>'; $o = new Demo();
When this object is created, the constructor will be called. So this script first prints this line (Creating a new object...) and will then print In the constructor.
Call the test() function:
echo '<p>Calling the function...</p>'; test();
After printing the status statement, the function is called. Consequently, the function is entered, wherein In the function. Creating a new object... will first be printed. Then, in that function, a new object is created (called $f). Therefore, the constructor will be called again, and the In the constructor. message printed, as you’ll see in the final output.
After the object is created in the function, the About to leave the function. message is printed. Then the function is exited, at which point in time the object defined in the function—$f—goes away, thus invoking the $f object’s destructor, printing In the destructor.
Delete the $o object:
echo '<p>About to delete the object...</p>'; unset($o);
Once this object is deleted, its destructor is invoked.
Complete the page:
echo '<p>End of the script.</p>'; ?> </body> </html>
Save the file as demo.php and place it in your Web directory. Then test by viewing it in your Web browser
.
The flow of the two objects’ creation and destruction over the execution of the script is revealed by this script. In particular, you can see how the test() function’s object, $f, lives and dies in the middle of this script.Delete the unset($o) line, save the file, and rerun it in your Web browser
.
If you don’t forcibly delete the object 
, it will be deleted when the script stops running. This means that the $o object’s destructor is called after the final printed message, even after the closing HTML tags 
.Also check the HTML source code of this page
to really understand the flow.(Arguably, you could also delete the About to delete the object... line, although I did not for the two figures.)
)