Métodos mágicos

PHP reserva los nombres de método que empiezan con dos guiones bajos como métodos mágicos — ganchos que el motor llama automáticamente en situaciones específicas, en lugar de ser llamados directamente por tu código.

__construct y __destruct

<?php
class DatabaseConnection {
    public function __construct() {
        echo "Connecting...\n";
    }

    public function __destruct() {
        echo "Closing connection.\n";
    }
}

$db = new DatabaseConnection();

__construct() (ya cubierto) se ejecuta al crear el objeto; __destruct() se ejecuta automáticamente cuando un objeto es recolectado por el recolector de basura — típicamente al final del script, o antes si nada más lo referencia. Es más útil para liberar un recurso externo (un manejador de archivo, una conexión de red) de forma determinista, en lugar de esperar a que el script simplemente termine.

__toString: controlando la conversión a string

<?php
class Money {
    public function __construct(private int $cents) {}

    public function __toString(): string {
        return number_format($this->cents / 100, 2);
    }
}

$price = new Money(1999);
echo "Price: $price"; // "Price: 19.99"

Sin __toString(), intentar usar un objeto donde se espera un string (como dentro de echo o interpolación de strings) lanza un error. Definirlo permite que un objeto participe con naturalidad en contextos de string, razón por la cual las clases que representan un valor (dinero, una fecha, una URL) suelen implementarlo.

__get y __set: interceptando el acceso a propiedades

<?php
class Config {
    private array $data = [];

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

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

$config = new Config();
$config->timeout = 30;   // triggers __set
echo $config->timeout;   // triggers __get, prints 30

__get() y __set() se disparan automáticamente cuando el código accede a una propiedad que en realidad no está declarada (o no es accesible) en el objeto — aquí, Config no tiene una propiedad timeout real, pero los métodos mágicos hacen que se comporte como si la tuviera, respaldada por el array privado $data. Esto sustenta cómo algunos frameworks implementan objetos de configuración o modelos flexibles y de apariencia dinámica.

__call: interceptando llamadas a métodos

<?php
class ApiClient {
    public function __call($name, $arguments) {
        echo "Calling method '$name' with: " . implode(", ", $arguments);
    }
}

$client = new ApiClient();
$client->getUser(42); // "Calling method 'getUser' with: 42"

__call() se dispara cuando el código llama a un método que no existe en el objeto. Los frameworks usan esto para construir APIs fluidas y de apariencia dinámica (como un constructor de consultas que parece tener un método para cada columna posible de la base de datos) sin escribir a mano cada posible nombre de método de antemano.

Una palabra de precaución

Los métodos mágicos son poderosos, pero hacen que el código sea más difícil de rastrear — un IDE no puede "ir a la definición" de una propiedad o método que solo existe a través de __get/__call, y un error tipográfico cae silenciosamente en el método mágico en lugar de lanzar un claro error de "método no encontrado". Recurre a ellos cuando construyas una librería o una abstracción a nivel de framework; para el código de aplicación cotidiano, una propiedad o método declarado explícitamente casi siempre es más claro.