Magic methods are special methods (prefixed with __) that PHP calls automatically in response to certain actions on an object — like accessing an undefined property, calling an undefined method, or converting an object to a string. They let you hook into and customize object behavior.
{
{ }
{ }
}
class Container {
private array $data = [];
public function __get($name) { // called on reading an INACCESSIBLE/undefined property
return $this->data[$name] ?? null;
}
public function __set($name, $value) { // called on writing one
$this->data[$name] = $value;
}
public function __isset($name): bool { return isset($this->data[$name]); }
}
$c = new Container();
$c->foo = "bar"; // triggers __set('foo', 'bar')
echo $c->foo; // triggers __get('foo') → "bar"
__get/__set intercept access to properties that don't exist or aren't accessible — enabling dynamic properties (used by ORMs, config objects).
class Api {
public function __call($method, $args) { // called for UNDEFINED method calls
return $this->request($method, $args); // e.g. dynamic API methods
}
public static function __callStatic($method, $args) { /* static version */ }
}
$api->getUsers(); // no getUsers() method → __call('getUsers', [])
__call/__callStatic intercept calls to undefined methods — used for fluent/dynamic APIs (e.g. Laravel's query builder, facades).
class Money {
public function __construct(private float $amount) {}
public function __toString(): string { // when the object is used as a string
return '$' . number_format($this->amount, 2);
}
}
echo new Money(9.5); // "$9.50" — __toString called automatically
class Multiplier {
public function __invoke($x) { return $x * 2; } // makes the object CALLABLE
}
$double = new Multiplier();
$double(5); // 10 — __invoke called
Magic methods are an important PHP feature for customizing object behavior, and understanding them is valuable both for using them appropriately and — especially — for understanding how PHP frameworks achieve their "magic." Methods like __get/__set (dynamic property access), __call/__callStatic (dynamic method handling), __toString (string conversion), and __invoke (callable objects) let objects respond intelligently to operations they don't explicitly define.
This is the mechanism behind much framework convenience: Laravel's Eloquent ORM uses __get/__set for model attributes, its query builder and facades use __call/__callStatic for fluent dynamic methods, and config/collection objects use these throughout.
Recognizing magic methods demystifies how these frameworks work and lets you build similarly flexible APIs.
Knowing the key magic methods, what triggers each, and their common framework uses is practical knowledge for both writing expressive PHP and effectively using/extending the frameworks built on them. (The caveat: magic methods can hurt clarity and IDE support — overusing them makes code harder to understand, so they're best used deliberately for genuine dynamic behavior, not as a default.)