O que são magic methods em PHP?

Question

IT Interview Practice · Accepted Answer

**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.

## O construtor e métodos comuns de ciclo de vida

```php
<?php
class User {
    public function __construct(string $name) { /* runs on `new User(...)` */ }
    public function __destruct() { /* runs when the object is destroyed */ }
}
```

## Property overloading: __get e __set

```php
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).

## Method overloading: __call e __callStatic

```php
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).

## __toString e __invoke

```php
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
```

## Por que isso importa

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.)

O que são magic methods em PHP?

O construtor e métodos comuns de ciclo de vida

Property overloading: get e set

Method overloading: call e callStatic

toString e invoke

Por que isso importa

Perguntas relacionadas