Gebruikt u ontwerppatronen in uw praktijk?

Ja, ik gebruik ze. Ze helpen bij het oplossen van typische taken, het verbeteren van de structuur van de code, de leesbaarheid en onderhoudbaarheid.

De belangrijkste patronen die ik toepas:

• Creational patterns:
  • Singleton: Om de klasse tot één instantie te beperken.
  • Factory Method: Om objecten te maken zonder de concrete klasse aan te geven.
  • Abstract Factory: Om gerelateerde objectfamilies te creëren.
  • Builder: Om complexe objecten stapsgewijs te maken.
• Structurele patterns:
  • Adapter: Voor compatibiliteit van interfaces.
  • Decorator: Om gedrag dynamisch aan een object toe te voegen.
  • Facade: Om een eenduidige interface aan een subsysteem te bieden.
  • Proxy: Om toegang tot een object te beheren.
• Gedragspatterns:
  • Observer: Om een abonnements- en notificatiemechanisme te implementeren.
  • Strategy: Om een familie van algoritmen te definiëren en uitwisselbaar te maken.
  • Template Method: Om het skelet van een algoritme in een basisklasse te definiëren.
  • Command: Om een verzoek als een object te encapsuleren.

Bijvoorbeeld, ik gebruik vaak Singleton voor het werken met databases:

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

    private function __construct() {
        // Database connectie configuratie
        $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() {}
}

En ik kan de Factory Method gebruiken om verschillende typen berichten of objecten te maken afhankelijk van de invoergegevens:

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

class EmailMessage implements Message {
    public function send(): string {
        return "E-mail verzenden...";
    }
}

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

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

// Gebruik:
// $factory = new MessageFactory();
// $email = $factory->createMessage('email');
// echo $email->send(); // Zal "E-mail verzenden..." tonen

De keuze van het patroon hangt af van de specifieke taak en context. Het belangrijkste is dat je ze niet alleen gebruikt omdat je ze kent, maar dat je begrijpt wanneer ze echt nodig zijn om de code te verbeteren.