¿Qué son los métodos mágicos de PHP?

Question

IT Interview Practice · Accepted Answer

**Los métodos mágicos** son métodos especiales (prefijados con `__`) que PHP llama automáticamente en respuesta a ciertas acciones en un objeto — como acceder a una propiedad indefinida, llamar a un método indefinido, o convertir un objeto a una cadena. Te permiten engancharte en y personalizar el comportamiento del objeto.

## Por qué es importante

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

## Sobrecarga de propiedades: __get y __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` interceptan el acceso a propiedades que no existen o no son accesibles — permitiendo propiedades dinámicas (utilizadas por ORMs, objetos de configuración).

## Sobrecarga de métodos: __call y __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` interceptan llamadas a métodos indefinidos — utilizados para APIs fluidas/dinámicas (p. ej. el constructor de consultas de 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 qué es importante

Los métodos mágicos son una característica importante de PHP para personalizar el comportamiento del objeto, y comprenderlos es valioso tanto para usarlos apropiadamente como — especialmente — para entender cómo los frameworks de PHP logran su "magia". Métodos como `__get`/`__set` (acceso dinámico a propiedades), `__call`/`__callStatic` (manejo dinámico de métodos), `__toString` (conversión a cadena), e `__invoke` (objetos invocables) permiten que los objetos respondan inteligentemente a operaciones que no definen explícitamente.

Este es el mecanismo detrás de gran parte de la conveniencia del framework: **Eloquent ORM de Laravel** utiliza `__get`/`__set` para atributos de modelos, su **constructor de consultas y facades** utilizan `__call`/`__callStatic` para métodos dinámicos fluidos, y los objetos de configuración/colección utilizan estos en toda la aplicación.

Reconocer métodos mágicos desmitifica cómo funcionan estos frameworks y te permite construir APIs igualmente flexibles.

Conocer los métodos mágicos clave, qué desencadena cada uno, y sus usos comunes en frameworks es un conocimiento práctico tanto para escribir PHP expresivo como para usar/extender efectivamente los frameworks construidos sobre ellos. (La salvedad: los métodos mágicos pueden afectar la claridad y el soporte del IDE — usarlos en exceso hace que el código sea más difícil de entender, por lo que se utilizan mejor deliberadamente para un comportamiento dinámico genuino, no como predeterminado.)

¿Qué son los métodos mágicos de PHP?

Por qué es importante

Sobrecarga de propiedades: get y set

Sobrecarga de métodos: call y callStatic

toString e invoke

Por qué es importante

Preguntas relacionadas