策略模式(Strategy)的可替换算法实现

策略模式是一种行为设计模式，允许在运行时选择算法的具体实现。通过封装一系列算法，使得它们可以相互替换，从而让算法的变化独立于使用它的客户端。在JavaScript中，这种模式常用于动态切换业务逻辑或算法，提升代码的灵活性和可维护性。

策略模式的核心思想

策略模式的核心在于将算法封装成独立的策略类，而不是硬编码在客户端代码中。每个策略类实现相同的接口，客户端通过上下文对象调用策略，而无需关心具体实现细节。这种解耦使得算法可以独立变化，且新增或修改策略时不会影响其他代码。

例如，一个电商平台的折扣计算逻辑可能因促销活动频繁变化。硬编码每种折扣会导致代码臃肿且难以维护。通过策略模式，可以将每种折扣算法封装成独立策略：

// 策略接口
class DiscountStrategy {
  calculate(price) {
    throw new Error("必须实现calculate方法");
  }
}

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

// 具体策略：固定折扣
class FixedDiscount extends DiscountStrategy {
  constructor(discountAmount) {
    super();
    this.discountAmount = discountAmount;
  }

  calculate(price) {
    return price - this.discountAmount;
  }
}

// 具体策略：百分比折扣
class PercentageDiscount extends DiscountStrategy {
  constructor(percentage) {
    super();
    this.percentage = percentage;
  }

  calculate(price) {
    return price * (1 - this.percentage / 100);
  }
}

上下文角色的实现

上下文（Context）是策略模式的关键角色，它持有具体策略的引用，并提供切换策略的方法。上下文通常不直接实现算法，而是委托给当前策略：

class ShoppingCart {
  constructor(discountStrategy = new NoDiscount()) {
    this.discountStrategy = discountStrategy;
    this.items = [];
  }

  setDiscountStrategy(strategy) {
    this.discountStrategy = strategy;
  }

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

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

// 使用示例
const cart = new ShoppingCart();
cart.addItem({ name: "商品A", price: 100 });
cart.addItem({ name: "商品B", price: 200 });

// 应用无折扣
console.log(cart.calculateTotal()); // 输出: 300

// 切换到固定折扣策略
cart.setDiscountStrategy(new FixedDiscount(50));
console.log(cart.calculateTotal()); // 输出: 250

// 切换到百分比折扣策略
cart.setDiscountStrategy(new PercentageDiscount(10));
console.log(cart.calculateTotal()); // 输出: 270

策略模式的动态切换优势

策略模式最显著的优势是运行时动态切换算法。这在需要根据用户输入、环境配置或业务规则改变行为时特别有用。例如，一个数据可视化工具可能支持多种图表渲染算法：

class ChartRenderer {
  constructor(strategy) {
    this.renderStrategy = strategy;
  }

  setRenderStrategy(strategy) {
    this.renderStrategy = strategy;
  }

  render(data) {
    return this.renderStrategy.execute(data);
  }
}

// 柱状图渲染策略
class BarChartStrategy {
  execute(data) {
    console.log(`渲染柱状图: ${JSON.stringify(data)}`);
    // 实际渲染逻辑...
  }
}

// 折线图渲染策略
class LineChartStrategy {
  execute(data) {
    console.log(`渲染折线图: ${JSON.stringify(data)}`);
    // 实际渲染逻辑...
  }
}

// 使用示例
const data = [10, 20, 30];
const renderer = new ChartRenderer(new BarChartStrategy());
renderer.render(data); // 输出: 渲染柱状图...

// 动态切换为折线图
renderer.setRenderStrategy(new LineChartStrategy());
renderer.render(data); // 输出: 渲染折线图...

策略模式与条件语句的对比

传统实现可能使用条件语句来切换不同算法，但这会导致代码难以维护：

// 不推荐的实现方式
function calculateDiscount(type, price) {
  if (type === "fixed") {
    return price - 10;
  } else if (type === "percentage") {
    return price * 0.9;
  } else {
    return price;
  }
}

策略模式消除了这些条件分支，将每个算法封装在独立类中。当新增折扣类型时，只需添加新的策略类，无需修改现有代码：

// 新增策略：满减折扣
class ThresholdDiscount extends DiscountStrategy {
  constructor(threshold, discount) {
    super();
    this.threshold = threshold;
    this.discount = discount;
  }

  calculate(price) {
    return price >= this.threshold ? price - this.discount : price;
  }
}

// 使用新策略无需修改上下文
cart.setDiscountStrategy(new ThresholdDiscount(200, 30));
console.log(cart.calculateTotal()); // 根据总价自动应用满减

策略组合的进阶用法

复杂场景下，策略可以组合使用。例如实现一个复合折扣策略，依次应用多个折扣：

class CompositeDiscount extends DiscountStrategy {
  constructor(strategies = []) {
    super();
    this.strategies = strategies;
  }

  calculate(price) {
    return this.strategies.reduce((currentPrice, strategy) => {
      return strategy.calculate(currentPrice);
    }, price);
  }
}

// 组合使用固定折扣和百分比折扣
const compositeStrategy = new CompositeDiscount([
  new FixedDiscount(20),
  new PercentageDiscount(5)
]);

cart.setDiscountStrategy(compositeStrategy);
console.log(cart.calculateTotal()); // 先减20，再减5%

策略模式在表单验证中的应用

表单验证是策略模式的典型应用场景。不同的字段可能需要不同的验证规则，且这些规则可能经常变化：

// 验证策略接口
class ValidationStrategy {
  validate(value) {
    throw new Error("必须实现validate方法");
  }
}

// 非空验证
class RequiredValidation extends ValidationStrategy {
  validate(value) {
    return value.trim() !== "";
  }
}

// 最小长度验证
class MinLengthValidation extends ValidationStrategy {
  constructor(minLength) {
    super();
    this.minLength = minLength;
  }

  validate(value) {
    return value.length >= this.minLength;
  }
}

// 正则验证
class PatternValidation extends ValidationStrategy {
  constructor(pattern) {
    super();
    this.pattern = pattern;
  }

  validate(value) {
    return this.pattern.test(value);
  }
}

// 表单字段类
class FormField {
  constructor(validations = []) {
    this.validations = validations;
    this.value = "";
  }

  setValue(value) {
    this.value = value;
  }

  isValid() {
    return this.validations.every(validation => 
      validation.validate(this.value)
    );
  }
}

// 使用示例
const usernameField = new FormField([
  new RequiredValidation(),
  new MinLengthValidation(4),
  new PatternValidation(/^[a-zA-Z0-9_]+$/)
]);

usernameField.setValue("user1");
console.log(usernameField.isValid()); // true

usernameField.setValue("u$");
console.log(usernameField.isValid()); // false

策略模式的性能考量

虽然策略模式提供了灵活性，但在性能敏感的场景需要考虑策略对象的创建开销。对于频繁调用的算法，可以通过以下方式优化：

1. 策略对象复用：创建策略对象池，避免重复实例化
2. 函数式策略：在JavaScript中，可以直接使用函数作为简单策略

// 函数式策略实现
const discountStrategies = {
  none: price => price,
  fixed: amount => price => price - amount,
  percentage: percent => price => price * (1 - percent / 100)
};

// 使用函数策略
const applyDiscount = (strategy, price) => strategy(price);

const fixed50 = discountStrategies.fixed(50);
console.log(applyDiscount(fixed50, 200)); // 150

策略模式与状态模式的比较

策略模式和状态模式在结构上相似，但意图不同：

• 策略模式：算法选择是主动的，由客户端决定使用哪种策略
• 状态模式：状态转换是被动的，由内部条件触发状态改变

例如，一个文档编辑器可能同时使用这两种模式：

// 策略模式：选择不同的导出格式
class ExportStrategy {
  export(document) {
    throw new Error("必须实现export方法");
  }
}

// 状态模式：根据文档状态限制操作
class DocumentState {
  edit() {
    throw new Error("当前状态不允许编辑");
  }
}