Introduction to Destructor in PHP
A Destructor is a function used for deleting the object instance that was created by a constructor for a given class, as a part of its functional feature. Whenever a constructor is used in a PHP program, it is not mandatory to have a destructor function to complement its functionality. But it is considered as a good practice to have destructor in the program where a constructor is called for. Also, this method is not specifically called for execution, instead it is executed when the control doesn’t find anymore functional references to the constructor method.
Basic syntax to call a destructor: The __destruct() function,
Syntax:
__destruct ( void ) : voidFor every destructor to be called, there has to be a constructor before it as shown below:
<?php
class <ANY_CLASS_NAME> {
// Declaring a constructor
function __construct() {
// To initialize required properties
}
// Declaring a destructor
function __destruct() {
// To remove reference of an object
}
}
?>Working of Destructor in PHP
Destructor is basically managed by the Garbage Collector which clears an object when it is not needed anymore. It cannot take any arguments as its input in contrast to the constructor.
This method is also used for cleaning up resources and to free the memory for accommodating more. Overloading cannot be performed with destructors and only a single destructor can exist in the same class. Another unique feature of it is that even if the script has stopped its execution with the help of an exit() command, the destructor will still be called. This exit() will not allow the leftover shutdown methods from quitting.
Examples of Destructor in PHP
Let us take some examples to understand destructor better:
Example #1
This is a simple example where we are creating a basic constructor function and then destroying the same by calling the destructor function.
Code:
<?php
class DestructableExample
{
function __construct() {
print "Inside constructor\n";
}
function __destruct() {
print "Destroying the class " . __CLASS__ . "\n";
}
}
$obj = new DestructableExample();Output:
Example #2
For this example we are using two variables in the constructor; employee first name and last name and then we are destroying the object Employee just before the PHP code ends by calling the destructor.
Code:
<?php
class Employee {
// Employee's first name
private $emp_fname;
// Employee's last name
private $emp_lname;
// Declaration of constructor
public function __construct($emp_fname, $emp_lname) {
echo "Initialisation of object as follows...<br/>";
$this->emp_fname = $emp_fname;
$this->emp_lname = $emp_lname;
}
// Declaration of destructor
public function __destruct(){
// Here we can clean the resources
echo "Removing the Object...";
}
// This method is being used to display full name
public function showName() {
echo "Employee full name is: " . $this->emp_fname . " " . $this->emp_lname . "<br/>";
}
}
// Class object declaration
$harry = new Employee("Harry", "Potter");
$harry->showName();
?>Output:
Example #3
In this example, we shall see how to handle a file test_doc.txt which is a pre-requisite text document to be present in the same working directory as the main file. Make sure to include some text in the test_doc.txt which needs to be displayed as part of the code.
fopen is the built-in function used for opening the file and fread is the function used to read the contents of the file. Here the destructor will be called to close/destroy the filehandle.
Code:
<?php
header("Content-type: text/plain");
class Example {
/**
* Declaring an identifier
* variable- string
*/
private $first_name;
/**
* A reference to another Foo object
* variable Foo
*/
private $setlink;
public function __construct($first_name) {
$this->first_name = $first_name;
}
public function setLink(Example $setlink){
$this->setlink = $setlink;
}
public function __destruct() {
echo 'Destroying: ', $this->first_name, PHP_EOL;
}
}
// We are creating 2 objects here
$obj1 = new Example('Example 1');
$obj2 = new Example('Example 2');
// Objects are made to point to themselves
$obj1->setLink($obj1);
$obj2->setLink($obj2);
// Destroying their global references
$obj1 = null;
$obj2 = null;
// Since both objects are declared null we cannot access them now and hence they must be destroyed
// but since they are not yet destroyed a memory leak may occur as they are still present.
//
// Garbage collector can be called as shown in below line. Uncomment to check its functionality
// gc_collect_cycles();
// Now we create 2 more objects but will not set their references
// only the obj1 and obj2 are pointing to them right now
$obj1 = new Example('Example 3');
$obj2 = new Example('Example 4');
// Removing their global references
$obj1 = null;
$obj2 = null;
// Now the Example 3 and example 4 cannot be accessed due to no references
// for them. Hence the destructor is called automatically
// previous to the execution of next line
echo 'Script has ended', PHP_EOL;
?>Output:
As mentioned in the code, if we uncomment the gc_collect_cycles() function in the center of the script we get the output as below:
Example #4
Code:
<?php
class FileHandle{
private $file_handle;
private $name;
/**
* We declare file handle with parameters file name and mode
* Using parameter string $name as file name
* Using parameter string $fmode as file mode for read, write
*/
public function __construct($name,$fmode){
$this->name = $name;
$this->file_handle = fopen($name, $fmode);
}
/**
* We are closing the file handle
*/
public function __destruct(){
if($this->file_handle){
fclose($this->file_handle);
}
}
/**
* Reading and printing file's content
*/
public function display(){
echo fread($this->file_handle, filesize($this->name));
}
}
$fu = new FileHandle('./test_doc.txt', 'r');
$fu->display();
?>Output:
The following warning is thrown if test_doc.txt is not created.
Advantages of Destructors
- Destructors help in freeing up memory allocation thus making sure the required space is present for newly created objects by the constructor or freeing up resources for any other task.
- Ensures that all the tasks run efficiently since it takes care of the cleanup process.
- In cases where many variables and structures are allocated, the usage of destructors will help prevent memory leak by releasing internal resources.
- It takes care of both Static and local variables.
Limitations of Destructors
- Destructors cannot take any parameters and also they do not give any return value (not even void).
- Inheritance is not permitted through destructors
- It is not mandatory that a destructor will be static
- Referring to an address of a destructor is not possible
- An object which belongs to the class containing the destructor is not allowed to be a union member.
- It is mandatory that a destructor function should have public access.
Conclusion
As we saw, destructors being the exact inverse of constructors are used to destroy an object after its usage is done and not required further in the code. Thus ensuring that it cleans up unwanted resources allowing space for future resources. This is done by declaring the __destruct() function which will be called by PHP automatically at the script end.
Recommended Articles
This is a guide to Destructor in PHP. Here we discuss the working, advantages, and limitations of destructor in PHP along with examples. You may also look at the following articles to learn more –
