Magic methods são métodos especiais (prefixados com __) que o PHP chama automaticamente em resposta a certas ações em um objeto — como acessar uma propriedade indefinida, chamar um método indefinido ou converter um objeto para string. Eles permitem customizar e interceptar o comportamento de objetos.
{
{ }
{ }
}
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 interceptam o acesso a propriedades que não existem ou não são acessíveis — habilitando propriedades dinâmicas (usadas por ORMs, objetos de configuração).
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 interceptam chamadas a métodos indefinidos — usados para APIs fluentes/dinâmicas (ex: query builder do Laravel, 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 são um recurso importante do PHP para customizar o comportamento de objetos, e entendê-los é valioso tanto para usá-los apropriadamente quanto — especialmente — para compreender como frameworks PHP alcançam sua "magic". Métodos como __get/__set (acesso dinâmico a propriedades), __call/__callStatic (manipulação dinâmica de métodos), __toString (conversão para string) e __invoke (objetos callable) permitem que objetos respondam inteligentemente a operações que não definem explicitamente.
Este é o mecanismo por trás de muita conveniência em frameworks: Eloquent ORM do Laravel usa __get/__set para atributos de modelo, seu query builder e facades usam __call/__callStatic para métodos dinâmicos fluentes, e objetos de config/collection usam esses métodos em toda a framework.
Reconhecer magic methods desmistifica como esses frameworks funcionam e permite construir APIs similarmente flexíveis.
Conhecer os key magic methods, o que dispara cada um e seus usos comuns em frameworks é conhecimento prático tanto para escrever PHP expressivo quanto para usar/estender efetivamente os frameworks construídos sobre eles. (A ressalva: magic methods podem prejudicar a clareza e o suporte de IDE — usá-los excessivamente torna o código mais difícil de entender, então são melhores usados deliberadamente para comportamento genuinamente dinâmico, não como padrão.)