JS `Strategy Pattern`：根据运行时条件动态切换算法

各位程序猿朋友们，大家好！我是你们的老朋友，Bug终结者（希望如此）。今天咱们来聊聊一个在代码世界里“变脸”的绝招——策略模式。

策略模式：让你的代码学会“随机应变”

想象一下，你是一家电商平台的程序员，要给用户提供不同的促销活动。比如，有的用户满100减20，有的用户打8折，还有的用户直接赠送优惠券。如果你的代码写成一堆 if-else，那可就完蛋了。不仅代码臃肿难维护，而且每次增加新的促销活动都要修改核心代码，风险巨大。

这时候，策略模式就闪亮登场了！它就像一个“策略大礼包”，可以根据不同的情况，动态选择不同的算法（也就是“策略”）。这样，你的代码就能灵活应对各种变化，而不用动不动就“伤筋动骨”了。

策略模式的组成要素

策略模式主要包含三个角色：

• 策略接口 (Strategy Interface)： 定义所有策略需要实现的方法，相当于一个“协议”。
• 具体策略类 (Concrete Strategies)： 实现策略接口，提供具体的算法实现。每个类代表一种策略。
• 上下文类 (Context)： 持有一个策略对象的引用，并在需要时调用策略对象的方法。它就像一个“调度员”，负责选择和执行策略。

代码示例：促销活动策略

为了更好地理解，咱们来看一个实际的例子：促销活动策略。

// 1. 策略接口
class PromotionStrategy {
  calculateDiscount(price) {
    throw new Error("Method 'calculateDiscount()' must be implemented.");
  }
}

// 2. 具体策略类：满减策略
class FullReductionStrategy extends PromotionStrategy {
  constructor(threshold, reduction) {
    super();
    this.threshold = threshold;
    this.reduction = reduction;
  }

  calculateDiscount(price) {
    if (price >= this.threshold) {
      return this.reduction;
    } else {
      return 0;
    }
  }
}

// 3. 具体策略类：折扣策略
class DiscountStrategy extends PromotionStrategy {
  constructor(discountRate) {
    super();
    this.discountRate = discountRate;
  }

  calculateDiscount(price) {
    return price * (1 - this.discountRate);
  }
}

// 4. 具体策略类：优惠券策略
class CouponStrategy extends PromotionStrategy {
  constructor(couponValue) {
    super();
    this.couponValue = couponValue;
  }

  calculateDiscount(price) {
    return this.couponValue;
  }
}

// 5. 上下文类：促销活动管理器
class PromotionManager {
  constructor(strategy) {
    this.strategy = strategy;
  }

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

  calculateFinalPrice(price) {
    const discount = this.strategy.calculateDiscount(price);
    return price - discount;
  }
}

// 使用示例
const fullReduction = new FullReductionStrategy(100, 20);
const discount = new DiscountStrategy(0.8);
const coupon = new CouponStrategy(10);

const promotionManager = new PromotionManager(fullReduction); // 初始策略：满减

let price = 120;
let finalPrice = promotionManager.calculateFinalPrice(price);
console.log(`满减后价格: ${finalPrice}`); // 输出: 100

promotionManager.setStrategy(discount); // 切换策略：折扣
finalPrice = promotionManager.calculateFinalPrice(price);
console.log(`折扣后价格: ${finalPrice}`); // 输出: 96

promotionManager.setStrategy(coupon); // 切换策略：优惠券
finalPrice = promotionManager.calculateFinalPrice(price);
console.log(`优惠券后价格: ${finalPrice}`); // 输出: 110

在这个例子中，PromotionStrategy 是策略接口，FullReductionStrategy、DiscountStrategy 和 CouponStrategy 是具体策略类，PromotionManager 是上下文类。通过 PromotionManager，我们可以动态切换不同的促销策略，而不需要修改 PromotionManager 本身的代码。

策略模式的优点

• 符合开闭原则： 可以方便地增加新的策略，而不需要修改现有代码。
• 提高代码可维护性： 将不同的算法封装在不同的类中，使得代码结构更清晰，易于维护。
• 提高代码可复用性： 策略类可以被多个上下文类复用。
• 避免大量 if-else 语句： 使代码更简洁，更易读。

策略模式的应用场景

策略模式在实际开发中有很多应用场景，比如：

• 支付方式选择： 可以根据用户选择的支付方式（支付宝、微信、银行卡等）选择不同的支付策略。
• 排序算法选择： 可以根据数据规模和特点选择不同的排序算法（快速排序、归并排序、插入排序等）。
• 数据验证： 可以根据不同的数据类型选择不同的验证策略。
• 缓存策略： 可以根据数据的访问频率和重要性选择不同的缓存策略（LRU、FIFO、LFU等）。

策略模式与其他设计模式的比较

• 策略模式 vs. 状态模式： 状态模式关注的是对象内部状态的改变，而策略模式关注的是算法的选择。状态模式中，状态的改变通常会导致对象行为的改变，而策略模式中，策略的改变通常是为了实现不同的目标。
• 策略模式 vs. 工厂模式： 工厂模式用于创建对象，而策略模式用于选择算法。工厂模式可以用于创建策略对象，然后策略模式用于选择使用哪个策略对象。
• 策略模式 vs. 模板方法模式： 模板方法模式定义了一个算法的骨架，并将一些步骤延迟到子类实现。策略模式则是将整个算法封装在一个策略类中，可以动态替换。

策略模式的注意事项

• 策略类的数量： 如果策略类的数量过多，可能会增加代码的复杂性。需要权衡利弊，避免过度设计。
• 策略类的粒度： 策略类的粒度应该适中。如果粒度太小，可能会导致策略类过多；如果粒度太大，可能会导致策略类不够灵活。
• 策略的选择： 如何选择合适的策略是一个重要的问题。可以根据用户的输入、系统配置、或者其他条件来选择策略。

更高级的用法：函数式编程和策略模式

JavaScript 的函数式编程特性可以让我们更简洁地实现策略模式。我们可以使用函数作为策略，而不是类。

// 1. 策略函数：满减策略
const fullReductionStrategy = (threshold, reduction) => (price) => {
  if (price >= threshold) {
    return reduction;
  } else {
    return 0;
  }
};

// 2. 策略函数：折扣策略
const discountStrategy = (discountRate) => (price) => {
  return price * (1 - discountRate);
};

// 3. 策略函数：优惠券策略
const couponStrategy = (couponValue) => (price) => {
  return couponValue;
};

// 4. 上下文类：促销活动管理器 (使用函数)
class PromotionManagerFunctional {
  constructor(strategy) {
    this.strategy = strategy;
  }

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

  calculateFinalPrice(price) {
    const discount = this.strategy(price);
    return price - discount;
  }
}

// 使用示例
const fullReduction = fullReductionStrategy(100, 20);
const discount = discountStrategy(0.8);
const coupon = couponStrategy(10);

const promotionManagerFunctional = new PromotionManagerFunctional(fullReduction); // 初始策略：满减

let priceFunctional = 120;
let finalPriceFunctional = promotionManagerFunctional.calculateFinalPrice(priceFunctional);
console.log(`函数式满减后价格: ${finalPriceFunctional}`); // 输出: 100

promotionManagerFunctional.setStrategy(discount); // 切换策略：折扣
finalPriceFunctional = promotionManagerFunctional.calculateFinalPrice(priceFunctional);
console.log(`函数式折扣后价格: ${finalPriceFunctional}`); // 输出: 96

promotionManagerFunctional.setStrategy(coupon); // 切换策略：优惠券
finalPriceFunctional = promotionManagerFunctional.calculateFinalPrice(priceFunctional);
console.log(`函数式优惠券后价格: ${finalPriceFunctional}`); // 输出: 110

这种方式更加简洁，避免了定义大量的类，也更符合函数式编程的思想。

策略模式的实际案例：表单验证

假设我们需要验证用户提交的表单数据，不同的字段可能需要不同的验证规则。我们可以使用策略模式来实现这个功能。

// 1. 策略接口
class ValidationStrategy {
  validate(value) {
    throw new Error("Method 'validate()' must be implemented.");
  }
}

// 2. 具体策略类：必填验证
class RequiredValidation extends ValidationStrategy {
  validate(value) {
    if (!value) {
      return "This field is required.";
    }
    return null; // null 表示验证通过
  }
}

// 3. 具体策略类：邮箱验证
class EmailValidation extends ValidationStrategy {
  validate(value) {
    const emailRegex = /^[^s@]+@[^s@]+.[^s@]+$/;
    if (!emailRegex.test(value)) {
      return "Invalid email address.";
    }
    return null;
  }
}

// 4. 具体策略类：长度验证
class LengthValidation extends ValidationStrategy {
  constructor(minLength, maxLength) {
    super();
    this.minLength = minLength;
    this.maxLength = maxLength;
  }

  validate(value) {
    if (value.length < this.minLength || value.length > this.maxLength) {
      return `The length must be between ${this.minLength} and ${this.maxLength}.`;
    }
    return null;
  }
}

// 5. 上下文类：表单验证器
class FormValidator {
  constructor() {
    this.validations = {}; // 存储字段和验证策略的映射
  }

  addValidation(field, strategy) {
    this.validations[field] = strategy;
  }

  validate(formData) {
    const errors = {};
    for (const field in this.validations) {
      if (this.validations.hasOwnProperty(field)) {
        const strategy = this.validations[field];
        const value = formData[field];
        const error = strategy.validate(value);
        if (error) {
          errors[field] = error;
        }
      }
    }
    return errors;
  }
}

// 使用示例
const formValidator = new FormValidator();
formValidator.addValidation("name", new RequiredValidation());
formValidator.addValidation("email", new EmailValidation());
formValidator.addValidation("password", new LengthValidation(6, 20));

const formData = {
  name: "John Doe",
  email: "invalid-email",
  password: "short",
};

const errors = formValidator.validate(formData);
console.log(errors);
// 输出:
// {
//   email: 'Invalid email address.',
//   password: 'The length must be between 6 and 20.'
// }

在这个例子中，我们定义了三种验证策略：RequiredValidation、EmailValidation 和 LengthValidation。FormValidator 类负责存储字段和验证策略的映射，并根据映射关系执行验证。

总结

策略模式是一种非常有用的设计模式，可以帮助我们编写更灵活、可维护的代码。它通过将算法封装在不同的策略类中，使得我们可以动态选择和切换算法，而不需要修改核心代码。希望今天的讲解能够帮助大家更好地理解和应用策略模式。记住，好的代码就像一位优秀的演员，能根据不同的场景，展现出不同的“演技”。

好啦，今天的讲座就到这里。希望大家都能成为代码界的“策略大师”，写出更加优雅和健壮的代码！如果还有什么问题，欢迎随时提问！下次再见！