PHP Academy · Lección

Introducción a los métodos mágicos

Aprenda a utilizar __toString, __get, __set y otros métodos mágicos de PHP.

Introducción a los métodos mágicos es una lección gratuita de PHP Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de PHP Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de PHP Academy incluye 4 lecciones en total.

Introducción: métodos mágicos de PHP

Los métodos mágicos son métodos especiales de PHP con prefijos de doble guion bajo que el motor de PHP activa automáticamente en situaciones específicas. Le proporcionan puntos de extensión para controlar el comportamiento de los objetos.

Conceptos fundamentales

Conceptos clave de los métodos mágicos de PHP:

__toString() — conversión de objeto a cadena
__get/__set/__isset/__unset — interceptan el acceso a propiedades
__call/__callStatic — interceptan las llamadas a métodos
__invoke() — objeto invocable

__toString

Ejemplo:

<?php
class Money {
    public function __construct(
        private float  $amount,
        private string $currency
    ) {}

    public function __toString(): string {
        return number_format($this->amount, 2) . ' ' . $this->currency;
    }
}

$price = new Money(9.99, 'USD');
echo $price;            // 9.99 USD
echo 'Price: ' . $price; // Price: 9.99 USD

get y set

Continuación:

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

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

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

$obj = new DynamicObject();
$obj->name = 'Alice';
echo $obj->name;  // Alice

isset y unset

Práctica:

<?php
class Model {
    private array $attributes = [];

    public function __set(string $k, mixed $v): void { $this->attributes[$k] = $v; }
    public function __get(string $k): mixed { return $this->attributes[$k] ?? null; }
    public function __isset(string $k): bool { return isset($this->attributes[$k]); }
    public function __unset(string $k): void { unset($this->attributes[$k]); }
}

$m = new Model();
$m->email = 'a@b.com';
var_dump(isset($m->email));  // true
unset($m->email);
var_dump(isset($m->email));  // false

call y callStatic

En profundidad:

<?php
class FluentQuery {
    private array $clauses = [];

    public function __call(string $name, array $args): static {
        $this->clauses[$name] = $args[0] ?? null;
        return $this;
    }

    public function toSql(): string {
        return 'SELECT * FROM '
            . ($this->clauses['from'] ?? 'unknown');
    }
}

echo (new FluentQuery())->from('users')->toSql();
// SELECT * FROM users

__invoke

Uso avanzado:

<?php
class Multiplier {
    public function __construct(private float $factor) {}

    public function __invoke(float $value): float {
        return $value * $this->factor;
    }
}

$double = new Multiplier(2);
echo $double(5);   // 10
echo $double(21);  // 42

$funcs = [new Multiplier(2), new Multiplier(3)];
foreach ($funcs as $fn) echo $fn(4) . ' '; // 8 12

__clone

Patrón del mundo real:

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

    public function set(string $k, mixed $v): self {
        $this->data[$k] = $v;
        return $this;
    }

    public function __clone() {
        // deep clone nested objects if needed
    }
}

$original = (new Config())->set('theme', 'dark');
$copy = clone $original;  // triggers __clone

__debugInfo

Prácticas recomendadas:

<?php
class ApiClient {
    public function __construct(
        private string $baseUrl,
        private string $apiKey  // sensitive!
    ) {}

    public function __debugInfo(): array {
        return [
            'baseUrl' => $this->baseUrl,
            'apiKey'  => '***' . substr($this->apiKey, -4),  // mask key
        ];
    }
}

var_dump(new ApiClient('https://api.example.com', 'secret123'));
// Shows masked key

Patrón práctico

Aplicación conjunta de los conceptos mediante un patrón práctico para los métodos mágicos de PHP.

Errores comunes

Evite estos errores comunes al trabajar con métodos mágicos de PHP:

Use __toString() para que los objetos se muestren de forma significativa
__get/__set permiten implementar patrones de proxy o decorador
__invoke permite usar objetos como elementos invocables (resulta útil con array_map)
__debugInfo evita que aparezcan datos confidenciales en var_dump

Comprobación rápida

¿Qué método mágico permite invocar un objeto de PHP como si fuera una función?

Repaso: métodos mágicos de PHP

Ha estudiado los métodos mágicos de PHP. Estos son los puntos clave que debe recordar:

Use __toString() para que los objetos se muestren de forma significativa
__get/__set permiten implementar patrones de proxy o decorador
__invoke permite usar objetos como elementos invocables (resulta útil con array_map)
__debugInfo evita que aparezcan datos confidenciales en var_dump

Preguntas frecuentes

¿La lección «Introducción a los métodos mágicos» es gratis?

Sí — el texto completo de «Introducción a los métodos mágicos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de PHP Academy, actualiza a CoddyKit PRO. El curso de PHP Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Introducción a los métodos mágicos»?

Aprenda a utilizar __toString, __get, __set y otros métodos mágicos de PHP. Practicas PHP Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar PHP Academy?

No se requiere experiencia previa. PHP Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Introducción a los métodos mágicos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de PHP Academy?

Sí. Cada lección de PHP Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a PHP Academy