La séparation des requêtes de commande (CQS) est un principe fondamental de la conception du logiciel qui favorise la clarté et la simplicité de votre base de code. Inventée par Bertrand Meyer, le principe indique que chaque méthode d'un système doit effectuer une action (une commande) ou des données de retour (une requête), mais jamais les deux. Cette distinction garantit que votre code est plus facile à comprendre, tester et maintenir.

Dans cet article de blog, nous explorerons les aspects clés de CQS, comment le mettre en œuvre et les avantages qu'il apporte au développement de logiciels. Nous fournirons également des exemples d'application de CQS dans des scénarios pratiques, tels que la conception d'API et les interactions de base de données.

1️⃣ Comprendre les bases de cqs

En son cœur, CQS sépare les fonctions en deux catégories distinctes:

✓ Commandes: Effectuer des actions qui modifient l'état du système mais ne renvoient aucune valeur (par exemple, la mise à jour d'une base de données ou l'envoi d'un e-mail).

✓ requêtes: récupérer des données sans modifier l'état du système (par exemple, récupérer les détails de l'utilisateur à partir d'une base de données).

Cette séparation simplifie le raisonnement sur le code et évite les effets secondaires involontaires.

2️⃣ Avantages de l'utilisation de cqs
Amélioration de la lisibilité du code: une distinction claire entre les commandes et les requêtes rend le code plus facile à comprendre.
Effets secondaires réduits: les requêtes ne modifient pas l'état, assurant un comportement prévisible.
Test plus facile: les commandes et les requêtes peuvent être testées indépendamment, réduisant la complexité dans les cas de test.
Conception évolutive: encourage le code modulaire et découplé, ce qui rend le système plus facile à évoluer et à étendre.

3️⃣ Implémentation de cqs dans la pratique

Exemple: API express.js

Appliquons les principes CQS à une application express.js:

? Sans cqs:

app.post('/user', (req, res) => {
  const user = createUser(req.body); // Command
  res.json(user); // Query
});

? Avec cqs:

app.post('/user', (req, res) => {
  createUser(req.body); // Command
  res.sendStatus(201);
});

app.get('/user/:id', (req, res) => {
  const user = getUser(req.params.id); // Query
  res.json(user);
});

ici, les commandes (CreateUser) et les requêtes (getUser) sont séparées, ce qui rend les responsabilités de chaque fonction plus claire.

4ress L'intégration avec le code hérité:

L'adoption de CQS dans une base de code existante peut nécessiter une refactorisation. Démarrez petit, en vous concentrant sur de nouvelles fonctionnalités ou des composants critiques.

Performance Overhead:

L'adhésion stricte aux CQS peut parfois conduire à des appels de fonction supplémentaires. Optimiser sélectivement pour équilibrer la clarté et les performances.

Conclusion

---

La séparation des requêtes de commande est un principe simple mais puissant qui favorise la clarté et la maintenabilité dans la conception des logiciels. En adoptant cette approche, vous pouvez créer des systèmes plus faciles à raisonner, à l'échelle et à tester. Que vous conceviez des API, de la mise en œuvre de la logique du domaine ou de la gestion des interactions de base de données, CQS est un outil précieux pour l'ingénierie logicielle moderne.