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

在JavaScript中，判断对象是否为空是常见的编程需求。本文深入探讨了多种JS判断对象是否为空的方法，并分析了它们的适用场景和局限性。最常用的方法是使用`Object.keys(obj).length === 0`，它能有效检测对象是否拥有可枚举的自身属性。然而，对于需要考虑不可枚举属性和Symbol属性的情况，则需要结合`Object.getOwnPropertyNames()`和`Object.getOwnPropertySymbols()`进行更严格的判断。此外，文章还讨论了`for...in`循环配合`hasOwnProperty()`的传统方法，以及`JSON.stringify(obj) === '{}'`的局限性。选择哪种方法取决于你对“空”的定义和实际业务需求。本文旨在帮助开发者根据不同场景选择最合适的判断方式，写出更健壮的代码。

判断JavaScript对象是否为空最常用且有效的方法是使用Object.keys(obj).length === 0，它检查对象是否有可枚举的自身属性；2. 若需考虑不可枚举属性和Symbol属性，则应结合Object.getOwnPropertyNames()和Object.getOwnPropertySymbols()进行更严格的判断；3. 使用for...in配合hasOwnProperty()可遍历自身可枚举属性并排除原型链属性，适用于传统环境；4. JSON.stringify(obj) === '{}'存在局限性，会忽略undefined和函数等值，不推荐在精确场景使用；5. 直接比较obj === {}不可行，因对象比较基于引用而非值；6. 最全面的判断方式是Object.getOwnPropertyNames(obj).length === 0 && Object.getOwnPropertySymbols(obj).length === 0，可确保对象没有任何自身属性，包括不可枚举和Symbol属性，但实际应用中需根据对“空”的定义选择合适方法，多数场景下Object.keys(obj).length === 0已足够有效。

在JavaScript中，判断一个对象是否为空，最常见且在多数场景下足够有效的方式是检查 Object.keys(obj).length === 0。这通常意味着该对象没有可枚举的自身属性。然而，“空”的定义并非一成不变，它可能指没有自身属性，也可能指没有可枚举的自身属性，甚至可能牵涉到原型链上的属性。

解决方案

判断JavaScript对象是否为空，根据你对“空”的定义和需求，有几种不同的策略。

1. 使用 Object.keys().length === 0 这是最常用也最推荐的方法，因为它简洁明了，并且覆盖了绝大多数日常开发场景。它会返回一个数组，包含对象所有可枚举的自身属性的键名。如果这个数组的长度为0，那么对象就是“空”的。

   

   function isEmptyObjectByKeys(obj) {
     return Object.keys(obj).length === 0;
   }
   
   // 示例
   console.log(isEmptyObjectByKeys({})); // true
   console.log(isEmptyObjectByKeys({ a: 1 })); // false
   console.log(isEmptyObjectByKeys(new Object())); // true

2. 使用 for...in 循环配合 hasOwnProperty() 这种方法更为传统，也更“底层”一些。它会遍历对象及其原型链上的所有可枚举属性。通过 hasOwnProperty() 方法，我们可以确保只检查对象自身的属性，排除继承来的属性。

   function isEmptyObjectByForIn(obj) {
     for (const key in obj) {
       if (Object.prototype.hasOwnProperty.call(obj, key)) {
         return false; // 发现自身属性，不为空
       }
     }
     return true; // 没有发现自身属性，为空
   }
   
   // 示例
   console.log(isEmptyObjectByForIn({})); // true
   console.log(isEmptyObjectByForIn({ a: 1 })); // false

   这种方式在某些老旧环境或需要严格控制继承属性时会派上用场，不过现代JS开发中，Object.keys() 更受欢迎。

   

3. 使用 JSON.stringify(obj) === '{}' 这个方法很直接，但它有一些明显的局限性。它会把对象序列化成JSON字符串，然后判断是否等于空对象的JSON字符串。

   function isEmptyObjectByJSONStringify(obj) {
     try {
       return JSON.stringify(obj) === '{}';
     } catch (e) {
       // 如果对象包含循环引用，JSON.stringify会抛出错误
       return false; // 或者根据业务逻辑处理
     }
   }
   
   // 示例
   console.log(isEmptyObjectByJSONStringify({})); // true
   console.log(isEmptyObjectByJSONStringify({ a: 1 })); // false
   // 局限性：
   // console.log(isEmptyObjectByJSONStringify({ a: undefined })); // "{}", true - 因为undefined属性会被忽略
   // console.log(isEmptyObjectByJSONStringify({ a: function(){} })); // "{}", true - 函数属性也会被忽略

   这个方法最大的问题在于，它只会序列化可枚举的自身属性，并且会忽略值为 undefined 或函数的属性。所以，如果你定义了一个 obj = { a: undefined }，它会告诉你这个对象是空的，但这显然不符合我们对“空”的直观理解。所以，个人建议，除非你对这些“副作用”心知肚明且能接受，否则尽量避免这种方法。

4. 使用 Object.getOwnPropertyNames().length === 0 或 Object.getOwnPropertySymbols().length === 0Object.getOwnPropertyNames() 会返回一个数组，包含对象所有自身属性的键名，包括不可枚举的属性。Object.getOwnPropertySymbols() 则返回所有自身Symbol属性。如果你需要检查对象是否连不可枚举的属性都没有，这两个方法就很有用了。

   function isEmptyObjectStrict(obj) {
     return Object.getOwnPropertyNames(obj).length === 0 &&
            Object.getOwnPropertySymbols(obj).length === 0;
   }
   
   // 示例
   let objWithNonEnumerable = {};
   Object.defineProperty(objWithNonEnumerable, 'a', {
     value: 1,
     enumerable: false // 不可枚举
   });
   console.log(isEmptyObjectByKeys(objWithNonEnumerable)); // true (因为'a'不可枚举)
   console.log(isEmptyObjectStrict(objWithNonEnumerable)); // false (因为'a'存在)

   这种方式非常“严格”，它会检查对象是否真的“一无所有”，包括那些我们平时不太关注的不可枚举属性。

为什么 obj === {} 这种比较方式行不通？

这其实是JavaScript中一个很基础但又容易混淆的概念：对象的比较是基于引用的，而不是基于值的。当你写 obj === {} 时，你是在比较 obj 变量所指向的内存地址，和 new Object() (也就是 {}) 在内存中新创建的一个空对象的内存地址。这两个地址必然是不同的，所以结果永远是 false。

举个例子：

let a = {};
let b = {};
console.log(a === b); // false

let c = a;
console.log(a === c); // true (因为它们指向同一个内存地址)

这就好比你有两把一模一样的钥匙，但它们是两把不同的钥匙，你不能说它们是同一把。只有当它们指向同一个“实体”时，它们才相等。所以，想通过直接比较来判断对象是否为空，这条路是走不通的。

Object.keys().length === 0 足够了吗？它有什么潜在的“盲区”？

Object.keys().length === 0 是我们最常用的判断方式，它在绝大多数场景下都表现良好。但正如任何工具一样，它也有自己的“脾气”和“盲区”。它的核心在于，它只关注对象自身的可枚举属性。

这意味着什么呢？

1. 不可枚举属性： JavaScript中的属性可以被定义为不可枚举的。例如，使用 Object.defineProperty() 创建的属性，如果没有明确设置 enumerable: true，默认就是不可枚举的。Object.keys() 会完全忽略这些属性。

   let myObject = {};
   Object.defineProperty(myObject, 'hiddenProp', {
     value: 'I am hidden',
     enumerable: false // 设为不可枚举
   });
   console.log(Object.keys(myObject).length === 0); // true
   console.log(myObject.hiddenProp); // "I am hidden" - 属性实际上存在！

   所以，如果你的“空”的定义是“没有任何自身属性，包括不可枚举的”，那么 Object.keys() 就会给你一个“假阳性”的结果。

2. 原型链上的属性： Object.keys() 不会遍历原型链上的属性。它只检查对象自身的属性。这通常是好事，因为我们通常只关心对象“自己的东西”。但如果你对“空”的定义包括“继承来的属性也算作不空”，那 Object.keys() 就帮不上忙了。

   function Parent() {
     this.parentProp = 'hello';
   }
   let child = new Parent();
   console.log(Object.keys(child).length === 0); // true (因为parentProp是继承来的，不属于child的自身属性)
   console.log(child.parentProp); // "hello"

   在多数情况下，我们判断对象是否为空，确实是想知道它有没有“自己的”数据，而不是继承来的方法或属性。所以这一点通常不是问题，反而是其优点。

如何更全面地判断一个对象是否真的“空无一物”？

要更全面、更严格地判断一个对象是否真的“空无一物”，我们需要把不可枚举属性和Symbol属性也考虑进来。

1. 结合 for...in 和 hasOwnProperty： 这种方法虽然比 Object.keys() 稍显冗长，但它能确保我们只检查对象自身的属性，无论是可枚举还是不可枚举的（尽管 for...in 本身不遍历不可枚举属性，但 hasOwnProperty 的检查是针对所有自身属性的）。

   function isTrulyEmpty(obj) {
     // 检查是否有可枚举的自身属性
     if (Object.keys(obj).length > 0) {
       return false;
     }
     // 检查是否有不可枚举的自身属性
     if (Object.getOwnPropertyNames(obj).length > 0) {
       // 这里会包含可枚举属性，所以理论上上面的Object.keys已经排除了它们
       // 但为了严谨，可以再确认一下是否存在非Object.keys列出的属性
       for (const name of Object.getOwnPropertyNames(obj)) {
         if (!Object.prototype.propertyIsEnumerable.call(obj, name)) {
           return false; // 发现不可枚举的自身属性
         }
       }
     }
     // 检查是否有Symbol类型的自身属性
     if (Object.getOwnPropertySymbols(obj).length > 0) {
       return false;
     }
     return true; // 真的空无一物
   }
   
   // 示例
   let obj1 = {};
   console.log(isTrulyEmpty(obj1)); // true
   
   let obj2 = {};
   Object.defineProperty(obj2, 'a', { value: 1, enumerable: false });
   console.log(isTrulyEmpty(obj2)); // false (因为有不可枚举的'a')
   
   let obj3 = { [Symbol('test')]: 'symbol value' };
   console.log(isTrulyEmpty(obj3)); // false (因为有Symbol属性)

   这个 isTrulyEmpty 函数结合了 Object.keys()、Object.getOwnPropertyNames() 和 Object.getOwnPropertySymbols()，力求做到“滴水不漏”。它首先快速检查最常见的可枚举属性，然后进一步检查不可枚举的命名属性和Symbol属性。

2. 更简洁的综合判断： 实际上，Object.getOwnPropertyNames() 会返回所有自身属性（包括不可枚举的，但不包括Symbol），而 Object.getOwnPropertySymbols() 则返回所有Symbol属性。所以，一个更简洁的“彻底空”判断可以是：

   function isAbsolutelyEmpty(obj) {
     return Object.getOwnPropertyNames(obj).length === 0 &&
            Object.getOwnPropertySymbols(obj).length === 0;
   }
   
   // 示例
   let objA = {};
   console.log(isAbsolutelyEmpty(objA)); // true
   
   let objB = { x: 1 };
   console.log(isAbsolutelyEmpty(objB)); // false
   
   let objC = {};
   Object.defineProperty(objC, 'y', { value: 2, enumerable: false });
   console.log(isAbsolutelyEmpty(objC)); // false
   
   let objD = { [Symbol('z')]: 3 };
   console.log(isAbsolutelyEmpty(objD)); // false

   这个 isAbsolutelyEmpty 函数可以说是在JS层面判断一个对象是否“空无一物”的最全面方式了。它考虑了所有类型的自身属性。但在实际应用中，你得想清楚你对“空”的定义到底有多严格。很多时候，Object.keys(obj).length === 0 已经足够了，没必要为了追求极致的严谨而过度设计。选择哪种方法，最终还是取决于你的业务场景和对“空”的精确定义。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~