Patrons comportementaux : stratégie, observateur, commande
Modélisez les comportements et les communications avec des patrons comportementaux.
Patrons comportementaux : stratégie, observateur, commande est une leçon PHP Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage PHP Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours PHP Academy comprend 4 leçons au total.
Modéliser le comportement
Les patrons comportementaux régissent la manière dont les objets collaborent et répartissent les responsabilités. Nous nous concentrons sur trois patrons omniprésents dans les systèmes PHP réels :
- Stratégie — remplacer un algorithme à l’exécution.
- Observer — diffuser des événements aux écouteurs intéressés.
- Command — transformer une requête en objet que vous pouvez mettre en file, journaliser ou annuler.
Stratégie : l’idée
Le patron de la Stratégie définit une famille d’algorithmes interchangeables derrière une seule interface et permet au client de choisir à l’exécution. Il remplace le switch volumineux ci-dessous par du polymorphisme : le contexte délègue à la stratégie qu’il contient.
<?php
// The smell Strategy removes: branching on a type code
function price(string $type, float $base): float {
switch ($type) {
case 'standard': return $base + 5;
case 'express': return $base + 15;
default: throw new InvalidArgumentException($type);
}
}
echo price('express', 10), PHP_EOL; // 25
Stratégie dans le code
Ici, le coût d’expédition dépend du transporteur choisi. Chaque stratégie encapsule un algorithme de tarification ; le contexte reste inchangé lorsque vous ajoutez un transporteur.
<?php
interface ShippingStrategy { public function cost(float $weight): float; }
final class Standard implements ShippingStrategy {
public function cost(float $w): float { return 5 + $w * 0.5; }
}
final class Express implements ShippingStrategy {
public function cost(float $w): float { return 15 + $w * 1.2; }
}
final class Cart {
public function __construct(private ShippingStrategy $strategy) {}
public function setStrategy(ShippingStrategy $s): void { $this->strategy = $s; }
public function quote(float $weight): float { return $this->strategy->cost($weight); }
}
$cart = new Cart(new Standard());
echo $cart->quote(10), PHP_EOL; // 10
$cart->setStrategy(new Express());
echo $cart->quote(10), PHP_EOL; // 27
Stratégie avec des fermetures
En PHP, une stratégie n’a pas toujours besoin d’une classe. Pour les cas légers, un callable ou la syntaxe des fonctions appelables de première classe constitue une stratégie parfaitement valide. Utilisez des classes complètes lorsque l’algorithme possède son propre état ou ses propres dépendances ; utilisez des fermetures pour les choix simples et sans état.
<?php
$strategies = [
'asc' => fn(array $a) => sort($a) ? $a : $a,
'desc' => fn(array $a) => rsort($a) ? $a : $a,
];
$data = [3, 1, 2];
print_r($strategies['desc']($data)); // [3,2,1]
Observer : l’idée
Le patron Observer permet à un sujet de notifier de nombreux observateurs lorsque son état change, sans savoir qui ils sont. Cela découple la source d’un événement de ses gestionnaires et constitue le fondement des systèmes d’événements, des points d’accroche et des mises à jour réactives.
Observer dans le code
Le sujet conserve une liste d’observateurs et appelle update() sur chacun d’eux. De nouveaux écouteurs peuvent s’enregistrer sans modifier la logique du sujet.
<?php
interface Observer { public function update(string $event): void; }
final class OrderSubject {
private array $observers = [];
public function subscribe(Observer $o): void { $this->observers[] = $o; }
public function placed(string $id): void {
foreach ($this->observers as $o) { $o->update("order $id placed"); }
}
}
final class EmailObserver implements Observer {
public function update(string $e): void { echo "email: $e" . PHP_EOL; }
}
final class AuditObserver implements Observer {
public function update(string $e): void { echo "audit: $e" . PHP_EOL; }
}
$subject = new OrderSubject();
$subject->subscribe(new EmailObserver());
$subject->subscribe(new AuditObserver());
$subject->placed('42');
Observer ou PSR-14
En PHP moderne, le patron Observer s’exprime souvent au moyen de répartiteurs d’événements PSR-14 : un répartiteur achemine un objet événement vers les écouteurs enregistrés. Le modèle mental est le même (sujet = événement, observateurs = écouteurs), mais un répartiteur les découple davantage et prend en charge les événements pouvant être interrompus. SplObserver/SplSubject existent dans la SPL, mais sont rarement utilisés aujourd’hui.
Command : l’idée
Le patron Command encapsule une requête sous forme d’objet : l’action, son récepteur et ses paramètres. Comme la requête est désormais une donnée, vous pouvez la mettre en file, la journaliser, la réessayer ou l’annuler. La commande la plus simple représente une intention sous forme de valeur, comme indiqué ci-dessous.
<?php
final class SendEmail {
public function __construct(
public readonly string $to,
public readonly string $subject
) {}
}
// The request is now data you can store, serialize, or enqueue
$cmd = new SendEmail('user@example.com', 'Welcome');
echo json_encode($cmd), PHP_EOL;
Command dans le code
Chaque commande implémente execute(). Un invocateur les conserve et les exécute, indépendamment de ce qu’elles font. L’ajout de undo() transforme cela en véritable pile d’annulation.
<?php
interface Command { public function execute(): string; }
final class Light { public bool $on = false; }
final class TurnOn implements Command {
public function __construct(private Light $light) {}
public function execute(): string { $this->light->on = true; return 'light on'; }
}
final class TurnOff implements Command {
public function __construct(private Light $light) {}
public function execute(): string { $this->light->on = false; return 'light off'; }
}
final class Invoker {
private array $queue = [];
public function add(Command $c): void { $this->queue[] = $c; }
public function run(): void {
foreach ($this->queue as $c) { echo $c->execute(), PHP_EOL; }
}
}
$light = new Light();
$inv = new Invoker();
$inv->add(new TurnOn($light));
$inv->add(new TurnOff($light));
$inv->run();
Bus de commandes
Les cadres applicatifs construisent un bus de commandes sur ce patron : un objet de transfert de données de commande est distribué à un seul gestionnaire. L’intergiciel placé autour du bus peut ajouter uniformément des transactions, de la validation et de la journalisation. Comme les commandes sont de simples objets sérialisables, le même gestionnaire peut s’exécuter de manière synchrone ou être placé dans une file traitée par un processus dédié.
Choisir entre ces patrons
- Stratégie : une opération, plusieurs algorithmes interchangeables, choisis par l’appelant.
- Observer : un événement, plusieurs réactions indépendantes ; la source ne connaît pas les gestionnaires.
- Command : représenter une requête sous forme d’objet afin de pouvoir la mettre en file, la journaliser, la réessayer ou l’annuler.
Ils se combinent bien : un gestionnaire de commande peut choisir une stratégie et émettre des événements observés.
Vérification rapide
Associez l’exigence au patron correspondant.
Récapitulatif
Vous avez modélisé le comportement avec trois patrons : Stratégie pour remplacer des algorithmes à l’exécution (classes ou fermetures), Observer pour diffuser des changements d’état à des écouteurs découplés (à la base des répartiteurs PSR-14) et Command pour transformer des requêtes en objets que vous pouvez mettre en file, journaliser et annuler (à la base des bus de commandes). Ensemble, ils maintiennent la flexibilité des collaborations et la clarté des responsabilités.
Apprends PHP avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 49
- Leçons
- 195
Questions Fréquemment Posées
La leçon « Patrons comportementaux : stratégie, observateur, commande » est-elle gratuite ?
Oui — le texte complet de « Patrons comportementaux : stratégie, observateur, commande » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours PHP Academy, passe à CoddyKit PRO. Le cours PHP Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Patrons comportementaux : stratégie, observateur, commande » ?
Modélisez les comportements et les communications avec des patrons comportementaux. Tu pratiques PHP Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer PHP Academy ?
Aucune expérience préalable n'est requise. PHP Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « Patrons comportementaux : stratégie, observateur, commande » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon PHP Academy ?
Oui. Chaque leçon PHP Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Les principes SOLID en pratique
- Patrons de création : fabrique, constructeur, singleton
- Patrons structurels : adaptateur, décorateur, façade
- Patrons comportementaux : stratégie, observateur, commande