JavaScript 中的策略模式(五)策略模式是一种行为型设计模式，允许将一组算法封装在独立的类中，使它们可以相互替换

策略模式是一种行为型设计模式，允许将一组算法封装在独立的类中，使它们可以相互替换。通过策略模式，客户端可以在运行时选择所需的算法，而不需要修改使用这些算法的代码。这种模式非常适合于需要在运行时选择不同算法或策略的场景。本文将深入探讨策略模式的概念、实现方式以及在 JavaScript 中的应用实例。

什么是策略模式？

策略模式涉及三个主要角色：

上下文（Context）：持有对策略的引用并使用策略对象。
策略接口（Strategy）：定义一组算法的接口，所有具体策略类都实现这个接口。
具体策略（Concrete Strategy）：实现具体算法的类，每个具体策略都实现策略接口。

策略模式的优缺点

优点

解耦合：将算法与使用算法的代码解耦，便于理解和维护。
灵活性：可以在运行时选择和切换不同的策略。
扩展性：新增策略时，无需修改上下文代码，符合开闭原则。

缺点

客户端复杂性：客户端需要了解所有策略的接口和用途，可能会增加使用复杂性。
策略数量增多：当策略数量过多时，会导致策略管理的复杂性增加。

策略模式的实现

1. 基本实现

下面是一个简单的策略模式的实现示例，使用不同的算法来计算折扣。

// 策略接口
class DiscountStrategy {
  calculate(price) {
    throw new Error('This method should be overridden!');
  }
}

// 具体策略：无折扣
class NoDiscount extends DiscountStrategy {
  calculate(price) {
    return price;
  }
}

// 具体策略：打9折
class TenPercentDiscount extends DiscountStrategy {
  calculate(price) {
    return price * 0.9;
  }
}

// 具体策略：打8折
class TwentyPercentDiscount extends DiscountStrategy {
  calculate(price) {
    return price * 0.8;
  }
}

// 上下文
class ShoppingCart {
  constructor(discountStrategy) {
    this.discountStrategy = discountStrategy;
    this.items = [];
  }

  addItem(item) {
    this.items.push(item);
  }

  calculateTotal() {
    const total = this.items.reduce((sum, item) => sum + item.price, 0);
    return this.discountStrategy.calculate(total);
  }
}

// 使用示例
const cart = new ShoppingCart(new TenPercentDiscount());
cart.addItem({ name: 'Item 1', price: 100 });
cart.addItem({ name: 'Item 2', price: 200 });

console.log(`Total after discount: $${cart.calculateTotal()}`); // 输出: Total after discount: $270

// 更换策略为无折扣
cart.discountStrategy = new NoDiscount();
console.log(`Total after no discount: $${cart.calculateTotal()}`); // 输出: Total after no discount: $300

在这个示例中，DiscountStrategy 是策略接口，定义了一个 calculate 方法。NoDiscount、TenPercentDiscount 和 TwentyPercentDiscount 是具体策略，分别实现不同的折扣计算逻辑。ShoppingCart 类是上下文，持有对策略的引用并使用它来计算总价。

2. 在 API 调用中的策略模式

策略模式也可以应用于 API 调用，根据不同的请求类型选择不同的处理策略。下面是一个简单的示例。

// 策略接口
class ApiRequestStrategy {
  request() {
    throw new Error('This method should be overridden!');
  }
}

// 具体策略：GET 请求
class GetRequest extends ApiRequestStrategy {
  request(url) {
    console.log(`Performing GET request to ${url}`);
    // 这里可以添加实际的请求逻辑
  }
}

// 具体策略：POST 请求
class PostRequest extends ApiRequestStrategy {
  request(url, data) {
    console.log(`Performing POST request to ${url} with data: ${JSON.stringify(data)}`);
    // 这里可以添加实际的请求逻辑
  }
}

// 上下文
class ApiClient {
  constructor(strategy) {
    this.strategy = strategy;
  }

  setStrategy(strategy) {
    this.strategy = strategy;
  }

  makeRequest(url, data) {
    this.strategy.request(url, data);
  }
}

// 使用示例
const apiClient = new ApiClient(new GetRequest());
apiClient.makeRequest('https://api.example.com/data'); // 输出: Performing GET request to https://api.example.com/data

apiClient.setStrategy(new PostRequest());
apiClient.makeRequest('https://api.example.com/data', { key: 'value' }); // 输出: Performing POST request to https://api.example.com/data with data: {"key":"value"}

在这个示例中，ApiRequestStrategy 是策略接口，GetRequest 和 PostRequest 是具体策略，分别处理不同类型的 API 请求。ApiClient 类是上下文，持有对策略的引用并执行请求。

何时使用策略模式？

策略模式适合以下场景：

需要在运行时选择不同算法或策略时。
需要将算法与使用算法的代码解耦时。
需要动态改变对象的行为时，如不同的计算方式或策略。

总结

策略模式是一种灵活且强大的设计模式，允许在运行时选择不同的算法或策略。通过将算法封装在独立的类中，策略模式提高了代码的可维护性和可扩展性。在 JavaScript 开发中，了解和应用策略模式可以帮助构建更为灵活和高效的应用。

在下一篇文章中，我们将探讨 JavaScript 中的命令模式，敬请期待！