如何在JavaScript/TypeScript中记录复杂布尔表达式的失败原因？

JavaScript/TypeScript 没有原生特性可以直接提取已执行布尔表达式的具体失败分支——因为表达式执行后仅保留布尔结果，原始的表达式结构已经丢失。要实现你要的效果，需要通过包装条件逻辑的方式，逐个验证并记录失败的条件。以下是几种实用方案：

1. 手动拆分条件并附带描述（最可靠） #

把每个链式条件拆成独立的测试项，每个测试项包含判断逻辑和对应的失败描述，逐个执行直到找到第一个失败的条件。这种方式清晰可控，适合生产环境，TypeScript 还能提供完整的类型约束。

function validateConditions<T>(target: T, conditions: Array<{
  test: (obj: T) => boolean;
  errorMsg: string;
}>) {
  for (const cond of conditions) {
    if (!cond.test(target)) {
      return { pass: false, error: `error: ${cond.errorMsg} evaluated to false` };
    }
  }
  return { pass: true };
}

// 使用示例
const a = { foo: 1, bar: 4 };
function someOtherPredicate(val: number) {
  return val > 0;
}

const result = validateConditions(a, [
  { test: o => o.foo === 1, errorMsg: 'a.foo == 1' },
  { test: o => o.bar < 3, errorMsg: 'a.bar < 3' },
  { test: o => someOtherPredicate(o.bar), errorMsg: 'someOtherPredicate(a.bar)' }
]);

if (!result.pass) {
  console.log(result.error); // 输出：error: a.bar < 3 evaluated to false
}

2. 利用函数toString()自动生成描述（开发环境友好） #

JavaScript 函数的toString()方法（多数环境下）会返回函数的源码，我们可以通过解析箭头函数的源码，自动提取判断表达式，省去手动写描述的麻烦。注意：此方法在代码被压缩混淆后会失效，仅适合开发环境。

function getExprFromTestFn<T>(testFn: (obj: T) => boolean): string {
  const fnStr = testFn.toString().trim();
  // 匹配箭头函数的表达式部分，比如 o => o.bar < 3 → 提取 o.bar < 3
  const match = fnStr.match(/^\s*\w+\s*=>\s*(.+)$/);
  return match ? match[1] : fnStr;
}

function autoValidateConditions<T>(target: T, tests: Array<(obj: T) => boolean>) {
  for (const test of tests) {
    if (!test(target)) {
      const expr = getExprFromTestFn(test);
      return { pass: false, error: `error: ${expr} evaluated to false` };
    }
  }
  return { pass: true };
}

// 使用示例
const result = autoValidateConditions(a, [
  o => o.foo === 1,
  o => o.bar < 3,
  o => someOtherPredicate(o.bar)
]);

if (!result.pass) {
  console.log(result.error); // 输出：error: o.bar < 3 evaluated to false
}

3. Proxy拦截对象属性判断（特定场景适用） #

如果你的条件大多是针对对象属性的比较，可以用Proxy拦截属性访问，自定义判断方法（如eq、lt）来自动记录失败信息。这种方式侵入性较强，但能实现高度自动化的追踪。

function createTrackedObj<T>(obj: T, onFail: (expr: string) => void): T {
  return new Proxy(obj, {
    get(target, prop) {
      const value = Reflect.get(target, prop);
      // 针对数字类型扩展判断方法
      if (typeof value === 'number') {
        return {
          eq(num: number) {
            const isValid = value === num;
            if (!isValid) onFail(`${String(prop)} == ${num}`);
            return isValid;
          },
          lt(num: number) {
            const isValid = value < num;
            if (!isValid) onFail(`${String(prop)} < ${num}`);
            return isValid;
          }
        };
      }
      // 其他类型可按需扩展
      return value;
    }
  }) as unknown as T;
}

// 使用示例
let errorMsg = '';
const trackedA = createTrackedObj(a, (expr) => {
  errorMsg = `error: a.${expr} evaluated to false`;
});

const isValid = trackedA.foo.eq(1) && trackedA.bar.lt(3) && someOtherPredicate(a.bar);
if (!isValid && errorMsg) {
  console.log(errorMsg); // 输出：error: a.bar < 3 evaluated to false
}

总结 #

• 生产环境优先用手动拆分条件的方案，稳定可靠；
• 开发环境可以用函数toString()自动提取表达式，减少重复代码；
• Proxy方案适合需要高度自动化追踪对象属性判断的特定场景。

内容的提问来源于stack exchange，提问作者Nathan