GRASP in der funktionalen Javascript-Programmierung

In der Welt der Softwareentwicklung dienen Entwurfsmuster als bewährte Lösungen für häufige Probleme.
Einer der weniger häufig diskutierten, aber ebenso wichtigen Sätze von Entwurfsmustern ist GRASP (General Responsibility Assignment Software Patterns). Die Prinzipien von GRASP korrelieren häufig mit den SOLID-Prinzipien und anderen OOP-Entwurfsmustern.
GRASP (General Responsibility Assignment Software Patterns) ist eine Sammlung von Richtlinien zur Zuweisung von Verantwortlichkeiten an Klassen und Objekte im objektorientierten Design. Wie können wir diese Muster in unserer Javascript-Entwicklung (Node.js) verwenden? Natürlich unterstützt Javascript Klassen, die nativ auf Prototypen basieren und in denen wir GRASP auf ähnliche Weise anwenden können, wie wir es in Java tun würden.
Meiner Meinung nach können GRASP-Muster jedoch auch auf die funktionale Programmierung angewendet werden.

Was ist GRASP?

Die neun GRASP-Muster sind:

1. Informationsexperte
2. Ersteller
3. Controller
4. Geringe Kopplung
5. Hohe Kohäsion
6. Polymorphismus
7. Reine Fabrikation
8. Indirektion
9. Geschützte Variationen

Informationsexperte

Weisen Sie Verantwortlichkeiten Funktionen zu, die über die erforderlichen Daten oder Kenntnisse zur Ausführung einer Aufgabe verfügen. In der funktionalen Programmierung kann dieses Prinzip angewendet werden, indem Verantwortlichkeiten Funktionen oder Modulen zugewiesen werden, die über die Daten oder den Kontext verfügen, die zur Ausführung einer Aufgabe erforderlich sind.

// 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'

Schöpfer

Verwenden Sie Factory-Funktionen, um komplexe Datenstrukturen oder Objekte zu erstellen. Während wir in der funktionalen Programmierung nicht auf die gleiche Weise mit Klassen umgehen wie in der objektorientierten Programmierung, können wir das Creator-Prinzip anwenden, indem wir die Verantwortung für die Erstellung von Datenstrukturen oder die Initialisierung von Objekten Funktionen oder Modulen zuweisen, die über die erforderlichen Informationen verfügen Kontext.

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

Regler

Verwenden Sie Funktionen höherer Ordnung, um Systemereignisse zu verarbeiten und Aufgaben zu delegieren. In der funktionalen Programmierung nehmen Controller häufig die Form von Funktionen an, die den Daten- und Aktionsfluss zwischen verschiedenen Teilen des Systems orchestrieren und so sicherstellen, dass die Verantwortlichkeiten klar getrennt sind.

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

Niedrige Kopplung

Stellen Sie sicher, dass Funktionen unabhängig sind und nur von expliziten Eingaben abhängen. Bei der funktionalen Programmierung wird eine geringe Kopplung erreicht, indem Funktionen und Module entworfen werden, die unabhängig voneinander funktionieren und sich nur minimal auf die internen Details anderer Funktionen oder Module verlassen

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

Hoher Zusammenhalt

Hohe Kohäsion bezieht sich auf den Grad der Zusammengehörigkeit der Elemente innerhalb eines Moduls oder einer Funktion. In der funktionalen Programmierung bedeutet das Erreichen einer hohen Kohäsion, Funktionen und Module so zu entwerfen, dass sie eine einzelne, genau definierte Aufgabe oder einen eng verwandten Satz von Aufgaben ausführen.

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');

Polymorphismus

Verwenden Sie Funktionen höherer Ordnung und erstklassige Funktionen, um Polymorphismus zu erreichen. In der funktionalen Programmierung wird Polymorphismus typischerweise durch Funktionen höherer Ordnung, generische Funktionen und Typsysteme wie Typescript erreicht

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

Reine Herstellung

Erstellen Sie Dienstprogrammfunktionen, die nicht direkt den Domänenkonzepten entsprechen, aber die notwendige Funktionalität bereitstellen, wenn keine geeignete Domänenfunktion oder -klasse vorhanden ist.

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

Indirektion

Indirektion bezieht sich in der funktionalen Programmierung auf die Verwendung von Zwischenfunktionen, um Interaktionen zwischen verschiedenen Teilen eines Systems zu verwalten. Ein gutes Beispiel in Node.js kann das Middleware-Muster sein.

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

Geschützte Variationen

Geschützte Variationen in der funktionalen Programmierung bedeuten die Schaffung eines Designs, das gegenüber Änderungen widerstandsfähig ist, indem die variierenden Teile gekapselt werden und sichergestellt wird, dass der Rest des Systems vor diesen Variationen geschützt ist. In der funktionalen Programmierung kann dieses Prinzip durch den Einsatz von Abstraktion, Unveränderlichkeit und Kapselung angewendet werden, um robusten und wartbaren Code zu erstellen, der weniger anfällig für Änderungen ist.

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);

Zusammenfassung

Wie Sie sehen, korrelieren die GRASP-Prinzipien mit vielen bekannten Designmustern sowie den SOLID-Prinzipien. Hoher Zusammenhalt ist fast gleichbedeutend mit dem Prinzip der Einzelverantwortung und so weiter.
Bei diesen Prinzipien handelt es sich nicht nur um OOP-Prinzipien, sondern um allgemeine Prinzipien für die Programmierung von gut strukturiertem, sauberem Code, unabhängig davon, ob es sich um funktionale oder OOP-Programmierung handelt.

Das obige ist der detaillierte Inhalt vonGRASP in der funktionalen Javascript-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!