掌握 Javascript 函数式编程

在软件开发领域，设计模式是针对常见问题经过时间考验的解决方案。
GRASP（通用责任分配软件模式）是较少讨论但同样重要的设计模式集之一。 GRASP 的原则通常与 SOLID 原则和其他 OOP 设计模式相关。
GRASP（通用责任分配软件模式）是一系列指南，旨在将责任分配给面向对象设计中的类和对象。我们如何在 Javascript (Node.js) 开发中使用这些模式？当然，Javascript 支持类，这些类本身是基于原型构建的，我们可以像在 Java 中那样以类似的方式应用 GRASP。
然而，在我看来，GRASP 模式也可以应用于函数式编程。

什么是GRASP？

九种 GRASP 模式是：

1. 信息专家
2. 创作者
3. 控制器
4. 低耦合
5. 高内聚力
6. 多态性
7. 纯属捏造
8. 间接
9. 受保护的变体

信息专家

将职责分配给具有执行任务所需数据或知识的功能。在函数式编程中，可以通过将职责分配给具有执行任务所需的数据或上下文的函数或模块来应用此原则。

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

创作者

使用工厂函数创建复杂的数据结构或对象。在函数式编程中，虽然我们处理类的方式与面向对象编程不同，但我们可以应用创建者原则，将创建数据结构或初始化对象的责任分配给具有必要信息的函数或模块，并且上下文。

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

控制器

使用高阶函数处理系统事件和委托任务。在函数式编程中，控制器通常采用函数的形式来编排系统不同部分之间的数据流和操作，确保职责明确分离。

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

低耦合

确保函数是独立的并且仅依赖于显式输入。在函数式编程中，低耦合是通过设计彼此独立运行的函数和模块来实现的，并且对其他函数或模块的内部细节的依赖最小化

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

高内聚力

高内聚是指模块或函数内的元素所属的程度。在函数式编程中，实现高内聚意味着设计函数和模块，以便它们执行单个、明确定义的任务或密切相关的一组任务。

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

多态性

使用高阶函数和一等函数来实现多态。在函数式编程中，多态性通常是通过高阶函数、泛型函数和 Typescript
等类型系统来实现

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

纯制造

当不存在合适的域函数或类时，创建不直接对应于域概念但提供必要功能的实用函数。

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

间接

函数式编程中的间接是指使用中间函数来管理系统不同部分之间的交互。 Node.js 中的一个很好的例子就是中间件模式。

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

受保护的变体

函数式编程中受保护的变化意味着通过封装变化的部分并确保系统的其余部分免受这些变化的影响，创建一种能够适应变化的设计。 在函数式编程中，可以通过使用抽象、不变性和封装来应用这一原则，以创建不易更改的健壮且可维护的代码。

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

概括

如您所见，GRASP 原则与许多已知的设计模式以及 SOLID 原则相关。高内聚几乎等于单一职责原则等等。
这些原则不仅是 OOP 原则，而且是编写架构良好的干净代码的一般原则，无论是函数式编程还是 OOP 编程。

以上是掌握 Javascript 函数式编程的详细内容。更多信息请关注PHP中文网其他相关文章！