怎么用JavaScript策略模式重构电商促销计算逻辑？

图 0：基于 JavaScript 策略模式的促销计算核心模型概览

一、为什么传统 if-else 促销结算会失控？

在电商平台的初始开发阶段，促销逻辑通常非常直观。业务线往往只有单一的“满 300 减 30”或“打 9 折”，开发者往往直接在一个主结算函数中编写条件判断：

// 典型的反模式：巨石 if-else 分支
function calculateFinalPrice(price, type, params) {
  if (type === 'FULL_REDUCTION') {
    if (price >= params.threshold) {
      return price - params.reduction;
    }
    return price;
  } else if (type === 'DISCOUNT') {
    return price * params.discountRate;
  } else if (type === 'DIRECT_COUPON') {
    return Math.max(0, price - params.amount);
  } else if (type === 'TIERED_DISCOUNT') {
    // 阶梯满折：满2件8折，满3件7折...
    // 逻辑不断向内堆砌
  }
  return price;
}

随着业务演进，此类代码会迅速暴露以下核心缺陷：

• 违反开闭原则（OCP）：每当运营上线一种新玩法（如“跨店满减”、“品类立减券”、“预售定金膨胀”），开发者都必须修改核心的 calculateFinalPrice 函数。每一次改动都可能对原本稳定的旧规则造成意外破坏。
• 圈复杂度飙升：各个优惠逻辑的参数结构不同、校验要求不同，多层嵌套条件令函数行数轻松突破数百行，阅读与维护成本极高。
• 单元测试困难：要测试一个新策略，测试用例必须覆盖整个函数的全部上下文入参，无法对单一促销规则进行无副作用的独立测试。

图 1：促销计算逻辑在重构前后的架构与职责对比

二、策略模式的落地四步法

策略模式的核心定义是：定义一系列算法，将每一个算法封装起来，并使它们可以互相替换。在传统面向对象语言（如 Java 或 C++）中，通常需要定义一个接口抽象类和一系列实现类。而在 JavaScript 中，函数是一等公民，策略模式的实现更加轻量优雅。我们可以通过以下四个明确步骤完成重构：

图 2：重构促销计算逻辑的具体实施步骤与分层职责

第 1 步：抽象策略统一入参出参契约

所有具体的促销策略函数，必须保持完全一致的签名形式：strategy(price, params)。其中 price 为当前待计算的订单基准金额（数值类型），params 为该策略所需的私有配置对象（例如满减门槛、打折比例等）。返回值为经过该策略计算后的折后金额。统一接口保证了策略之间的可替换性。

第 2 步：将促销算法编写为纯函数

策略函数不应修改外部传入的对象，也不依赖外部全局变量。只要输入相同，输出就必定相同。这为前端单元测试和异常隔离提供了天然屏障。

第 3 步：建立策略映射字典（Strategy Map）

利用 JavaScript 的对象键值或 Map 结构存放促销类型常量与函数的映射关系，直接通过属性索引获取对应策略，取代冗长的 if-else 分支。

第 4 步：封装上下文类（PromotionContext）

上下文类充当业务模块与具体策略之间的门面，负责调用前的入参边界校验、策略未命中时的容错兜底、计算过程中的异常捕获，以及结果的精度格式化。

三、完整的重构代码实现

以下是使用现代化 JavaScript (ES6+) 实现的完整促销重构模块代码。代码包含策略注册表、上下文控制器及使用示例，可直接在 Node.js 或前端项目中执行：

/**
 * 1. 促销策略集合 (Strategies)
 * 每个策略都是入参可预测、无副作用的纯函数
 */
const promotionStrategies = {
  // 满减策略：例如满 300 减 40
  FULL_REDUCTION(price, { threshold = 0, reduction = 0 } = {}) {
    if (price >= threshold) {
      return Math.max(0, price - reduction);
    }
    return price;
  },

  // 折扣策略：例如打 85 折 (discountRate: 0.85)
  DISCOUNT(price, { discountRate = 1 } = {}) {
    const validRate = (discountRate > 0 && discountRate <= 1) ? discountRate : 1;
    return price * validRate;
  },

  // 直减抵用券策略：直接减去券面金额，最低降至 0 元
  DIRECT_COUPON(price, { amount = 0 } = {}) {
    return Math.max(0, price - amount);
  },

  // 阶梯满减策略：根据金额从高到低匹配最高档位
  TIERED_REDUCTION(price, { tiers = [] } = {}) {
    // 阶梯配置格式：[{ threshold: 1000, reduction: 200 }, { threshold: 500, reduction: 80 }]
    const matchedTier = [...tiers]
      .sort((a, b) => b.threshold - a.threshold)
      .find(tier => price >= tier.threshold);

    return matchedTier ? Math.max(0, price - matchedTier.reduction) : price;
  }
};

/**
 * 2. 促销计算上下文类 (Context)
 * 负责分发调度、参数校验与降级保护
 */
class PromotionContext {
  constructor(initialStrategies = {}) {
    // 浅拷贝内置策略字典，避免外部意外污染
    this.strategies = { ...initialStrategies };
  }

  // 允许动态注册新促销策略 (符合开闭原则)
  register(type, strategyFn) {
    if (typeof strategyFn !== 'function') {
      throw new TypeError(`注册失败：策略 [${type}] 的处理器必须为函数`);
    }
    this.strategies[type] = strategyFn;
  }

  // 检查是否支持某策略
  has(type) {
    return Boolean(this.strategies[type]);
  }

  // 执行价格计算
  calculate(price, type, params = {}) {
    // 基础入参防御性校验
    if (typeof price !== 'number' || Number.isNaN(price) || price < 0) {
      throw new TypeError('计算失败：订单基础金额必须为非负数值');
    }

    const strategy = this.strategies[type];

    // 容错处理：未识别的促销类型，采用原价兜底，避免流程阻断
    if (!strategy) {
      console.warn(`[促销警告] 未找到类型为 [${type}] 的计算策略，已按原价兜底返回。`);
      return price;
    }

    try {
      const calculated = strategy(price, params);
      // 处理浮点数精度，统一保留两位小数，且最低为 0
      return Math.max(0, Math.round(calculated * 100) / 100);
    } catch (error) {
      console.error(`[促销异常] 策略 [${type}] 执行出错:`, error);
      return price; // 异常时回退原价，确保结算主链路安全
    }
  }
}

// ---------------------------
// 3. 实际业务调用与验证示例
// ---------------------------
const calculator = new PromotionContext(promotionStrategies);

const basePrice = 1200;

// 场景 A：满 1000 减 150
const priceA = calculator.calculate(basePrice, 'FULL_REDUCTION', {
  threshold: 1000,
  reduction: 150
});
console.log('满减后金额:', priceA); // 输出: 1050

// 场景 B：限时 88 折
const priceB = calculator.calculate(basePrice, 'DISCOUNT', {
  discountRate: 0.88
});
console.log('打折后金额:', priceB); // 输出: 1056

// 场景 C：无缝扩展业务新规则（如定金 50 抵扣 200 的预售膨胀玩法）
calculator.register('DEPOSIT_EXPAND', (price, { deposit = 0, expansion = 0 } = {}) => {
  return Math.max(0, price - expansion + deposit);
});

const priceC = calculator.calculate(basePrice, 'DEPOSIT_EXPAND', {
  deposit: 50,
  expansion: 200
});
console.log('定金膨胀后金额:', priceC); // 输出: 1050

四、进阶实战：多重促销叠加与流水线机制

真实电商结算场景往往比单一优惠更加复杂。用户常常同时享有“跨店满减”、“店铺代金券”以及“金币/积分抵扣”。多项促销不是非此即彼，而是按照既定的业务优先级链式叠加计算。

借助策略模式，我们可以轻松实现一个基于管道流水线（Pipeline）的多促销叠加处理器：前一个策略的折后输出，作为下一个策略的输入基数，并自动记录每一步的抵扣明细。

图 3：多重促销链式计算流水线与优惠明细追溯模型

流水线计算器代码实现

流水线类复用前文的 PromotionContext，通过迭代执行策略队列并维护折后基数：

/**
 * 促销组合流水线
 */
class PromotionPipeline {
  constructor(context) {
    this.context = context;
  }

  /**
   * 顺序执行多项优惠计算
   * @param {number} originalPrice 订单原始金额
   * @param {Array} promotions 促销规则列表 [{ type, params, priority }]
   */
  execute(originalPrice, promotions = []) {
    // 按照指定优先级升序排序 (优先级数值越小越先执行)
    const sortedPromos = [...promotions].sort((a, b) => (a.priority || 0) - (b.priority || 0));

    let currentPrice = originalPrice;
    const breakdown = [];

    for (const promo of sortedPromos) {
      if (currentPrice <= 0) {
        // 金额已减至 0，跳过后续所有扣减策略
        breakdown.push({
          type: promo.type,
          deduction: 0,
          currentPrice: 0,
          status: 'SKIPPED_ZERO_PRICE'
        });
        continue;
      }

      const beforePrice = currentPrice;
      currentPrice = this.context.calculate(currentPrice, promo.type, promo.params);
      
      const deduction = Math.round((beforePrice - currentPrice) * 100) / 100;
      breakdown.push({
        type: promo.type,
        deduction,
        currentPrice,
        status: 'APPLIED'
      });
    }

    return {
      originalPrice,
      finalPrice: currentPrice,
      totalDiscount: Math.round((originalPrice - currentPrice) * 100) / 100,
      breakdown
    };
  }
}

// 使用示例
const pipeline = new PromotionPipeline(calculator);

const orderPromotions = [
  { type: 'FULL_REDUCTION', params: { threshold: 1000, reduction: 150 }, priority: 10 },
  { type: 'DIRECT_COUPON', params: { amount: 50 }, priority: 20 },
  { type: 'DISCOUNT', params: { discountRate: 0.95 }, priority: 30 }
];

const bill = pipeline.execute(1000, orderPromotions);
console.log('账单结算结果:', bill);
/*
输出结果：
{
  originalPrice: 1000,
  finalPrice: 760,
  totalDiscount: 240,
  breakdown: [
    { type: 'FULL_REDUCTION', deduction: 150, currentPrice: 850, status: 'APPLIED' },
    { type: 'DIRECT_COUPON', deduction: 50, currentPrice: 800, status: 'APPLIED' },
    { type: 'DISCOUNT', deduction: 40, currentPrice: 760, status: 'APPLIED' }
  ]
}
*/

五、生产环境重构注意事项与避坑指南

将促销逻辑重构为策略模式时，除了算法结构的调整，还需严格处理以下电商领域的实际工程问题：

图 4：JavaScript 策略模式重构方案落地总结与演进方向

六、总结

电商促销计算往往是业务迭代最频繁、逻辑最容易失控的重灾区。通过采用策略模式重构：

1. 消灭深层分支：将各异的计算过程分散收敛到独立的纯函数中；
2. 构建统一上下文：通过 PromotionContext 抹平参数差异，统一处理精度与异常兜底；
3. 灵活组合叠加：借助流水线机制有序串联各项优惠，清晰追溯优惠账单明细。

这种解耦方式不仅让代码结构层次清晰，而且彻底消除了“修改一条新规则引发原有功能异常”的风险，为电商业务的高速演进提供了坚实的底层代码架构支撑。