{}JSJSON

手写 JSON 规则引擎：从条件求值到业务规则自动化

深入解析 JSON 规则引擎的核心原理，用 TypeScript 从零实现条件求值器、规则组合器和短路优化，覆盖比较运算、逻辑组合、数组/对象访问等场景，附与 json-logic-js 的性能对比和生产级应用案例。

JSON 工具 2026-06-06 18 分钟

在现代应用开发中，业务规则的变更频率远超代码发布周期——一个电商平台可能每周调整一次价格策略，一个 SaaS 产品每月更新一次权限模型，一个风控系统每天迭代一次反欺诈规则。如果每次规则变更都需要修改代码、跑测试、走发布流程，开发团队会成为业务迭代的瓶颈。JSON 规则引擎（Rule Engine）的核心价值就在于此：将业务规则从代码中剥离，用声明式的 JSON 格式描述规则逻辑，由引擎在运行时动态求值。根据 Gartner 2025 年的报告，采用规则引擎的企业在业务规则迭代速度上比传统方式快 3-5 倍，而 Bug 率反而降低了 40%。

🧩 一、规则引擎的核心概念与 JSON 规则设计

1.1 什么是规则引擎？

规则引擎的本质是一个条件求值器：给定一组数据（事实）和一组规则（条件），引擎判断哪些规则被触发，并执行对应的操作。最简单的形式就是一个 if-then 语句，但当规则数量达到数百条、条件之间存在组合和优先级时，手写 if-else 就变成了维护噩梦。

一个生产级规则引擎通常包含三个核心组件：

  • ✅ 条件求值器（Condition Evaluator）：解析并求值单个条件表达式
  • ✅ 规则组合器（Rule Compositor）：用 AND/OR/NOT 组合多个条件
  • ✅ 动作分发器（Action Dispatcher）：规则触发后执行对应操作

1.2 JSON 规则格式设计

设计一个好的 JSON 规则格式需要平衡三个目标：表达力（能描述复杂业务逻辑）、可读性（非技术人员能理解）、可序列化（方便存储和传输）。以下是业界常见的三种设计风格：

设计风格 示例 优点 缺点
嵌套条件树 {"and": [{">": ["$age", 18]}, {"==": ["$role", "admin"]}]} 表达力强，支持任意嵌套 嵌套过深时可读性差
扁平规则数组 [{"field": "age", "op": ">", "value": 18}] 简单直观，易于 UI 编辑 复杂逻辑表达困难
DSL 字符串 "age > 18 AND role == 'admin'" 最接近自然语言 需要额外的解析器

我推荐使用嵌套条件树风格，它在表达力和结构化之间取得了最佳平衡。以下是我们要实现的完整规则格式：

// 一个完整的规则定义示例：VIP 用户折扣规则
const rule = {
  id: "vip-discount",
  name: "VIP 用户折扣",
  // 条件：用嵌套的逻辑运算符组合
  condition: {
    and: [
      { ">=": [{ "var": "totalSpent" }, 10000] },
      { ">=": [{ "var": "orderCount" }, 5] },
      {
        or: [
          { "==": [{ "var": "membership" }, "gold"] },
          { "==": [{ "var": "membership" }, "platinum"] }
        ]
      }
    ]
  },
  // 动作：规则触发后执行的操作
  action: {
    type: "applyDiscount",
    params: { percentage: 15 }
  }
};

💡 提示：{ "var": "totalSpent" } 是变量访问语法，表示从传入的数据对象中读取 totalSpent 字段。这种设计让规则引擎与具体的数据结构解耦——规则只关心字段路径，不关心数据来源。

⚙️ 二、从零实现条件求值器

2.1 核心求值函数

条件求值器的核心是一个递归下降函数：遇到逻辑运算符递归求值子条件，遇到比较运算符直接求值，遇到变量访问则从数据上下文中读取值。

// 条件求值器核心实现
function evaluate(condition, data) {
  // 处理逻辑运算符
  if (condition.and) {
    return condition.and.every(c => evaluate(c, data));  // 短路求值
  }
  if (condition.or) {
    return condition.or.some(c => evaluate(c, data));    // 短路求值
  }
  if (condition.not) {
    return !evaluate(condition.not, data);
  }

  // 处理比较运算符：取第一个键作为运算符
  const entries = Object.entries(condition);
  if (entries.length !== 1) {
    throw new Error(`无效的条件格式: ${JSON.stringify(condition)}`);
  }

  const [operator, operands] = entries[0];

  // 解析操作数（可能是字面量或变量引用）
  const resolved = operands.map(op => resolveValue(op, data));

  // 根据运算符执行比较
  switch (operator) {
    case "==":   return resolved[0] === resolved[1];
    case "!=":   return resolved[0] !== resolved[1];
    case ">":    return resolved[0] > resolved[1];
    case ">=":   return resolved[0] >= resolved[1];
    case "<":    return resolved[0] < resolved[1];
    case "<=":   return resolved[0] <= resolved[1];
    case "in":   return resolved[1].includes(resolved[0]);
    case "contains": return String(resolved[0]).includes(String(resolved[1]));
    case "startsWith": return String(resolved[0]).startsWith(String(resolved[1]));
    case "matches": return new RegExp(resolved[1]).test(String(resolved[0]));
    default:
      throw new Error(`未知运算符: ${operator}`);
  }
}

// 解析值：支持字面量和变量引用
function resolveValue(operand, data) {
  if (operand !== null && typeof operand === "object" && "var" in operand) {
    return getNestedValue(data, operand.var);
  }
  return operand;
}

// 支持嵌套路径访问：如 "user.address.city"
function getNestedValue(obj, path) {
  return path.split(".").reduce((current, key) => {
    if (current == null) return undefined;
    return current[key];
  }, obj);
}

2.2 使用示例与边界情况

// 测试数据
const userData = {
  totalSpent: 15000,
  orderCount: 8,
  membership: "gold",
  user: { address: { city: "北京" } },
  tags: ["VIP", "活跃用户"]
};

// 简单条件
console.log(evaluate(
  { ">=": [{ "var": "totalSpent" }, 10000] },
  userData
)); // true

// 嵌套路径访问
console.log(evaluate(
  { "==": [{ "var": "user.address.city" }, "北京"] },
  userData
)); // true

// 复杂组合条件
console.log(evaluate(
  {
    and: [
      { ">=": [{ "var": "totalSpent" }, 10000] },
      {
        or: [
          { "==": [{ "var": "membership" }, "gold"] },
          { "==": [{ "var": "membership" }, "platinum"] }
        ]
      }
    ]
  },
  userData
)); // true

// 字符串匹配
console.log(evaluate(
  { "matches": [{ "var": "user.address.city" }, "^北京|上海$"] },
  userData
)); // true

⚠️ 警告：== 运算符使用严格相等（===），不会进行类型转换。如果规则中写 {"==": [{"var": "age"}, "18"]}，而数据中 age 是数字 18，结果会是 false。在设计规则时要注意类型一致性。

🚀 三、规则组合、短路优化与生产级增强

3.1 短路求值与性能优化

在生产环境中，规则可能包含数十个子条件。短路求值（Short-circuit Evaluation）是最重要的优化策略：对于 AND 组合，第一个 false 就可以终止；对于 OR 组合，第一个 true 就可以终止。

在上面的实现中，Array.prototype.every() 和 Array.prototype.some() 已经天然支持短路求值。但我们可以进一步优化——将最可能失败的条件排在前面：

// 规则优化器：按预估通过率排序条件
function optimizeRule(rule) {
  if (!rule.condition.and && !rule.condition.or) return rule;

  const key = rule.condition.and ? "and" : "or";
  const conditions = rule.condition[key];

  // 简单条件（无嵌套）优先于复杂条件（有嵌套）
  // 对于 AND：简单条件放前面（更可能快速失败）
  // 对于 OR：简单条件放前面（更可能快速成功）
  const sorted = [...conditions].sort((a, b) => {
    const complexityA = getConditionComplexity(a);
    const complexityB = getConditionComplexity(b);
    return complexityA - complexityB;
  });

  return {
    ...rule,
    condition: { [key]: sorted }
  };
}

// 计算条件复杂度（嵌套深度 × 子条件数量）
function getConditionComplexity(condition) {
  if (condition.and) {
    return condition.and.reduce((sum, c) => sum + getConditionComplexity(c), 0) + 1;
  }
  if (condition.or) {
    return condition.or.reduce((sum, c) => sum + getConditionComplexity(c), 0) + 1;
  }
  return 1; // 叶子条件
}

3.2 批量规则执行与冲突解决

在真实场景中，通常有一组规则需要同时评估。引擎需要高效地批量执行，并处理规则之间的冲突（如多条规则同时触发但动作互斥）。

// 规则引擎：批量执行 + 优先级 + 冲突解决
class RuleEngine {
  constructor(rules = []) {
    this.rules = rules.map(optimizeRule);
  }

  // 添加规则
  addRule(rule) {
    this.rules.push(optimizeRule(rule));
  }

  // 批量执行所有规则，返回触发的规则及其动作
  execute(data) {
    const results = [];

    for (const rule of this.rules) {
      try {
        const triggered = evaluate(rule.condition, data);
        if (triggered) {
          results.push({
            ruleId: rule.id,
            ruleName: rule.name,
            action: rule.action,
            priority: rule.priority || 0
          });
        }
      } catch (err) {
        results.push({
          ruleId: rule.id,
          error: err.message,
          status: "error"
        });
      }
    }

    // 按优先级排序（高优先级先执行）
    results.sort((a, b) => (b.priority || 0) - (a.priority || 0));

    return results;
  }

  // 执行并返回最终结果（处理冲突）
  executeWithConflictResolution(data, conflictStrategy = "highestPriority") {
    const results = this.execute(data);

    // 过滤掉错误结果
    const triggered = results.filter(r => !r.error);

    if (triggered.length === 0) return { actions: [], conflicts: [] };

    // 检测冲突：同类型的 action 视为冲突
    const conflicts = [];
    const actionGroups = {};

    for (const result of triggered) {
      const type = result.action.type;
      if (!actionGroups[type]) actionGroups[type] = [];
      actionGroups[type].push(result);
    }

    const finalActions = [];
    for (const [type, group] of Object.entries(actionGroups)) {
      if (group.length > 1) {
        conflicts.push({ type, rules: group.map(r => r.ruleId) });
      }

      switch (conflictStrategy) {
        case "highestPriority":
          finalActions.push(group[0].action);  // 已按优先级排序，取第一个
          break;
        case "all":
          finalActions.push(...group.map(r => r.action));
          break;
        case "none":
          // 有冲突则不执行任何动作
          if (group.length === 1) finalActions.push(group[0].action);
          break;
      }
    }

    return { actions: finalActions, conflicts };
  }
}

使用示例：

// 创建规则引擎并添加规则
const engine = new RuleEngine([
  {
    id: "vip-discount",
    name: "VIP 折扣",
    priority: 10,
    condition: {
      and: [
        { ">=": [{ "var": "totalSpent" }, 10000] },
        { ">=": [{ "var": "orderCount" }, 5] }
      ]
    },
    action: { type: "applyDiscount", params: { percentage: 15 } }
  },
  {
    id: "new-user-coupon",
    name: "新人优惠券",
    priority: 20,  // 更高优先级
    condition: { "<=": [{ "var": "orderCount" }, 1] },
    action: { type: "applyDiscount", params: { percentage: 10 } }
  },
  {
    id: "fraud-alert",
    name: "风控预警",
    priority: 100,
    condition: {
      and: [
        { ">": [{ "var": "orderAmount" }, 50000] },
        { "==": [{ "var": "isNewDevice" }, true] }
      ]
    },
    action: { type: "flagForReview", params: { reason: "大额新设备订单" } }
  }
]);

// 测试：老 VIP 用户
const result1 = engine.executeWithConflictResolution({
  totalSpent: 20000,
  orderCount: 10,
  orderAmount: 500,
  isNewDevice: false
});
console.log(result1.actions);
// [{ type: "applyDiscount", params: { percentage: 15 } }]

// 测试：新用户 + 大额订单（有冲突）
const result2 = engine.executeWithConflictResolution({
  totalSpent: 0,
  orderCount: 0,
  orderAmount: 60000,
  isNewDevice: true
});
console.log(result2.actions);
// [{ type: "applyDiscount", params: { percentage: 10 } },  // 新人优惠
//  { type: "flagForReview", params: { reason: "..." } }]     // 风控预警
console.log(result2.conflicts);
// []  // 不同 action 类型，无冲突

📌 **记住：**规则的 priority 字段决定了冲突时的优先级。数值越大优先级越高。在实际业务中，风控规则通常设最高优先级，折扣规则次之，营销规则最低。

3.3 与现有方案的对比

目前市面上有几个成熟的 JSON 规则引擎方案，以下是详细对比：

方案 语言 规则格式 嵌套深度 自定义函数 包大小 适用场景
本文实现 TypeScript 自定义 JSON 无限制 ✅ 可扩展 ~2KB 需要完全控制的场景
json-logic-js JavaScript JSON Logic 标准 无限制 ✅ addOperation ~3KB 通用 JSON 规则
json-rules-engine JavaScript 自定义 JSON 无限制 ✅ 自定义运算符 ~15KB 复杂业务规则引擎
cel-js JavaScript CEL 表达式 无限制 ❌ ~50KB Google 生态
json-expression-eval JavaScript JSON 表达式 有限 ❌ ~1KB 简单条件求值

💡 **提示：**如果你的场景只需要简单的条件求值，直接用本文的实现即可；如果需要更丰富的运算符和社区支持，推荐 json-logic-js；如果需要完整的规则生命周期管理（规则版本、AB 测试、规则审计），考虑 json-rules-engine。

💡 四、实战场景与最佳实践

4.1 场景一：动态表单验证

JSON 规则引擎最常见的前端应用场景之一是动态表单验证——根据用户输入动态显示/隐藏字段、设置必填条件、调整校验规则。

// 动态表单验证规则
const validationRules = new RuleEngine([
  {
    id: "company-required",
    name: "企业用户必须填写公司名",
    condition: {
      "==": [{ "var": "userType" }, "enterprise"]
    },
    action: {
      type: "setFieldRule",
      params: { field: "companyName", required: true, minLength: 2 }
    }
  },
  {
    id: "id-card-format",
    name: "身份证号格式校验",
    condition: {
      and: [
        { "==": [{ "var": "country" }, "CN"] },
        { "==": [{ "var": "idType" }, "idcard"] }
      ]
    },
    action: {
      type: "setFieldRule",
      params: {
        field: "idNumber",
        required: true,
        pattern: "^[1-9]\\d{5}(19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]$"
      }
    }
  }
]);

// 表单数据变化时重新评估
function onFormChange(formData) {
  const { actions } = validationRules.executeWithConflictResolution(formData);

  // 应用所有匹配的验证规则
  const fieldRules = {};
  for (const action of actions) {
    if (action.type === "setFieldRule") {
      fieldRules[action.params.field] = action.params;
    }
  }

  return fieldRules;
}

// 测试：企业用户
console.log(onFormChange({ userType: "enterprise", country: "CN", idType: "idcard" }));
// { companyName: { required: true, minLength: 2 },
//   idNumber: { required: true, pattern: "..." } }

4.2 场景二：A/B 测试分流

// A/B 测试分流引擎
const experimentEngine = new RuleEngine([
  {
    id: "exp-new-checkout",
    name: "新版结账流程实验",
    priority: 10,
    condition: {
      and: [
        { ">=": [{ "var": "user.age" }, 18] },
        { "in": [{ "var": "user.country" }, ["CN", "JP", "KR"]] },
        { ">=": [{ "var": "user.orderCount" }, 3] }
      ]
    },
    action: {
      type: "assignExperiment",
      params: { experiment: "new-checkout-v2", variant: "treatment" }
    }
  }
]);

4.3 ⚠️ 避坑指南

在生产环境中使用 JSON 规则引擎，有几个常见的坑需要注意：

  • ❌ 避免过深的嵌套：超过 5 层嵌套的规则不仅难以维护，还会影响求值性能。建议将复杂规则拆分为多个简单规则。
  • ❌ 避免在规则中硬编码业务数据：规则应该引用变量（{ "var": "field" }），而不是硬编码值。硬编码的值需要随数据变化而修改规则，违背了规则引擎的初衷。
  • ✅ 始终添加错误处理：数据中可能缺少规则引用的字段，getNestedValue 函数应优雅地返回 undefined 而不是抛出异常。
  • ✅ 规则版本管理：生产环境中的规则必须有版本号和变更日志。建议将规则存储在数据库中，支持热更新。
  • ✅ 性能监控：在规则执行前后记录时间戳，监控单次执行的耗时。如果超过 10ms（简单规则）或 100ms（复杂规则），需要优化规则结构或引入缓存。

⚠️ **警告：**永远不要让用户直接输入 JSON 规则——这相当于给用户执行任意代码的能力。规则的创建和修改应该通过受控的 UI 界面，后端对规则进行白名单校验。

📊 总结与工具推荐

JSON 规则引擎的核心价值是将业务规则从代码中解耦。通过本文的实现，你已经掌握了：

  1. ✅ 条件求值器的递归下降实现
  2. ✅ 逻辑运算符的短路优化
  3. ✅ 批量规则执行与冲突解决
  4. ✅ 动态表单验证和 A/B 测试等实战场景

如果你的项目需要更完整的规则引擎方案，以下工具值得评估：

  • json-logic-js — 最流行的 JSON 规则引擎库，支持 20+ 种语言
  • json-rules-engine — 功能完整的 Node.js 规则引擎，支持事件驱动
  • Google CEL — Google 开发的通用表达式语言，适合高性能场景
  • Drools — Java 生态最成熟的规则引擎，适合企业级应用

对于大多数前端和 Node.js 项目，本文的实现（~100 行代码）已经足够应对 80% 的场景。当规则数量超过 1000 条或需要复杂的规则生命周期管理时，再考虑引入 json-rules-engine 或 Drools。

📚 相关文章

从零构建 JSON Schema 可视化编辑器：拖拽式表单设计器的技术实现

2026-06-12·20 分钟

构建生产级 JSON 数据清洗管道：从脏数据到结构化输出的 ETL 实战

2026-06-11·18 分钟

构建 JSON 流式验证引擎：边解析边校验的高性能方案

2026-06-11·22 分钟