The magic method in PHP is to handle special built-in functions for common object-oriented tasks, which start with a double underscore (__), which improves code flexibility by automatically performing specific actions. __construct is used to initialize properties or run setting code when object creation, supports parameter passing, and uses the default constructor if undefined; __get and __set are used to dynamically access or assign private or non-existent properties, suitable for implementing delayed loading or fallback logic, but attention should be paid to debugging complexity and necessary verification; __toString allows objects to return string representations, which is convenient for debugging or outputting readable information, and must return string types to avoid errors.

Magic methods in PHP are special built-in functions that start with double underscores ( __ ) and provide a way to handle common object-oriented tasks automatically. They're not actual magic, but they sure act like it when you're working with objects and want things to happen behind the scenes.

Here's how some of the most commonly used ones work and why they're useful.

__construct – Setting Things Up When an Object Is Created

This is probably the most widely used magic method. It's your go-to for initializing properties or running setup code as soon as a new instance of a class is created.

For example:

 class User {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }
}

Now every time you do new User('Alice') , the name gets set without having to call a separate method.

• Think of it like setting default values ??or connecting to a database right when the object is born.
• You can pass arguments to it just like any other method.
• If you don't define one, PHP uses a default constructor (which does nothing).

__get and __set – Handling Undefined or Private Properties Gracefully

These two let you control what happens when someone tries to access or assign a value to a property that doesn't exist or is inaccessible.

Say you have a class where you want to allow dynamic property access but still keep some control:

 class Data {
    private $values ??= [];

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

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

So now:

 $data = new Data();
$data->age = 30;
echo $data->age; // Outputs: 30

• These methods are great for implementing lazy loading or fallback logic.
• But be careful — using them too much can make debugging harder because it hides how data is stored.
• Always pairs them with proper validation if needed.

__toString – Make Your Objects Output Like Strings

If you try to echo an object directly in PHP, you'll get an error unless that object has a __toString() method defined.

This method lets you return a string representation of the object:

 class Product {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function __toString() {
        return "Product: " . $this->name;
    }
}

Now:

 $product = new Product("Chair");
echo $product; // Outputs: Product: Chair

• Useful for debugging or displaying readable info about the object.
• Must return a string — returning anything else will cause an error.

There are also others like __call , __clone , __sleep , etc., each with their own use cases. But these three ( __construct , __get , __set ) are the ones you'll likely run into first.

They're powerful tools, especially when building flexible classes or frameworks, but like all tools, they should be used thoughtfully.

Basically that's it.

The above is the detailed content of What are Magic Methods in PHP (e.g., `__construct`, `__get`, `__set`)?. For more information, please follow other related articles on the PHP Chinese website!