Utilisez-vous des modèles de conception dans votre…

Oui, je les utilise. Ils aident à résoudre des tâches courantes, à améliorer la structure du code, sa lisibilité et sa maintenabilité.

Les principaux modèles que j'applique:

Créatifs:
- Singleton: Pour limiter la classe à une seule instance.
- Factory Method: Pour créer des objets sans spécifier la classe concrète.
- Abstract Factory: Pour créer des familles d'objets liés.
- Builder: Pour créer des objets complexes étape par étape.
Structurels:
- Adapter: Pour la compatibilité des interfaces.
- Decorator: Pour ajouter dynamiquement un comportement à un objet.
- Facade: Pour fournir une interface unifiée à un sous-système.
- Proxy: Pour contrôler l'accès à un objet.
Comportementaux:
- Observer: Pour implémenter un mécanisme d'abonnement et de notification.
- Strategy: Pour définir une famille d'algorithmes et les rendre interchangeables.
- Template Method: Pour définir le squelette d'un algorithme dans une classe de base.
- Command: Pour encapsuler une requête en tant qu'objet.

Par exemple, j'utilise souvent Singleton pour travailler avec des bases de données:

<?php
// Database.php
class Database {
    private static ?Database $instance = null;
    private ?PDO $pdo = null;

    private function __construct() {
        // Configuration de la connexion à la BD
        $dsn = 'mysql:host=localhost;dbname=mydatabase;charset=utf8';
        $user = 'myuser';
        $password = 'mypassword';

        try {
            $this->pdo = new PDO($dsn, $user, $password);
            $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
        } catch (\PDOException $e) {
            throw new \PDOException($e->getMessage(), (int)$e->getCode());
        }
    }

    public static function getInstance(): self {
        if (self::$instance === null) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    public function getConnection(): ?PDO {
        return $this->pdo;
    }

    private function __clone() {}
    public function __wakeup() {}
}

Et j'applique Factory Method pour créer différents types de messages ou d'objets en fonction des données d'entrée.

<?php
// MessageFactory.php
interface Message {
    public function send(): string;
}

class EmailMessage implements Message {
    public function send(): string {
        return "Envoi d'email...";
    }
}

class SmsMessage implements Message {
    public function send(): string {
        return "Envoi de SMS...";
    }
}

class MessageFactory {
    public function createMessage(string $type): Message {
        switch ($type) {
            case 'email':
                return new EmailMessage();
            case 'sms':
                return new SmsMessage();
            default:
                throw new InvalidArgumentException("Type de message inconnu.");
        }
    }
}

// Utilisation:
// $factory = new MessageFactory();
// $email = $factory->createMessage('email');
// echo $email->send(); // Affichera "Envoi d'email..."

Le choix du modèle dépend de la tâche spécifique et du contexte. L'essentiel est de ne pas les utiliser simplement pour les utiliser, mais de comprendre quand ils sont réellement nécessaires pour améliorer le code.

Utilisez-vous des modèles de conception dans votre pratique?