Classi anonime

Fa parte della sezione Programmazione orientata agli oggetti del percorso PHP di Coddy. Lezione 58 di 91.

A volte hai bisogno di un oggetto semplice e occasionale senza il sovraccarico di definire una classe completa. Le classi anonime ti permettono di creare oggetti al volo, proprio dove ti servono. Sono particolarmente utili se combinate con l'iniezione delle dipendenze.

Una classe anonima si definisce usando new class seguito dal corpo della classe:

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

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

Output:

Log: Hello!

Le classi anonime diventano potenti quando implementano interfacce. Sono perfette per i test o quando ti serve un'implementazione rapida senza ingombrare la tua codebase con classi monouso:

<?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;

Output:

Sent: Test message

Le classi anonime possono anche estendere altre classi, usare i trait e accettare argomenti del costruttore. Hanno pieno accesso alle funzionalità della programmazione orientata agli oggetti: sono semplicemente definite direttamente nel codice anziché in un file separato. Usale quando una definizione di classe completa sarebbe eccessiva, ma hai comunque bisogno di un comportamento orientato agli oggetti.

Sfida

Facile

Costruiamo un sistema di formattazione dei dati che dimostri la potenza delle classi anonime. Invece di creare file di classe separati per implementazioni semplici e usate una sola volta, userai classi anonime per creare rapidamente le implementazioni proprio dove ti servono.

Organizzerai il codice in due file:

FormatterInterface.php: Definisci un'interfaccia chiamata FormatterInterface con un unico metodo format(string $data): string. Questo stabilisce il contratto che ogni formattatore deve rispettare.
main.php: Includi il file dell'interfaccia e crea una classe DataProcessor che utilizzi l'iniezione delle dipendenze per accettare qualsiasi formattatore. La classe dovrebbe:
- Accettare un FormatterInterface nel costruttore
- Avere un metodo process(string $data) che delega il lavoro al formattatore iniettato e ne restituisce il risultato
Riceverai due input: un tipo di formattazione ("upper" o "reverse") e una stringa da formattare.

In base al tipo di formattazione, crea una classe anonima che implementi FormatterInterface:
- Per "upper": il metodo format() dovrebbe restituire i dati convertiti in maiuscolo
- Per "reverse": il metodo format() dovrebbe restituire i dati invertiti
Inietta la tua classe anonima in un DataProcessor, chiama process() con la stringa di input e stampa il risultato.

Questo approccio è perfetto quando ti serve un'implementazione rapida senza appesantire la tua base di codice con file di classi usate una sola volta. La classe anonima viene creata direttamente sul posto, implementa l'interfaccia richiesta e può essere passata ovunque sia prevista quell'interfaccia.

Provalo tu

<?php
require_once 'FormatterInterface.php';

// TODO: Crea una classe DataProcessor che:
// - Accetti un FormatterInterface nel suo costruttore
// - Abbia un metodo process(string $data) che deleghi la gestione al formatter

// Leggi l'input
$formatType = trim(fgets(STDIN));
$inputString = trim(fgets(STDIN));

// TODO: In base a $formatType ("upper" o "reverse"), crea una classe anonima
// che implementi FormatterInterface
// - Per "upper": format() deve restituire i dati in maiuscolo
// - Per "reverse": format() deve restituire i dati in ordine inverso

// TODO: Crea un DataProcessor con il formatter della tua classe anonima
// Chiama process() con la stringa di input e stampa il risultato

?>