Clases anónimas en PHP: qué son y cuándo usarlas

Hola, ¿cómo están? Continuando con el curso de PHP, hoy veremos las clases anónimas. Son el equivalente en el mundo de los objetos a las funciones anónimas que vimos hace unas lecciones.

¡Empecemos!

Qué es una clase anónima

Una clase anónima es una clase sin nombre que se declara y se instancia en el mismo momento. No se puede reutilizar en otro lugar, porque no hay forma de referirse a ella.

<?php
$objeto = new class {
    public function saludar(): string
    {
        return "Hola desde una clase anónima";
    }
};

echo $objeto->saludar();

Fíjate en la estructura: new class { seguido del cuerpo, y punto y coma al final porque es una asignación.

Para qué sirven

La pregunta razonable es: si tengo clases normales, ¿para qué querría una sin nombre?

La respuesta es la misma que con las funciones anónimas: cuando necesitas un objeto una sola vez y ponerle nombre sería ruido. Si la clase solo se usa en un punto del programa, declararla arriba del archivo la separa de donde realmente importa.

Pasar parámetros

Una clase anónima puede tener constructor, y se le pasan los argumentos en el mismo new:

<?php
$conexion = new class("localhost", 3306) {
    public function __construct(
        private string $host,
        private int $puerto,
    ) {}

    public function describir(): string
    {
        return "Conectando a {$this->host}:{$this->puerto}";
    }
};

echo $conexion->describir();   // Conectando a localhost:3306

Extender una clase

Las clases anónimas pueden heredar igual que cualquier otra:

<?php
class Logger
{
    public function registrar(string $mensaje): void
    {
        echo "[LOG] $mensaje\n";
    }
}

$loggerSilencioso = new class extends Logger {
    public function registrar(string $mensaje): void
    {
        // no hace nada
    }
};

$loggerSilencioso->registrar("Esto no se imprime");

Este caso —crear una versión que no hace nada— es habitual en pruebas, cuando quieres desactivar un comportamiento sin tocar el código original.

Implementar una interfaz

Este es probablemente su uso más frecuente. Veremos las interfaces en detalle más adelante, pero adelanto el ejemplo porque es donde las clases anónimas brillan:

<?php
interface Notificador
{
    public function enviar(string $mensaje): void;
}

function procesarPedido(Notificador $notificador): void
{
    // ... lógica del pedido
    $notificador->enviar("Pedido procesado");
}

// Un notificador de prueba, creado al vuelo
procesarPedido(new class implements Notificador {
    public function enviar(string $mensaje): void
    {
        echo "Simulando envío: $mensaje";
    }
});

Sin clases anónimas tendrías que crear un archivo con una clase NotificadorDePrueba que se usa una sola vez.

Usar variables del exterior

A diferencia de las funciones anónimas, una clase anónima no captura automáticamente las variables de fuera. Hay que pasárselas por el constructor:

<?php
$prefijo = "AVISO";

$logger = new class($prefijo) {
    public function __construct(private string $prefijo) {}

    public function registrar(string $mensaje): void
    {
        echo "[{$this->prefijo}] $mensaje";
    }
};

$logger->registrar("Sistema iniciado");   // [AVISO] Sistema iniciado

Un detalle importante: cada una es distinta

Si creas dos clases anónimas idénticas, PHP las considera tipos diferentes:

<?php
$a = new class {};
$b = new class {};

var_dump($a instanceof $b);   // false

Por eso no sirven cuando necesitas crear varios objetos del mismo tipo. Para eso, una clase normal.

Cuándo usarlas y cuándo no

Sí conviene:

• Implementar una interfaz para un caso puntual.
• Crear objetos falsos o simulados en pruebas.
• Configuración que se usa en un solo lugar.
• Reemplazar el comportamiento de una clase de forma temporal.

No conviene:

• Si vas a necesitar el mismo tipo en más de un sitio.
• Si la clase tiene mucha lógica: se vuelve ilegible embutida dentro de otra instrucción.
• Solo por evitar crear un archivo. Una clase con nombre siempre se lee mejor.

La regla práctica: si al escribirla te cuesta encontrar dónde empieza y dónde termina, debería ser una clase con nombre.

Un ejemplo práctico

Supongamos que tienes una función que envía reportes y quieres probarla sin que envíe correos de verdad:

<?php
declare(strict_types=1);

interface EnviadorDeCorreo
{
    public function enviar(string $destino, string $asunto): bool;
}

class GeneradorDeReportes
{
    public function __construct(
        private EnviadorDeCorreo $enviador,
    ) {}

    public function enviarReporteMensual(string $destino): bool
    {
        $asunto = "Reporte de " . date("F Y");
        return $this->enviador->enviar($destino, $asunto);
    }
}

// En pruebas, sin tocar el servidor de correo:
$generador = new GeneradorDeReportes(
    new class implements EnviadorDeCorreo {
        public function enviar(string $destino, string $asunto): bool
        {
            echo "Simulado: '$asunto' hacia $destino\n";
            return true;
        }
    }
);

$generador->enviarReporteMensual("gerencia@empresa.com");

En producción pasarías el enviador real; en pruebas, este anónimo. La clase GeneradorDeReportes no cambia ni una línea.

Errores comunes

• Olvidar el punto y coma al final de la asignación.
• Esperar que capture variables como hacen las closures. Hay que pasarlas por constructor.
• Usarlas para lógica compleja. El código se vuelve difícil de leer muy rápido.
• Intentar comparar tipos entre dos anónimas distintas.

Para cerrar

Las clases anónimas son una herramienta puntual, no algo que vayas a usar todos los días. Su lugar natural son las pruebas y las implementaciones de interfaz de un solo uso.

Si te llevas una idea: existen para los casos en que ponerle nombre a la clase no aporta nada. En cualquier otro caso, ponle nombre.

En la siguiente lección veremos cómo recorrer objetos con foreach.

Saludos y éxitos.