Éliminer la duplication de code : un guide pratique des modèles de conception PHP

Modèle de méthode d'usine

Les modèles de conception PHP sont la clé pour améliorer la qualité et la maintenabilité du code. Dans le développement réel, éliminer la duplication de code est une étape cruciale. Cet article de l'éditeur PHP Yuzai vous fournit un guide pratique des modèles de conception PHP pour vous aider à comprendre comment utiliser les modèles de conception pour éliminer efficacement la duplication de code, améliorer la lisibilité et la maintenabilité du code et rendre votre projet plus efficace et plus stable. Que vous soyez débutant en PHP ou développeur expérimenté, cet article vous apportera des astuces et conseils pratiques pour rendre votre code plus élégant et rationalisé.

interface Product
{
public function operation();
}

class ConcreteProductA implements Product
{
public function operation()
{
// ...
}
}

class ConcreteProductB implements Product
{
public function operation()
{
// ...
}
}

class Creator
{
public function factoryMethod(): Product
{
return new ConcreteProductA(); // 可根据需要返回不同的具体产品
}
}

$product = (new Creator())->factoryMethod();
$product->operation();

Modèle de boîtier unique

Le modèle singleton garantit qu'une classe ne peut être instanciée qu'une seule fois. Ceci est utile pour contrôler l’état global ou l’accès aux ressources.

class Singleton
{
private static $instance;

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

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

return self::$instance;
}
}

$instance1 = Singleton::getInstance();
$instance2 = Singleton::getInstance();

if ($instance1 === $instance2) {
// 始终返回同一个实例
}

Mode Stratégie

Le modèle de stratégie définit un ensemble d'algorithmes associés et les rend facilement interchangeables. C'est une bonne pratique lorsque nous devons modifier le comportement de l'algorithme en fonction de différents scénarios.

interface Strategy
{
public function operation();
}

class ConcreteStrategyA implements Strategy
{
public function operation()
{
// ...
}
}

class ConcreteStrategyB implements Strategy
{
public function operation()
{
// ...
}
}

class Context
{
private $strategy;

public function __construct(Strategy $strategy)
{
$this->strategy = $strategy;
}

public function executeStrategy()
{
$this->strategy->operation();
}
}

$context = new Context(new ConcreteStrategyA());
$context->executeStrategy(); // 使用策略 A

$context = new Context(new ConcreteStrategyB());
$context->executeStrategy(); // 使用策略 B

Mode Observateur

Le modèle Observer définit un objet (sujet) qui peut stocker un ensemble d'objets (observateurs) qui en dépendent. Lorsque l'état d'un sujet change, il en informe automatiquement tous les observateurs.

interface Subject
{
public function attach(Observer $observer);
public function detach(Observer $observer);
public function notify();
}

class ConcreteSubject implements Subject
{
private $observers = [];
private $state;

public function attach(Observer $observer)
{
$this->observers[] = $observer;
}

public function detach(Observer $observer)
{
$index = array_search($observer, $this->observers);
if ($index !== false) {
unset($this->observers[$index]);
}
}

public function notify()
{
foreach ($this->observers as $observer) {
$observer->update();
}
}

public function setState($state)
{
$this->state = $state;
$this->notify();
}

public function getState()
{
return $this->state;
}
}

interface Observer
{
public function update();
}

class ConcreteObserver implements Observer
{
private $state;

public function update()
{
// 拉取主题的最新状态
$subject = $this->getSubject();
$this->state = $subject->getState();

// ...
}

protected function getSubject(): Subject
{
// 获取主题的引用（实现可能因具体场景而异）
}
}

$subject = new ConcreteSubject();
$observer1 = new ConcreteObserver();
$observer2 = new ConcreteObserver();

$subject->attach($observer1);
$subject->attach($observer2);

$subject->setState("新状态"); // 通知观察者状态已更改

En adoptant ces modèles de conception, vous pouvez éliminer la duplication de code et améliorer la lisibilité, la maintenabilité et l'évolutivité du code. Ils fournissent des solutions flexibles qui permettent aux développeurs de personnaliser et de réutiliser le code selon différents scénarios.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!