如何构建一个基于规则引擎的JavaScript决策系统？

在业务开发中，我们经常会遇到需要根据多个条件组合做出决策的场景，比如电商平台的优惠券核销、风控系统的风险判定等。如果把这些决策逻辑直接写在业务代码里，一旦规则发生变化就需要修改代码、重新发布，维护成本很高。基于规则引擎的JavaScript决策系统可以把决策逻辑抽象成可配置的规则，实现决策逻辑的动态调整，不需要修改核心业务代码。

规则引擎的核心组成

一个基础的规则引擎通常包含以下几个核心部分：

• 规则定义模块：负责定义规则的结构，明确规则的条件和对应的执行动作
• 规则解析模块：读取配置的规则，将其转换为引擎可识别的内部结构
• 规则匹配模块：根据输入的上下文数据，匹配满足条件的规则
• 动作执行模块：执行匹配到的规则对应的动作，返回决策结果

规则的数据结构设计

首先我们需要定义规则的通用结构，一条规则通常包含规则ID、规则名称、条件集合、执行动作、优先级等字段。条件部分支持多条件组合，我们可以借鉴布尔逻辑的设计，支持与、或、非三种逻辑运算。

// 规则的基础结构定义
const ruleExample = {
  id: 'rule_001',
  name: '新用户首单满减规则',
  // 条件集合，支持组合条件
  conditions: {
    logic: 'and', // 逻辑运算符，支持and、or、not
    items: [
      { field: 'isNewUser', operator: 'eq', value: true },
      { field: 'orderAmount', operator: 'gte', value: 100 }
    ]
  },
  // 匹配成功后执行的动作
  action: {
    type: 'discount',
    params: { discountAmount: 20 }
  },
  priority: 1 // 规则优先级，数值越小优先级越高
};

条件匹配逻辑实现

条件匹配是规则引擎的核心，我们需要根据条件中的字段、运算符和输入值判断是否满足条件。首先实现一个单个条件的匹配函数，再处理组合条件的逻辑运算。

/**
 * 单个条件匹配
 * @param {Object} condition 单个条件对象，包含field、operator、value
 * @param {Object} context 输入的上下文数据
 * @returns {boolean} 是否匹配
 */
function matchSingleCondition(condition, context) {
  const { field, operator, value } = condition;
  const fieldValue = context[field];
  switch (operator) {
    case 'eq': // 等于
      return fieldValue === value;
    case 'neq': // 不等于
      return fieldValue !== value;
    case 'gt': // 大于
      return fieldValue > value;
    case 'gte': // 大于等于
      return fieldValue >= value;
    case 'lt': // 小于
      return fieldValue < value;
    case 'lte': // 小于等于
      return fieldValue <= value;
    case 'in': // 包含于数组
      return Array.isArray(value) && value.includes(fieldValue);
    case 'notin': // 不包含于数组
      return Array.isArray(value) && !value.includes(fieldValue);
    default:
      return false;
  }
}

/**
 * 组合条件匹配
 * @param {Object} conditions 组合条件对象，包含logic和items
 * @param {Object} context 输入的上下文数据
 * @returns {boolean} 是否匹配
 */
function matchConditions(conditions, context) {
  const { logic, items } = conditions;
  if (logic === 'and') {
    return items.every(item => {
      if (item.logic) {
        return matchConditions(item, context);
      }
      return matchSingleCondition(item, context);
    });
  }
  if (logic === 'or') {
    return items.some(item => {
      if (item.logic) {
        return matchConditions(item, context);
      }
      return matchSingleCondition(item, context);
    });
  }
  if (logic === 'not') {
    // not逻辑下items只有一个元素
    const item = items[0];
    if (item.logic) {
      return !matchConditions(item, context);
    }
    return !matchSingleCondition(item, context);
  }
  return false;
}

规则引擎核心类实现

我们把规则引擎的核心能力封装成一个类，支持规则的添加、规则匹配和决策执行。

class RuleEngine {
  constructor() {
    this.rules = []; // 存储所有规则
  }

  /**
   * 添加规则
   * @param {Object} rule 规则对象
   */
  addRule(rule) {
    this.rules.push(rule);
    // 按优先级排序，优先级高的规则先匹配
    this.rules.sort((a, b) => a.priority - b.priority);
  }

  /**
   * 批量添加规则
   * @param {Array} rules 规则数组
   */
  addRules(rules) {
    rules.forEach(rule => this.addRule(rule));
  }

  /**
   * 执行决策
   * @param {Object} context 输入的上下文数据
   * @returns {Array} 匹配到的动作数组
   */
  execute(context) {
    const matchedActions = [];
    for (const rule of this.rules) {
      const isMatch = matchConditions(rule.conditions, context);
      if (isMatch) {
        matchedActions.push(rule.action);
      }
    }
    return matchedActions;
  }
}

实际使用示例

下面我们模拟一个电商优惠券决策的场景，配置两条规则，然后输入用户上下文数据执行决策。

// 初始化规则引擎
const engine = new RuleEngine();

// 配置规则
const rules = [
  {
    id: 'rule_001',
    name: '新用户首单满100减20',
    conditions: {
      logic: 'and',
      items: [
        { field: 'isNewUser', operator: 'eq', value: true },
        { field: 'orderAmount', operator: 'gte', value: 100 }
      ]
    },
    action: { type: 'discount', params: { amount: 20 } },
    priority: 1
  },
  {
    id: 'rule_002',
    name: '老用户满200减30',
    conditions: {
      logic: 'and',
      items: [
        { field: 'isNewUser', operator: 'eq', value: false },
        { field: 'orderAmount', operator: 'gte', value: 200 }
      ]
    },
    action: { type: 'discount', params: { amount: 30 } },
    priority: 2
  }
];

engine.addRules(rules);

// 测试上下文1：新用户，订单金额150
const context1 = { isNewUser: true, orderAmount: 150 };
const result1 = engine.execute(context1);
console.log('上下文1匹配的动作：', result1); // 输出 [{type: 'discount', params: {amount: 20}}]

// 测试上下文2：老用户，订单金额250
const context2 = { isNewUser: false, orderAmount: 250 };
const result2 = engine.execute(context2);
console.log('上下文2匹配的动作：', result2); // 输出 [{type: 'discount', params: {amount: 30}}]

// 测试上下文3：新用户，订单金额50
const context3 = { isNewUser: true, orderAmount: 50 };
const result3 = engine.execute(context3);
console.log('上下文3匹配的动作：', result3); // 输出 []

扩展优化方向

上述实现是一个基础版本的决策系统，实际业务中还可以做更多扩展：

• 支持规则的热更新，不需要重启服务就能更新规则配置
• 增加规则冲突处理机制，当多条规则匹配时可以选择只执行最高优先级的规则，或者合并执行所有动作
• 添加规则执行日志，记录每条规则的匹配情况，方便排查问题
• 支持更复杂的运算符，比如正则匹配、自定义函数判断等

JavaScript规则引擎决策系统规则配置修改时间：2026-06-09 08:27:24