JS判断对象是否为空的5种原生方法对比

一、判空前置概念：何为“空对象”与类型防崩校验

在深入具体方法前，首先要明确两个基本事实：

1. 为什么不能直接使用 !obj 或 Boolean(obj)？
在 JavaScript 中，对象是引用类型。即便是一个不包含任何键值对的空对象字面量 {}，其对应的内存指针也是存在的，在类型强制转换中永远会被计算为布尔真值 true。因此，执行 if (!obj) 只能判断变量是否为 null、undefined、0、"" 或 false，无法判断一个现有对象内是否持有属性。

2. 什么是合格的防御性类型校验？
JavaScript 历史遗留问题中，typeof null === 'object' 是一个著名的类型陷阱；同时，数组 [] 的 typeof 结果同样是 'object'。如果不加校验直接对 null 或 undefined 调用对象 API，程序会直接抛出运行时异常 TypeError: Cannot convert undefined or null to object。

因此，一个稳健的判断逻辑必须在检查属性数量之前，先验证目标值确实是一个合法的非空普通对象：

// 示例：基础对象类型守卫函数
function isPlainObject(val) {
  return typeof val === 'object' && val !== null && !Array.isArray(val);
}

// 示例调用输出
console.log(isPlainObject({}));      // 示例输出: true
console.log(isPlainObject(null));    // 示例输出: false
console.log(isPlainObject([]));      // 示例输出: false
console.log(isPlainObject(123));     // 示例输出: false

二、方法一：Object.keys(obj).length === 0（最常用标准方案）

Object.keys() 是 ECMAScript 5（ES5）规范引入的标准方法。它接受一个目标对象作为参数，返回一个由该对象自身持有的所有可枚举字符串键名构成的数组。判断该数组的 length 是否为 0，即可确认对象是否为空。

// 示例：使用 Object.keys 封装判空函数
function isEmptyWithKeys(obj) {
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    return false;
  }
  return Object.keys(obj).length === 0;
}

// 示例调用与输出
console.log(isEmptyWithKeys({}));                       // 示例输出: true
console.log(isEmptyWithKeys({ name: 'Alice' }));        // 示例输出: false
console.log(isEmptyWithKeys(Object.create({ a: 1 })));  // 示例输出: true (原型链属性不计入自身键)

特性与局限性分析：

• 优点：语义明确，代码简洁，所有现代浏览器及 Node.js 环境原生支持。自动过滤继承自原型链的属性，只针对对象本身拥有的属性生效。
• 局限一（忽略不可枚举属性）：通过 Object.defineProperty() 定义且设置 enumerable: false 的属性无法被检测到。
• 局限二（忽略 Symbol 键）：ES6 引入的 Symbol 类型键名（例如 obj[Symbol('id')] = 1）不会被 Object.keys() 捕获。
• 性能特征：即使对象拥有成千上万个属性，该方法也会先完整分配一个包含所有键名的临时数组，然后再计算 .length，在超大对象且非空的场景下会有不必要的内存分配。

三、方法二：JSON.stringify(obj) === '{}'（存在静默陷阱，不推荐）

部分开发者习惯使用 JSON.stringify(obj) === '{}' 来判断对象是否为空。这种做法的直观思路是将对象序列化为 JSON 字符串，并与空字面量字符串 "{}" 进行全等比对。

// 示例：JSON 序列化判空测试
function isEmptyWithJson(obj) {
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    return false;
  }
  try {
    return JSON.stringify(obj) === '{}';
  } catch (err) {
    return false; // 捕获循环引用错误
  }
}

// 常见场景输出
console.log(isEmptyWithJson({}));             // 示例输出: true
console.log(isEmptyWithJson({ a: 1 }));        // 示例输出: false

// 示例：JSON.stringify 导致的严重误判
const deceptiveObj = {
  a: undefined,
  b: function () {},
  c: Symbol('secret')
};

console.log(Object.keys(deceptiveObj).length); // 示例输出: 2 (包含 a 和 b)
console.log(JSON.stringify(deceptiveObj));     // 示例输出: "{}"
console.log(isEmptyWithJson(deceptiveObj));    // 示例输出: true (致命误判：对象明明有3个属性，却被判为空)

// 隐患二：遇到循环引用直接抛出异常
const circularObj = {};
circularObj.self = circularObj;
// JSON.stringify(circularObj) 会直接抛出: TypeError: Converting circular structure to JSON

此外，JSON.stringify 需要做完整的词法语法分析和字符串拼接，在 5 种方法中执行开销最大、吞吐量最低。因此在任何严肃的工程代码中，都不应采用此方案。

四、方法三：for...in 循环配合 Object.hasOwn()（短路性能最佳）

for...in 语句可以遍历对象及其原型链上的所有可枚举属性。借助该特性，只要循环迭代进入并确认存在属于对象自身的键，就可以立即返回 false 提前退出（短路求值），无需等待整个对象扫描完成。

由于 for...in 会同时遍历原型链，必须借助属性确认方法进行防污染过滤：ES2022 推荐使用 Object.hasOwn(obj, key)；在旧环境中使用 Object.prototype.hasOwnProperty.call(obj, key)。

// 示例：for...in 短路判空实现
function isEmptyWithForIn(obj) {
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    return false;
  }
  for (const key in obj) {
    // 过滤原型链继承属性，只确认对象自身键
    if (Object.hasOwn(obj, key)) {
      return false; // 只要发现第一个自身属性，立即中断并返回 false
    }
  }
  return true; // 循环完毕未发现任何自身属性，说明为空
}

// 兼容旧环境的版本（防止 Object.create(null) 无原型方法的问题）
function isEmptyForInLegacy(obj) {
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    return false;
  }
  for (const key in obj) {
    if (Object.prototype.hasOwnProperty.call(obj, key)) {
      return false;
    }
  }
  return true;
}

// 示例调用输出
console.log(isEmptyWithForIn({}));               // 示例输出: true
console.log(isEmptyWithForIn({ x: 10, y: 20 })); // 示例输出: false (遍历到 x 即刻返回，不执行 y)

五、方法四：Object.getOwnPropertyNames(obj).length === 0（捕获不可枚举属性）

在部分涉及底层配置、类库设计或组件状态管理的场景中，对象的某些属性可能会被设置为“不可枚举”（enumerable: false）。此时，上述的 Object.keys() 和 for...in 都将彻底忽略这些不可枚举属性。

Object.getOwnPropertyNames() 会返回一个由对象自身拥有的所有字符串属性名称组成的数组，无论该属性是否可枚举。

// 示例：不可枚举属性的检测行为
const configObj = {};
Object.defineProperty(configObj, 'hiddenToken', {
  value: 'secret_123',
  enumerable: false // 显式设置为不可枚举
});

// 对比测试
console.log(Object.keys(configObj).length); // 示例输出: 0 (Object.keys 误判为空)

function isEmptyWithPropNames(obj) {
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    return false;
  }
  return Object.getOwnPropertyNames(obj).length === 0;
}

console.log(isEmptyWithPropNames(configObj)); // 示例输出: false (成功检测出 hiddenToken)

边界与限制：

• 该方法能精准查出所有的不可枚举常规属性。
• 它无法获取 Symbol 类型的属性键。如果对象唯一的属性是以 Symbol 声明的，Object.getOwnPropertyNames(obj).length 依然会是 0。

六、方法五：Reflect.ownKeys(obj).length === 0（最严谨的全面检测）

随着 ECMAScript 2015（ES6）标准的引入，Symbol 成为了 JavaScript 的第七种原始数据类型，被广泛用于对象私有元数据及唯一键标识。

Reflect.ownKeys(target) 是 JavaScript 原生提供的最底层的属性键反射方法。根据规范，它的返回值精确等价于：
Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbols(target))。

也就是说，Reflect.ownKeys() 能够一次性囊括对象自身的所有属性：无论是可枚举还是不可枚举、无论是普通 String 键还是 Symbol 键，无一遗漏。

// 示例：包含 Symbol 属性的对象判空测试
const symKey = Symbol('uid');
const userEntity = {
  [symKey]: 1001
};

// 常见方法失效场景
console.log(Object.keys(userEntity).length);                // 示例输出: 0
console.log(Object.getOwnPropertyNames(userEntity).length); // 示例输出: 0

// 使用 Reflect.ownKeys 严谨判空
function isStrictEmpty(obj) {
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    return false;
  }
  return Reflect.ownKeys(obj).length === 0;
}

console.log(isStrictEmpty(userEntity)); // 示例输出: false (准确捕获 Symbol 键)
console.log(isStrictEmpty({}));         // 示例输出: true

七、5种方法核心差异剖析与选型决策指南

在真实业务工程中，选择哪种方法不取决于“哪种最炫”，而取决于业务对“空”的定义深度与性能吞吐量要求。

八、工程实践总结与通用封装建议

在实际项目落地中，建议根据你的项目类型采用以下标准实现：

1. 常规 Web 业务通用实现（推荐首选）

// 适用于 95% 常见前后端数据交互、表单状态及对象配置
export function isObjectEmpty(obj) {
  // 1. 严格类型前置检查：排除 null, undefined, 基本数据类型及数组
  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
    return false;
  }
  // 2. 核心原生判断
  return Object.keys(obj).length === 0;
}

2. 框架级/底层库严谨实现（防 Symbol 与隐藏属性）

// 适用于 SDK、插件框架、底层工具库
export function isStrictObjectEmpty(obj) {
  if (typeof obj !== 'object' || obj === null || Array.isArray(obj)) {
    return false;
  }
  // 涵盖自身所有键名（包含 Symbol 及不可枚举属性）
  return Reflect.ownKeys(obj).length === 0;
}

通过理解底层属性的枚举特性、Symbol 键机制以及原型链传播机制，开发者可以避开 JSON.stringify 等隐蔽误区，在代码健壮性与运行效率之间找到最恰当的平衡点。