The PHP magic method is an automatically triggered built-in function that responds to specific behaviors in object interactions. They start with a double underscore and are automatically executed in specific scenarios; __construct() is called when the object is created and is used to initialize operations; __destruct() is called before the object is destroyed, which is suitable for cleaning resources; __get() and __set() handle dynamic access to inaccessible properties; __call() and __callStatic() are used to handle undefined instance methods and static method calls respectively; other such as __sleep(), __wakeup(), __toString(), and __invoke() are triggered when serializing, deserializing, object to strings and objects as function calls, respectively. While improving class flexibility, you need to pay attention to moderate use to avoid degradation of code readability.

PHP magic methods are special built-in functions that get triggered automatically when certain actions happen in your code. They're called "magic" because they don't need to be explicitly called — they run behind the scenes based on how you interact with your objects.

These methods always start with double underscores ( __ ), and there are several of them, each serving a specific purpose. Here's a breakdown of some of the most commonly used ones and when they're invoked.

__construct() – When an object is created

This is probably the most familiar one. It runs automatically when you create a new instance of a class.

 class User {
    public function __construct() {
        echo "User created";
    }
}

$user = new User(); // Outputs: User created

You can pass arguments to it when instantiating the object, which makes it useful for setting up initial values ??or dependencies.

__destruct() – When an object is destroyed

This method is called right before an object is destroyed, usually when the script ends or when the object goes out of scope.

 class Logger {
    public function __destruct() {
        echo "Logger closed";
    }
}

$logger = new Logger();
// Outputs: Logger closed (after script finishes)

It's often used for cleanup tasks like closing database connections or file handles.

__get() and __set() – Accessing inaccessible properties

If you try to access or assign a value to a property that isn't accessible (like being private or not defined at all), PHP will look for these methods.

 class Person {
    private $data = [];

    public function __set($name, $value) {
        $this->data[$name] = $value;
    }

    public function __get($name) {
        return $this->data[$name] ?? null;
    }
}

$p = new Person();
$p->name = "Alice";
echo $p->name; // Outputs: Alice

These are super handy for implementing dynamic properties or lazy loading behavior.

__call() and __callStatic() – Calling undefined methods

When you try to call a method that doesn't exist or isn't visible, PHP checks if __call() is defined. Similarly, __callStatic() works for static calls.

 class Math {
    public function __call($method, $args) {
        if (strpos($method, 'power') === 0) {
            return pow($args[0], $args[1]);
        }
    }
}

$m = new Math();
echo $m->powerTwo(2, 3); // Returns 8

This can be used to implement flexible APIs or fallback behaviors.

Other useful ones you might see:

• __sleep() – Before serializing an object
• __wakeup() – After unserializing
• __toString() – When the object is treated as a string (eg, in echo )
• __invoke() – When the object is called like a function

They all help make your classes more flexible and expressive without having to write boilerplate code.

Not every class needs magic methods, but knowing how and when they're triggered give you more control over object behavior. Use them thoughtfully — they're powerful, but can also make code harder to follow if overused.

The above is the detailed content of What are PHP Magic Methods and how are they invoked?. For more information, please follow other related articles on the PHP Chinese website!