GRASP en programmation fonctionnelle Javascript

Dans le monde du développement logiciel, les modèles de conception servent de solutions éprouvées aux problèmes courants.
L’un des ensembles de modèles de conception les moins discutés mais tout aussi essentiels est le GRASP (General Responsibility Assignment Software Patterns). Les principes de GRASP sont souvent en corrélation avec les principes SOLID et d'autres modèles de conception POO.
GRASP, ou General Responsibility Assignment Software Patterns, est un ensemble de lignes directrices visant à attribuer des responsabilités aux classes et aux objets dans la conception orientée objet. Comment pouvons-nous utiliser ces modèles dans notre développement Javascript (Node.js) ? Bien entendu, Javascript prend en charge les classes, qui sont nativement construites sur des prototypes, dans lesquelles nous pouvons appliquer GRASP de la même manière que nous le ferions en Java.
Cependant, à mon avis, les modèles GRASP peuvent également être appliqués à la programmation fonctionnelle.

Qu’est-ce que GRASP ?

Les neuf modèles GRASP sont :

1. Expert en informations
2. Créateur
3. Contrôleur
4. Couplage faible
5. Haute cohésion
6. Polymorphisme
7. Fabrication pure
8. Indirection
9. Variations protégées

Expert en informations

Attribuez des responsabilités aux fonctions qui disposent des données ou des connaissances requises pour effectuer une tâche. En programmation fonctionnelle, ce principe peut être appliqué en attribuant des responsabilités à des fonctions ou des modules qui disposent des données ou du contexte requis pour effectuer une tâche.

// User management module
const createUser = (name, email) => ({ name, email });

const getUserEmail = (user) => user.email;

const updateUserEmail = (user, newEmail) => ({
  ...user,
  email: newEmail,
});

const user = createUser('John Doe', 'john@example.com');
console.log(getUserEmail(user));  // 'john@example.com'

const updatedUser = updateUserEmail(user, 'john.doe@example.com');
console.log(getUserEmail(updatedUser));  // 'john.doe@example.com'

Créateur

Utilisez les fonctions d'usine pour créer des structures de données ou des objets complexes. En programmation fonctionnelle, même si nous ne traitons pas les classes de la même manière qu'en programmation orientée objet, nous pouvons appliquer le principe Creator en attribuant la responsabilité de créer des structures de données ou d'initialiser des objets à des fonctions ou des modules qui disposent des informations et des informations nécessaires. contexte.

const createUser = (name, email) => ({ name, email });

Contrôleur

Utilisez des fonctions d'ordre supérieur pour gérer les événements système et déléguer des tâches. En programmation fonctionnelle, les contrôleurs prennent souvent la forme de fonctions qui orchestrent le flux de données et d'actions entre les différentes parties du système, garantissant ainsi que les responsabilités sont clairement séparées.

// Example of express.js controller
const handleRequest = (req, res, userService) => {
  const user = userService.createUser(req.body.name, req.body.email);
  res.send(user);
};

Couplage faible

Assurez-vous que les fonctions sont indépendantes et ne dépendent que d'entrées explicites. Dans la programmation fonctionnelle, un faible couplage est obtenu en concevant des fonctions et des modules qui fonctionnent indépendamment les uns des autres, avec une dépendance minimale sur les détails internes d'autres fonctions ou modules

const sendEmail = (emailService, email) => emailService.send(email);

Haute cohésion

La cohésion élevée fait référence au degré auquel les éléments d'un module ou d'une fonction appartiennent ensemble. En programmation fonctionnelle, atteindre une cohésion élevée signifie concevoir des fonctions et des modules de manière à ce qu'ils exécutent une tâche unique bien définie ou un ensemble de tâches étroitement liées.

const createUser = (name, email) => ({ name, email });
const addUser = (users, user) => [...users, user];

const createAndAddUser = (users, name, email)=>{
  const user = createUser(name, email);
  return addUser(users, user)
}
// usage
const users = [
  { name: 'Alice', email: 'alice@example.com' },
  { name: 'Bob', email: 'bob@example.com' },
];

const newUsers = createAndAddUser(users, 'Charlie', 'charlie@example.com');

Polymorphisme

Utilisez des fonctions d'ordre supérieur et des fonctions de première classe pour obtenir le polymorphisme. En programmation fonctionnelle, le polymorphisme est généralement obtenu grâce à des fonctions d'ordre supérieur, des fonctions génériques et des systèmes de types comme Typescript

const processPayment = (paymentMethod) => paymentMethod.process();

Fabrication pure

Créez des fonctions utilitaires qui ne correspondent pas directement aux concepts de domaine mais fournissent les fonctionnalités nécessaires, lorsqu'aucune fonction ou classe de domaine appropriée n'existe.

const log = (message) => console.log(message);

Indirection

L'indirection en programmation fonctionnelle fait référence à l'utilisation de fonctions intermédiaires pour gérer les interactions entre différentes parties d'un système. Un bon exemple dans Node.js peut être le modèle Middleware.

const withNumberFilterMiddleware = (data) => data.filter(item => !isNaN(Number(item)));

Variantes protégées

Les variations protégées dans la programmation fonctionnelle signifient créer une conception résiliente aux changements en encapsulant les parties qui varient et en garantissant que le reste du système est protégé de ces variations. En programmation fonctionnelle, ce principe peut être appliqué grâce à l'utilisation de l'abstraction, de l'immuabilité et de l'encapsulation pour créer un code robuste et maintenable, moins susceptible aux changements.

const processCreditCardPayment = (amount) => {
  console.log(`Processing credit card payment of ${amount}`);
  // Credit card payment logic
};

const processPayPalPayment = (amount) => {
  console.log(`Processing PayPal payment of ${amount}`);
  // PayPal payment logic
};

const processPayment = (paymentMethod, amount) => {
  paymentMethod(amount);
};

// Use different payment methods without changing the processPayment function
processPayment(processCreditCardPayment, 100);
processPayment(processPayPalPayment, 200);

Résumé

Comme vous pouvez le constater, les principes GRASP sont en corrélation avec de nombreux modèles de conception connus ainsi qu'avec les principes SOLID. Une cohésion élevée équivaut presque au principe de responsabilité unique, etc.
Ces principes ne sont pas seulement des principes de POO, mais des principes généraux de programmation de code propre et bien architecturé, qu'il s'agisse de programmation fonctionnelle ou de POO.

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!