策略模式核心是分离算法定义与使用，JavaScript中可通过函数对象（如discountStrategies）或类（如FixedDiscountStrategy）实现，结合工厂函数动态选择策略，确保纯度、可测性与低耦合。
策略模式的核心是把算法的定义和使用分开，让不同算法可以互相替换而不影响调用方。在 JavaScript 中，这通常通过函数或对象封装行为、用统一接口调用实现。
用函数对象实现策略集合
把每种算法写成独立函数，挂载到一个策略对象上，调用时根据条件选择对应函数：
- 定义策略对象，每个属性是一个具体算法函数
- 传入参数统一，返回值结构一致，便于外部处理
- 避免硬编码 if-else，用 key 查找策略，扩展新算法只需加函数
const discountStrategies = {
'vip': (price) => price * 0.8,
'promo': (price) => Math.max(price - 50, 0),
'newUser': (price) => price * 0.95,
'default': (price) => price
};
<p>function calculatePrice(price, strategyKey) {
const strategy = discountStrategies[strategyKey] || discountStrategies.default;
return strategy(price);
}</p><p>calculatePrice(100, 'vip'); // 80
calculatePrice(100, 'promo'); // 50
用类+实例化方式支持状态与复用
当策略需要维护内部状态（如计数器、缓存）或依赖外部服务时，用类更合适：
- 每个策略类实现相同方法名（如 execute()），保证接口一致
- 策略实例可保存上下文数据，比如促销活动的剩余次数
- 运行时动态切换策略实例，不影响客户端逻辑
class FixedDiscountStrategy {
constructor(fixedAmount) {
this.fixedAmount = fixedAmount;
}
execute(price) {
return Math.max(price - this.fixedAmount, 0);
}
}
<p>class PercentageDiscountStrategy {
constructor(rate) {
this.rate = rate;
}
execute(price) {
return price * (1 - this.rate);
}
}</p><p>// 使用时切换策略实例
let currentStrategy = new FixedDiscountStrategy(30);
console.log(currentStrategy.execute(100)); // 70</p><p>currentStrategy = new PercentageDiscountStrategy(0.2);
console.log(currentStrategy.execute(100)); // 80
结合配置与工厂，自动匹配策略
真实业务中，策略选择常依赖用户属性、环境或规则引擎。可以用简单工厂封装判断逻辑：
立即学习“Java免费学习笔记（深入）”；
- 工厂函数接收上下文（如用户等级、订单金额、时间等）
- 内部做条件判断，返回对应策略实例或函数
- 把“选哪个策略”的逻辑集中管理，避免散落在各处
function createDiscountStrategy(user, order) {
if (user.level === 'vip' && order.total > 500) {
return new PercentageDiscountStrategy(0.25);
}
if (user.isNew && order.items.length > 0) {
return new PercentageDiscountStrategy(0.1);
}
return new FixedDiscountStrategy(10);
}
<p>const strategy = createDiscountStrategy(currentUser, currentOrder);
const finalPrice = strategy.execute(currentOrder.total);
注意点：保持策略的纯度与可测性
策略函数或类应尽量无副作用、不依赖全局状态：
- 输入确定 → 输出确定，方便单元测试
- 避免在策略内部发请求、改 DOM 或读取 localStorage
- 如有必要依赖，通过构造函数或参数注入，而非硬编码
- 策略之间不耦合，各自独立演进
不复杂但容易忽略。
