JS怎么递归判断深层嵌套对象是否为空？

在前端交互与表单清洗中，经常遇到由于用户部分操作而产生的深层嵌套对象。假设用户打开了商品筛选抽屉，勾选了规格分类后又取消了具体的标签输入，最终提交到前端状态管理中的数据结构往往类似于 { filter: { specs: {}, categories: [{}], meta: { keyword: "" } } }。如果此时直接使用 Object.keys(obj).length === 0，由于第一层存在键名 filter，常规浅层判空会直接返回 false，将空数据误当作有效筛选提交给后端。解决这一问题的核心思路是：运用深度优先搜索（DFS）进行递归检测——遇到对象或数组属性时继续向下探索；一旦探测到任何非空基本属性值，立即触发短路退出返回 false；若整棵属性树的所有分支均已探索完毕且只包含空容器，则最终判定该深层对象为空。

一、为什么常规浅层判空无法处理深层嵌套？

JavaScript 原生提供了多种检查对象自有属性的 API，最常见的便是 Object.keys()、Object.entries() 以及 Reflect.ownKeys()。这些 API 的共同特征是只读取当前对象自身的第一层属性，绝不会主动下钻到属性值内部。

当一个对象是由多个对象或数组层层包裹而成的“空壳”时，在浅层检查的视角下，外层对象实际上持有引用类型的键。例如：

// 示例执行环境：Node.js 或 现代浏览器控制台
const emptyPayload = {
  query: {
    pagination: {},
    conditions: [{}, []]
  }
};

// 浅层判空测试
console.log(Object.keys(emptyPayload).length === 0);
// 输出结果为 false，因为第一层包含键名 "query"

从上面的结果可以看出，浅层检查虽然性能极高（时间复杂度接近 O(1)），但其认知范围仅限于首层结构。如果试图借助 JSON.stringify(emptyPayload) 进行字符串序列化转换，不仅会耗费额外的内存与算力，而且空数组 [] 与空对象 {} 序列化后的字符串不一致，一旦对象中含有 undefined、函数或循环引用，JSON.stringify 更会直接丢失字段或抛出致命异常。

如上图所示，递归深层判空则会将嵌套对象视作一棵以属性为分支的树。只有将所有子分支展开并确认每个叶子节点均无实质内容后，才会逐层回溯判定整棵树为空。

二、基础递归思路：分层拆解与短路剪枝

设计一个递归判空函数，必须明确两大要素：基准条件（Base Case）与递归推进步（Recursive Step），并严格配合短路求值（Short-circuit Evaluation）以保障性能。

1. 推导执行逻辑

1. 类型与空值判定：如果传入的值不是对象（或者为 null），说明已经触及叶子节点，按照基本类型的空值规则直接返回判断结果。
2. 提取当前层键名：如果传入的是普通对象或数组，提取其自身拥有的全部可枚举属性。若键名长度为 0，说明当前层是纯粹的空对象 {} 或空数组 []，返回 true。
3. 递归下钻与短路：使用 for...of 循环遍历属性值。一旦发现子属性递归调用返回 false（即发现了实质数据），立即中断后续循环并返回 false。
4. 完整回溯：只有当所有子属性都成功通过判空检测，循环平稳结束时，才向外层返回 true。

2. 基础版本代码实现

按照上述推导，可以编写出基础的递归实现。此版本重点解决对象与数组的嵌套：

// 执行环境：ECMAScript 2015 (ES6) 及以上
function isBasicDeepEmpty(val) {
  // 1. 基准条件：非对象类型（包括 null）
  if (val === null || typeof val !== 'object') {
    // 基础定义：undefined、空字符串均视为空，其余基础值（如数字、布尔值）视为非空
    return val === undefined || val === '';
  }

  // 2. 提取当前对象或数组的全部自有可枚举键
  const keys = Object.keys(val);
  if (keys.length === 0) {
    return true; // 空对象 {} 或空数组 []
  }

  // 3. 递归遍历子属性（利用 for...of 支持随时 break / return 触发短路）
  for (const key of keys) {
    const subVal = val[key];
    // 只要有任意子节点不是空，整棵树就不是空
    if (!isBasicDeepEmpty(subVal)) {
      return false;
    }
  }

  // 4. 所有子节点均为深层空
  return true;
}

// 验证测试
const testA = { a: { b: { c: [] }, d: {} } };
const testB = { a: { b: { c: [{ id: 1 }] } } };

console.log('testA 判定结果:', isBasicDeepEmpty(testA));
console.log('testB 判定结果:', isBasicDeepEmpty(testB));

三、不可忽视的四大边界情况与安全防护

基础递归在处理结构规整的纯数据时表现良好，但在真实工业场景中，JavaScript 对象可能包含循环引用、特殊实例对象以及不同的业务空值标准。如果不做安全防护，程序极易陷入严重故障。

1. 循环引用导致的堆栈溢出（Stack Overflow）

当对象内部属性直接或间接引用了自身（例如 obj.child = obj）时，朴素递归会在引用环中无限递归，直到触发 RangeError: Maximum call stack size exceeded。解决循环引用的规范做法是引入 WeakSet 作为访问备忘录：在深入对象前检查是否已处于遍历链路中，若已访问过则直接退出该环路；WeakSet 不会产生强引用，不会造成额外的垃圾回收内存泄漏。

2. 特殊内置对象的误判

在 JavaScript 中，typeof new Date() 和 typeof /abc/g 的结果均为 "object"，但它们自身并没有可枚举属性（Object.keys(new Date()) 长度为 0）。如果按照普通对象处理，new Date() 会被错误地当成空对象；但实际上 Date 代表具体时间戳，RegExp 代表具体的正则规则。因此，必须对特殊内置类设立白名单或特化检查。

3. 严格模式与宽松模式的业务分歧

什么是“空”？不同业务场景的定义截然不同：

• 严格结构空（Strict Empty）：只有纯粹的 {}、[] 以及 undefined 算作空。字段值为 null、0、false 或 ""（空字符串）被视为用户主动填写的有效数据。
• 宽松表单空（Loose Empty）：在表单数据过滤或 HTTP 请求清洗场景下，null、""（空格或空字符串）通常被认定为无效无输入数据，需要连同嵌套容器一并视为空并剔除。

四、工业级通用递归判空函数实现与多场景验证

结合上述安全防护设计，下面给出一个健壮、生产可用的通用递归判空函数。该函数支持深度循环引用防爆栈、特殊类型过滤，并提供宽松/严格模式的自定义配置项。

/**
 * 递归判断深层嵌套对象是否为空
 * @param {*} target 待检测的目标值
 * @param {Object} [options] 配置项
 * @param {boolean} [options.loose=false] 是否启用宽松模式（为 true 时 null、""、空白字符串均视为空）
 * @param {WeakSet} [_seen] 内部递归使用的环引用追踪记录
 * @returns {boolean} 是否为空
 */
function isDeepEmpty(target, options = {}, _seen = new WeakSet()) {
  const { loose = false } = options;

  // 1. 处理 null 与 undefined
  if (target === undefined) return true;
  if (target === null) return loose; // 宽松模式下 null 视为空

  // 2. 处理原始基础类型 (string, number, boolean, symbol, bigint, function)
  if (typeof target !== 'object') {
    if (typeof target === 'string') {
      return loose ? target.trim().length === 0 : target.length === 0;
    }
    // 数字、布尔、BigInt、函数等具有确切业务语义，严格算非空
    return false;
  }

  // 3. 拦截特殊内置实例对象
  // Date, RegExp, Error 属于具体实体；NaN 等非容器对象不作为空容器对待
  if (target instanceof Date || target instanceof RegExp || target instanceof Error) {
    return false;
  }

  // 4. 处理 Map 与 Set 集合类型
  if (target instanceof Map || target instanceof Set) {
    if (target.size === 0) return true;
    for (const item of target.values()) {
      if (!isDeepEmpty(item, options, _seen)) return false;
    }
    return true;
  }

  // 5. 循环引用防护：如果当前对象正在当前遍历链路上，避免无限死循环
  if (_seen.has(target)) {
    // 已经遍历过当前节点所在的环，跳过对该重复节点的下钻
    return true;
  }
  _seen.add(target);

  // 6. 提取自身全部属性名（采用 Object.keys 处理常规数据属性）
  const keys = Object.keys(target);
  if (keys.length === 0) {
    return true;
  }

  // 7. 递归检查每一个子属性，短路快速失败
  for (let i = 0; i < keys.length; i++) {
    const key = keys[i];
    const childValue = target[key];

    // 一旦任一子属性为非空，直接返回 false，不再继续深究其他属性
    if (!isDeepEmpty(childValue, options, _seen)) {
      return false;
    }
  }

  return true;
}

用例覆盖测试

在 Node.js 或浏览器环境中执行以下测试套件，验证函数在不同边界场景下的判断输出：

// 场景 1：多层纯空结构
const case1 = { a: { b: [{ c: [] }, {}] }, d: {} };
console.log('Case 1 (纯多层空嵌套):', isDeepEmpty(case1));

// 场景 2：深层包含实际有效数值
const case2 = { a: { b: [{ c: [0] }] } };
console.log('Case 2 (深层包含数字 0):', isDeepEmpty(case2));

// 场景 3：表单空字符串在严格模式 vs 宽松模式
const case3 = { user: { name: "   ", note: null } };
console.log('Case 3 (严格模式下的空白字符):', isDeepEmpty(case3, { loose: false }));
console.log('Case 3 (宽松模式下的空白字符):', isDeepEmpty(case3, { loose: true }));

// 场景 4：循环引用对象
const circularObj = { list: [] };
circularObj.self = circularObj;
console.log('Case 4 (循环引用且无实际数据):', isDeepEmpty(circularObj));

// 场景 5：内置 Date 对象
const case5 = { meta: { createdAt: new Date() } };
console.log('Case 5 (包含 Date 实例):', isDeepEmpty(case5));

五、技术方案评估与工程实践总结

在前端与 Node.js 业务开发中，开发者往往面临不同的技术路线抉择。下表总结了主流判空策略的技术特征：