• +91-9142290450

  • Hajipur, Bihar, 844101

☰
❮
❯

PHP Destructor

← Previous Next →

In PHP, destructors are special methods that automatically execute when an object is destroyed or goes out of scope. Destructors are primarily used for cleaning up resources, such as closing database connections, releasing files, or performing final tasks before the object is removed from memory. Understanding destructors helps ensure efficient resource management in Object-Oriented PHP applications.

What is a Destructor?

A destructor is a method inside a class that runs automatically at the end of the object’s lifecycle. In PHP, destructors are defined using the __destruct() method.

Key points about destructors:

  • They are automatically called when an object is destroyed.

  • They do not accept parameters.

  • A class can have only one destructor.

  • Destructors are useful for releasing resources and performing cleanup tasks.

Basic Example of a Destructor

class FileHandler {
    public function __construct() {
        echo "File opened.<br>";
    }

    public function __destruct() {
        echo "File closed.<br>";
    }
}

$file = new FileHandler();

Output:

File opened.
File closed.

Here, the constructor runs first when the object is created, and the destructor automatically runs when the object goes out of scope or the script ends.

Destructor in Object Scope

Destructors are automatically called when an object is unset or goes out of scope:

class Logger {
    public function __construct() {
        echo "Logger initialized.<br>";
    }

    public function __destruct() {
        echo "Logger destroyed.<br>";
    }
}

function createLogger() {
    $log = new Logger();
}

createLogger(); // Logger object destroyed when function ends

Here, the Logger object is destroyed as soon as the createLogger() function finishes execution.

Using Destructors for Resource Cleanup

Destructors are particularly useful when working with files, database connections, or external resources:

class Database {
    private $connection;

    public function __construct($host, $user, $pass, $db) {
        $this->connection = new mysqli($host, $user, $pass, $db);
        if ($this->connection->connect_error) {
            die("Connection failed: " . $this->connection->connect_error);
        }
        echo "Database connected.<br>";
    }

    public function __destruct() {
        $this->connection->close();
        echo "Database connection closed.<br>";
    }
}

$db = new Database("localhost", "root", "", "test_db");

When the script ends, the destructor closes the database connection, ensuring no resources remain open unnecessarily.

Destructor in Inheritance

When a class extends another class, destructors of parent classes are automatically called after the child destructor runs.

Example:

class ParentClass {
    public function __destruct() {
        echo "Parent destructor called.<br>";
    }
}

class ChildClass extends ParentClass {
    public function __destruct() {
        echo "Child destructor called.<br>";
        parent::__destruct();
    }
}

$obj = new ChildClass();

Output:

Child destructor called.
Parent destructor called.

Calling parent::__destruct() explicitly ensures that the parent class cleanup is executed.

Multiple Objects and Destructors

Destructors are executed for each object when they are destroyed:

class Demo {
    private $name;

    public function __construct($name) {
        $this->name = $name;
        echo "Object $name created.<br>";
    }

    public function __destruct() {
        echo "Object $this->name destroyed.<br>";
    }
}

$a = new Demo("A");
$b = new Demo("B");

unset($a); // Only A is destroyed
// B will be destroyed automatically when the script ends

Output:

Object A created.
Object B created.
Object A destroyed.
Object B destroyed.

Best Practices for Destructors

  1. Use destructors only for cleanup – avoid heavy operations or long-running tasks.

  2. Close resources like files, database connections, and network sockets.

  3. Avoid performing business logic in destructors; keep them for cleanup only.

  4. Call parent destructors explicitly in inheritance if needed.

  5. Do not rely on destructors for critical logic, as the exact timing of destructor execution can vary.

Common Mistakes

  • Assuming destructors run immediately after unsetting an object; they actually run at the end of the object’s lifecycle or script execution.

  • Performing database inserts or updates in destructors; this can lead to unpredictable behavior.

  • Forgetting to release resources in destructors, causing memory leaks.

Summary of the Tutorial

  • Destructors are special methods that execute automatically when an object is destroyed or goes out of scope.

  • They are defined using __destruct() and do not accept parameters.

  • Destructors are commonly used to release resources like files, database connections, or network sockets.

  • In inheritance, child destructors run first, and parent destructors can be called explicitly.

  • Following best practices ensures efficient resource management and prevents memory leaks.

Understanding destructors is crucial for writing robust PHP applications, especially when working with resources that need proper cleanup.

Practice Questions

  1. Create a class FileHandler with a constructor that opens a file and a destructor that closes it. Demonstrate how the destructor runs automatically.

  2. Write a PHP program to create a class Logger that prints a message in the constructor and a different message in the destructor. Instantiate the object inside a function and observe when the destructor runs.

  3. Create a class Database that connects to MySQL in the constructor and closes the connection in the destructor. Test it by creating multiple objects.

  4. Write a class SessionManager with a constructor that starts a session and a destructor that destroys it. Instantiate the class and observe the behavior.

  5. Create two classes, ParentClass and ChildClass. Give both a destructor that prints a message. Instantiate ChildClass and observe the order of destructor execution.

  6. Write a PHP program with a class ResourceHandler that allocates a memory resource in the constructor and frees it in the destructor. Demonstrate the automatic cleanup.

  7. Create a class TempFile with a constructor that creates a temporary file and a destructor that deletes it. Instantiate the object and observe the file lifecycle.

  8. Write a class NetworkConnection with a constructor that simulates opening a connection and a destructor that closes it. Instantiate multiple objects to observe destructors for each.

  9. Create a class Cache with a constructor that stores data in an array and a destructor that clears the array. Demonstrate how the destructor ensures no leftover data remains.

  10. Write a class Printer with a constructor that prints a starting message and a destructor that prints an ending message. Create multiple objects in different scopes to observe when destructors run.

← Previous Next →

Try a Short Quiz.

coding learning websites codepractice

No quizzes available.

PHP

online coding class codepractice

PHP Basics

PHP Data

Control Flow

PHP Functions

PHP Arrays

PHP Forms

PHP Advanced

Cookies & Sessions

Filters & JSON

PHP Exceptions

PHP OOP

MySQL with PHP

PHP and XML

AJAX with PHP

codepractice logo
Login
Go Back Top