Clases anónimas

Parte de la sección Programación Orientada a Objetos del Journey de PHP de Coddy. Lección 58 de 91.

A veces necesitas un objeto sencillo y puntual sin la sobrecarga de definir una clase completa. Las clases anónimas te permiten crear objetos sobre la marcha, justo donde los necesitas. Son especialmente útiles cuando se combinan con la inyección de dependencias.

Una clase anónima se define usando new class seguido del cuerpo de la clase:

<?php
$logger = new class {
    public function log(string $message): void {
        echo "Log: $message";
    }
};

$logger->log("Hello!");

Salida:

Log: Hello!

Las clases anónimas se vuelven potentes al implementar interfaces. Esto es perfecto para las pruebas o cuando necesitas una implementación rápida sin llenar tu base de código de clases de un solo uso:

<?php
interface Notifier {
    public function send(string $message): string;
}

function notify(Notifier $notifier, string $msg): string {
    return $notifier->send($msg);
}

$result = notify(new class implements Notifier {
    public function send(string $message): string {
        return "Sent: $message";
    }
}, "Test message");

echo $result;

Salida:

Sent: Test message

Las clases anónimas también pueden extender otras clases, usar traits y aceptar argumentos del constructor. Tienen acceso completo a las características de la POO; simplemente se definen en línea en lugar de en un archivo separado. Úsalas cuando una definición de clase completa sería excesiva, pero aún necesites un comportamiento orientado a objetos.

Desafío

Fácil

Construyamos un sistema de formateo de datos que demuestre el poder de las clases anónimas. En lugar de crear archivos de clase independientes para implementaciones simples y de un solo uso, usarás clases anónimas para crear implementaciones rápidas justo donde las necesites.

Organizarás tu código en dos archivos:

FormatterInterface.php: Define una interfaz llamada FormatterInterface con un único método format(string $data): string. Esto establece el contrato que debe seguir cualquier formateador.
main.php: Incluye el archivo de la interfaz y crea una clase DataProcessor que usa la inyección de dependencias para aceptar cualquier formateador. La clase debe:
- Aceptar un FormatterInterface en su constructor
- Tener un método process(string $data) que delegue en el formateador inyectado y devuelva su resultado
Recibirás dos entradas: un tipo de formato ("upper" o "reverse") y una cadena a formatear.

Según el tipo de formato, crea una clase anónima que implemente FormatterInterface:
- Para "upper": el método format() debe devolver los datos convertidos a mayúsculas
- Para "reverse": el método format() debe devolver los datos invertidos
Inyecta tu clase anónima en un DataProcessor, llama a process() con la cadena de entrada e imprime el resultado.

Este enfoque es perfecto cuando necesitas una implementación rápida sin llenar tu base de código de archivos de clase de un solo uso. La clase anónima se crea en línea, implementa la interfaz requerida y se puede pasar a cualquier lugar donde se espere esa interfaz.

Pruébalo tú mismo

<?php
require_once 'FormatterInterface.php';

// TODO: Crea una clase DataProcessor que:
// - Acepta un FormatterInterface en su constructor
// - Tiene un método process(string $data) que delega al formatter

// Leer la entrada
$formatType = trim(fgets(STDIN));
$inputString = trim(fgets(STDIN));

// TODO: Based on $formatType ("upper" or "reverse"), create an anonymous class
// que implementa FormatterInterface
// - Para "upper": format() debe devolver la versión en mayúsculas de los datos
// - Para "reverse": format() debe devolver la versión invertida de los datos

// TODO: Create a DataProcessor with your anonymous class formatter
// Llama a process() con la cadena de entrada e imprime el resultado

?>