【问题标题】：How do I test for an empty JavaScript object?如何测试一个空的 JavaScript 对象？
【发布时间】：2010-10-15 08:39:34
【问题描述】：

AJAX 请求后，有时我的应用程序可能会返回一个空对象，例如：

var a = {};

如何检查是否是这种情况？

【问题讨论】：

标签： javascript javascript-objects

【解决方案1】：

我正在使用这个。

function isObjectEmpty(object) {
  var isEmpty = true;
  for (keys in object) {
     isEmpty = false;
     break; // exiting since we found that the object is not empty
  }
  return isEmpty;
}

例如：

var myObject = {}; // Object is empty
var isEmpty  = isObjectEmpty(myObject); // will return true;
 
// populating the object
myObject = {"name":"John Smith","Address":"Kochi, Kerala"}; 
 
// check if the object is empty
isEmpty  = isObjectEmpty(myObject); // will return false;

from here

更新

或

你可以使用isEmptyObject的jQuery实现

function isEmptyObject(obj) {
  var name;
  for (name in obj) {
    return false;
  }
  return true;
}

【讨论】：

嗨。当您使用数字或布尔值 true 或 false 测试此函数时，返回 true，这不是正确的结果。 isObjectEmpty（真）。 isObjectEmpty(假)。 isObjectEmpty(1)
我们正在检查对象是否为空，而不是数据类型是否为对象。在您的情况下，要检查它是否是一个对象，我们需要类似 if(typeof a === "object") {...}

【解决方案2】：

ECMA 5+:

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
obj // ? null and undefined check
&& Object.keys(obj).length === 0
&& Object.getPrototypeOf(obj) === Object.prototype

但请注意，这会创建一个不必要的数组（keys 的返回值）。

Pre-ECMA 5：

function isEmpty(obj) {
  for(var prop in obj) {
    if(Object.prototype.hasOwnProperty.call(obj, prop)) {
      return false;
    }
  }

  return JSON.stringify(obj) === JSON.stringify({});
}

jQuery:

jQuery.isEmptyObject({}); // true

lodash:

_.isEmpty({}); // true

Underscore:

_.isEmpty({}); // true

Hoek

Hoek.deepEqual({}, {}); // true

ExtJS

Ext.Object.isEmpty({}); // true

AngularJS (version 1)

angular.equals({}, {}); // true

Ramda

R.isEmpty({}); // true

【讨论】：

Object.keys(new Date()).length === 0;所以这个答案可能会产生误导。
为什么我们需要在ECMA5+代码中检查obj.contructor===Object？我们只能使用这个代码obj // ? null and undefined check && Object.keys(obj).length === 0
你上面的评论从字面上解释了为什么 =) 有一百万个不同的对象，所以你要确保只测试“实际对象原语”，即构造函数不是某种扩展的对象对象。
这对于非空对象返回 true，但其所有键都是符号。

【解决方案3】：

性能

今天 2020.01.17，我在 Chrome v79.0、Safari v13.0.4 和 Firefox v72.0 上对 macOS High Sierra 10.13.6 进行了测试；选择的解决方案。

结论

基于for-in（A、J、L、M）的解决方案最快
基于JSON.stringify (B, K) 的解决方案很慢
奇怪的是，基于Object(N)的解决方案也很慢

详情

下面的 sn-p 中有 15 种解决方案。如果您想在您的机器上运行性能测试，请单击HERE。此链接于 2021.07.08 更新，但最初是在 here 执行测试 - 上表中的结果来自那里（但现在看起来该服务不再有效）。

var log = (s, f) => console.log(`${s} --> {}:${f({})}  {k:2}:${f({ k: 2 })}`);

function A(obj) {
  for (var i in obj) return false;
  return true;
}

function B(obj) {
  return JSON.stringify(obj) === "{}";
}

function C(obj) {
  return Object.keys(obj).length === 0;
}

function D(obj) {
  return Object.entries(obj).length === 0;
}

function E(obj) {
  return Object.getOwnPropertyNames(obj).length === 0;
}

function F(obj) {
  return Object.keys(obj).length === 0 && obj.constructor === Object;
}

function G(obj) {
  return typeof obj === "undefined" || !Boolean(Object.keys(obj)[0]);
}

function H(obj) {
  return Object.entries(obj).length === 0 && obj.constructor === Object;
}

function I(obj) {
  return Object.values(obj).every((val) => typeof val === "undefined");
}

function J(obj) {
  for (const key in obj) {
    if (hasOwnProperty.call(obj, key)) {
      return false;
    }
  }
  return true;
}

function K(obj) {
  for (var prop in obj) {
    if (obj.hasOwnProperty(prop)) {
      return false;
    }
  }
  return JSON.stringify(obj) === JSON.stringify({});
}

function L(obj) {
  for (var prop in obj) {
    if (obj.hasOwnProperty(prop)) return false;
  }
  return true;
}

function M(obj) {
  for (var k in obj) {
    if (obj.hasOwnProperty(k)) {
      return false;
    }
  }
  return true;
}

function N(obj) {
  return (
    Object.getOwnPropertyNames(obj).length === 0 &&
    Object.getOwnPropertySymbols(obj).length === 0 &&
    Object.getPrototypeOf(obj) === Object.prototype
  );
}

function O(obj) {
  return !(Object.getOwnPropertyNames !== undefined
    ? Object.getOwnPropertyNames(obj).length !== 0
    : (function () {
        for (var key in obj) break;
        return key !== null && key !== undefined;
      })());
}

log("A", A);
log("B", B);
log("C", C);
log("D", D);
log("E", E);
log("F", F);
log("G", G);
log("H", H);
log("I", I);
log("J", J);
log("K", K);
log("L", L);
log("M", M);
log("N", N);
log("O", O);

【讨论】：

很多这一切都没有意义，因为您将一切都建立在 false 和/或 true 的返回之上。有时编程需要 if 语句或三元运算符。仅供参考
为了完整起见，我编辑了您的 jsperf 以测试 obj = {a:1,b:2,c:3} 和 for(var i in obj) 仍然是最快的 jsperf.com/object-empty-ch/2

【解决方案4】：

IsEmpty 对象，当我们著名的雅虎大师向 ECMA 引入自定义的不可枚举对象属性并被接受时，意外失去了它的意义，即：它是编程语义 .

[如果你不喜欢历史 - 可以直接跳到工作代码]

我看到很多很好的答案\这个问题的解决方案\问题。但是，获取 ECMA 脚本的最新扩展并不是正确的方法。我们过去常常阻止 Web 以保持 Netscape 4.x 和基于 Netscape 的页面工作和项目的活力，这（顺便说一下）是极其原始的落后和特殊的，拒绝使用新的 W3C 标准和主张 [在那个时候是相当具有革命性的并且对编码人员友好]，而现在对我们自己的遗产是残酷的。

杀死 Internet Explorer 11 是完全错误的！是的，一些自“冷战”时代以来一直处于休眠状态的渗透微软的老战士同意了——出于所有错误的原因。 - 但这并不正确！

在您的答案中使用新引入的方法\属性并将其作为发现（“一直存在，但我们没有注意到”）而不是 一项新发明（就其本质而言）有点“绿色”且有害。大约 20 年前，我曾经犯过这样的错误，当时我仍然无法分辨那里已经存在什么，并将我能找到参考的所有内容都视为一种常见的工作解决方案......

向后兼容性很重要！

我们只是还不知道。这就是我需要分享我的“百年历史”通用解决方案的原因，该解决方案仍然向后和向前兼容，以适应不可预见的未来。

in 运算符受到了很多攻击，但我认为这样做的人终于清醒过来，真正开始理解和欣赏真正的动态类型语言例如 JavaScript 及其美丽的特性。

我的方法旨在简单而有核心，出于上述原因，我不称其为“空”，因为该词的含义不再准确。 Is Enumerable，似乎是一个有确切含义的词。

function isEnum( x ) { for( var p in x )return!0; return!1 };

一些用例：

isEnum({1:0})
true

isEnum({})
false

isEnum(null)
false

感谢阅读！

【讨论】：

【解决方案5】：

isEmptyObject(value) {
  return value && value.constructor === Object && Object.keys(value).length === 0;
}

上面的代码足以检查对象的空性。

一篇很好的文章写在how-to-check-if-object-is-empty

【讨论】：

这看起来很像接受的答案
检查事项的顺序。

【解决方案6】：

你可以使用 lodash 库来代替普通的 JS 函数。

_.isEmpty({}) // 是的

这将检查数组和对象是否有值并返回布尔值。

【讨论】：

【解决方案7】：

如果ECMAScript 5 support可用，则可以使用Object.keys()：

function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}

对于 ES3 和更早版本，没有简单的方法可以做到这一点。您必须明确地遍历属性：

function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return true;
}

【讨论】：

这很好用，或者更简单：function isEmpty(object) { for(var i in object) { return true; } 返回假； }
这个函数中真假不应该颠倒吗？
@namtax: no - 函数名为isEmpty()，因此如果它有属性，它应该返回false
@NicholasKreidberg 该代码function isEmpty(object) { for(var i in object) { return true; } return false; } 必须在 11 年后更正。这是更正：function isEmpty(obj) { return !(() => { for (const i in obj) { return true; } return false; })(); }
或者：function isObjectEmpty(obj) { for (const i in obj) return false; return true; }

【解决方案8】：

我能找到的最佳单线解决方案（更新）：

isEmpty = obj => !Object.values(obj).filter(e => typeof e !== 'undefined').length;

console.log(isEmpty({}))                                        // true
console.log(isEmpty({a: undefined, b: undefined}))              // true
console.log(isEmpty({a: undefined, b: void 1024, c: void 0}))   // true

console.log(isEmpty({a: [undefined, undefined]}))               // false
console.log(isEmpty({a: 1}))                                    // false
console.log(isEmpty({a: ''}))                                   // false
console.log(isEmpty({a: null, b: undefined}))                   // false

【讨论】：

最佳答案被忽略
@Damien，待定问题是 11 岁，这个答案是 2 周前发布的。
如果对象是这样的：{ 0 : null }，我得到一个值为 null 的键。遇到这种情况怎么办？
检查 Object.keys().length 已经在 2009 年就这个问题提出了建议。stackoverflow.com/a/679937/2943403 所以这个发布的答案一半有缺陷，另一半是多余的。

【解决方案9】：

奇怪的是，我还没有遇到比较对象的值而不是任何条目的存在的解决方案（也许我在许多给定的解决方案中错过了它）。
如果一个对象的所有值都未定义，我想介绍一个对象被认为是空的情况：

    const isObjectEmpty = obj => Object.values(obj).every(val => typeof val === "undefined")

    console.log(isObjectEmpty({}))                                 // true
    console.log(isObjectEmpty({ foo: undefined, bar: undefined })) // true
    console.log(isObjectEmpty({ foo: false,     bar: null }))      // false

示例用法

假设，举例来说，您有一个函数 (paintOnCanvas) 会破坏其参数（x、y 和 size）中的值。如果 all 都未定义，则它们将被排除在结果选项集之外。如果不是，它们都不是，它们都包括在内。

function paintOnCanvas ({ brush, x, y, size }) {
  const baseOptions = { brush }
  const areaOptions = { x, y, size }
  const options = isObjectEmpty(areaOptions) ? baseOptions : { ...baseOptions, areaOptions }
  // ...
}

【讨论】：

【解决方案10】：

同时，我们可以使用一个函数来检查所有“空”，例如 null、undefined、''、' '、{}、[]。

var isEmpty = function(data) {
  if (typeof(data) === 'object') {
    if (JSON.stringify(data) === '{}' || JSON.stringify(data) === '[]') {
      return true;
    } else if (!data) {
      return true;
    }
    return false;
  } else if (typeof(data) === 'string') {
    if (!data.trim()) {
      return true;
    }
    return false;
  } else if (typeof(data) === 'undefined') {
    return true;
  } else {
    return false;
  }
}

//Use cases and results.

console.log(isEmpty()); // true
console.log(isEmpty(null)); // true
console.log(isEmpty('')); // true
console.log(isEmpty('  ')); // true
console.log(isEmpty(undefined)); // true
console.log(isEmpty({})); // true
console.log(isEmpty([])); // true
console.log(isEmpty(0)); // false
console.log(isEmpty('Hey')); // false

【讨论】：

您不应该在这样的实用程序函数中对数据进行字符串化。想象一下，如果你有一个存储了 1GB 数据的对象，并决定在它上面运行这个函数——你会将整个对象串起来只是为了检查它里面是否有任何东西？只需使用Object.keys()

【解决方案11】：

我的看法：

function isEmpty(obj) {
  return Object.keys(obj).length === 0;
}

var a = {
  a: 1,
  b: 2
}
var b = {}

console.log(isEmpty(a)); // false
console.log(isEmpty(b)); // true

只是，我认为目前并非所有浏览器都实现Object.keys()。

【讨论】：

Object.keys(new Date()).length === 0;所以这个答案可能会产生误导。
取决于您是否认为日期始终“满”，尽管从未公开密钥。但我同意，如果这是你的计划，为 Date 构造函数添加一些补充 instanceof 检查是一个不错的选择。

【解决方案12】：

您最想知道的是，对象在使用之前是否具有属性。因此，不要询问isEmpty，然后总是检查if(!isEmpty(obj)) 之类的否定，您可以只测试对象是否不为空并且具有属性

export function hasProperties(obj): boolean {
  return obj && obj.constructor === Object && Object.keys(obj).length >= 1;
}

【讨论】：

【解决方案13】：

我喜欢我想出的这个，这里有一些其他答案的帮助。我想我会分享它。

Object.defineProperty(Object.prototype, 'isEmpty', {
    get() {
        for(var p in this) {
            if (this.hasOwnProperty(p)) {return false}
        }
        return true;
    }
});


let users = {};
let colors = {primary: 'red'};
let sizes = {sm: 100, md: 200, lg: 300};

console.log(
'\nusers =', users,
'\nusers.isEmpty ==> ' + users.isEmpty,
'\n\n-------------\n',
'\ncolors =', colors,
'\ncolors.isEmpty ==> ' + colors.isEmpty,
'\n\n-------------\n',
'\nsizes =', sizes,
'\nsizes.isEmpty ==> ' + sizes.isEmpty,
'\n',
''
);

【讨论】：

【解决方案14】：

我们也可以使用 vanilla js 来处理 null 或 undefined 的检查，如下所示，

function isEmptyObject(obj) {
  return !!obj && Object.keys(obj).length === 0 && obj.constructor === Object;
}

//tests

isEmptyObject(new Boolean());  // false 
isEmptyObject(new Array());    // false 
isEmptyObject(new RegExp());   // false 
isEmptyObject(new String());   // false 
isEmptyObject(new Number());   // false 
isEmptyObject(new Function()); // false 
isEmptyObject(new Date());     // false
isEmptyObject(null);          // false
isEmptyObject(undefined);     // false
isEmptyObject({});            // true

【讨论】：

【解决方案15】：

1。使用 Object.keys

Object.keys 将返回一个数组，其中包含对象的属性名称。如果数组的长度为0，那么我们就知道这个对象是空的。

function isEmpty(obj) {
    return Object.keys(obj).length === 0 && empty.constructor === Object;
}

我们也可以使用 Object.values 和 Object.entries 进行检查。这通常是确定对象是否为空的最简单方法。

2。用 for...in 循环对象属性

for...in 语句将遍历对象的可枚举属性。

function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return true;
}

在上面的代码中，我们会循环遍历对象的属性，如果一个对象至少有一个属性，那么它将进入循环并返回false。如果对象没有任何属性，那么它将返回 true。

#3。使用 JSON.stringify 如果我们对对象进行字符串化并且结果只是一个左括号和右括号，我们就知道该对象是空的。

function isEmptyObject(obj){
    return JSON.stringify(obj) === '{}';
}

4。使用 jQuery

jQuery.isEmptyObject(obj);

5。使用下划线和 Lodash

_.isEmpty(obj);

Resource

【讨论】：

【解决方案16】：

遇到同样问题但使用jQuery的朋友，可以使用jQuery.isEmptyObject。

【讨论】：

嘿！我只花了几个小时调试 IE 8 问题，却发现是 jQuery.isEmptyObject 导致了问题。如果对象为空，则返回 true。
如果问题根本与 jQuery 无关，为什么还要发布包括 jQuery 在内的答案？
我知道这是一个旧评论，但我想知道你的问题@MFD3000，因为文档说：如果对象为空，则返回 true（如名称所示）
在这样一个基本任务中包含 jQuery 并不是我所说的正确答案。的确，如今 jQuery 几乎无处不在，但我们仍然不应忘记它是围绕一种非常强大的语言本身构建的。
这些 cmets 中典型的 JS 势利眼。每个人都知道 Web 上的 JavaScript 有很大一部分是用 jQuery 编写的，所以如果 jQuery 已经内置了用于测试对象的方法，那么在这里为 jQuery 提供解决方案是完全可以接受的。成千上万寻求帮助的开发人员可能会发现此答案很有帮助。没有人说这是唯一的方法。我注意到没有人对发布解决方案以使用 underscore.js...

【解决方案17】：

检查值的新方法是 if(Object.entries(this.props.myarticle).length===0){ }

这里 myarticles 是对象

【讨论】：

【解决方案18】：

这一行代码也有助于回退到旧版浏览器。

var a = {}; //if empty returns false
(Object.getOwnPropertyNames ? Object.getOwnPropertyNames(a).length !== 0 : (function(){ for(var key in a) break; return !!key })()) //Returns False

var a = {b:2}; //if not empty returns true
(Object.getOwnPropertyNames ? Object.getOwnPropertyNames(a).length !== 0 : (function(){ for(var key in a) break; return !!key })()) //Returns true

Object.getOwnPropertyNames 在 ECMA-5 中实现。上面这行代码适用于具有后备功能的旧版浏览器。

另一个快速的解决方案是检查 length 的属性 Object.keys、Object.entries 或 Object.values

知识文章：关注这个SO帖子了解Object.keys Vs Object.getOwnPropertyNames之间的详细区别

【讨论】：

【解决方案19】：

我知道这并不能 100% 回答您的问题，但我之前也遇到过类似的问题，以下是我用来解决这些问题的方法：

我有一个可能返回空对象的 API。因为我知道 API 需要哪些字段，所以我只检查是否存在任何必填字段。

例如：

API 返回{} or {agentID: '1234' (required), address: '1234 lane' (opt),...}。在我的调用函数中，我只会检查

if(response.data && response.data.agentID) { 
  do something with my agentID 
} else { 
  is empty response
}

这样我就不需要使用那些昂贵的方法来检查对象是否为空。如果对象没有 agentID 字段，我的调用函数的对象将为空。

【讨论】：

【解决方案20】：

这是一个快速、简单的函数：

function isEmptyFunction () {
  for (const i in this) return false
  return true
}

作为 getter 实现：

Object.defineProperty(Object.prototype, 'isEmpty', { get: isEmptyFunction })

console.log({}.isEmpty) // true

作为单独的函数实现：

const isEmpty = Function.prototype.call.bind(isEmptyFunction)

console.log(isEmpty({})) // true

【讨论】：

没有Object.hasOwnProperty，这个函数总是返回true（这个函数叫做isEmpty，但是当它不为空的时候返回true，顺便说一句……）。此外，该函数不会自动调用自身。在obj.isEmpty 之后添加()。
此外，在偶然发现这一点之后，您可能希望交换 return true/false 语句。一旦找到属性，函数“isEmpty”应该返回 false，因为这意味着它不是为空的。语义，但可能是个好主意。

【解决方案21】：

完美的故障安全解决方案

我认为第一个被接受的解决方案在大多数情况下都有效，但不是Failsafe。

将是更好且故障安全的解决方案。

function isEmptyObject() { 
  return toString.call(obj) === "[object Object]" 
  && Object.keys(obj).length === 0;
}

或在 ES6/7 中

const isEmptyObject = () => toString.call(obj) === "[object Object]" 
  && Object.keys(obj).length === 0;

使用这种方法，如果 obj 设置为 undefined 或 null，则代码不会中断。并返回 null。

【讨论】：

您正在检查一个对象是否为空，具有固定的字符串和诸如“toString.call(obj)”之类的黑客/不规则做法。这只是不好的做法和您不想在代码库中看到的代码。有更好更干净的解决方案，只需阅读它们就有意义。阅读它时这没有意义，它是一个 hack。

【解决方案22】：

    let jsObject = JSON.parse(JSON.stringify(obj), (key, value) => {
                if (value === null ||
                    value === '' ||
                    (value.constructor === Object && Object.entries(value).length === 0) ||
                    (value.constructor === Array && value.length === 0)) {
                    return undefined
                }
                return value
            })

这将递归过滤掉所有无效字段。

【讨论】：

【解决方案23】：

对于空对象，使用 Object.keys(obj).length（如上面对 ECMA 5+ 的建议）会慢 10 倍！保留老派（for...in）选项。

在 Node、Chrome、Firefox 和 IE 9 下测试，很明显对于大多数用例：

(for...in...) 是最快的选项！
Object.keys(obj).length 比空对象慢 10 倍
JSON.stringify(obj).length 总是最慢的（并不奇怪）
Object.getOwnPropertyNames(obj).length 比 Object.keys(obj).length 需要更长的时间在某些系统上可能更长。

底线性能明智，使用：

function isEmpty(obj) { 
   for (var x in obj) { return false; }
   return true;
}

或

function isEmpty(obj) {
   for (var x in obj) { if (obj.hasOwnProperty(x))  return false; }
   return true;
}

在Is object empty?查看详细的测试结果和测试代码

【讨论】：

Object.keys 很慢，但代码更少。在一个小页面上，它被调用...可能 10 次...考虑到额外代码的额外解析时间，这仍然会更慢吗？

【解决方案24】：

isEmpty 表示任何类型的值

/* eslint-disable no-nested-ternary */

const isEmpty = value => {
  switch (typeof value) {
    case 'undefined':
      return true;
    case 'object':
      return value === null
        ? true
        : Array.isArray(value)
        ? !value.length
        : Object.entries(value).length === 0 && value.constructor === Object;
    case 'string':
      return !value.length;
    default:
      return false;
  }
};

【讨论】：

【解决方案25】：

这与在 lodash 源中检查对象的方式类似：

const isEmpty = value => {
  for (const key in value) {
    if (hasOwnProperty.call(value, key)) {
      return false
    }
  }
  return true;
}

但是还有很多其他方法可以做到这一点。

【讨论】：

【解决方案26】：

要真正接受 ONLY {}，使用 Lodash 在 Javascript 中做到这一点的最佳方法是：

_.isEmpty(value) && _.isPlainObject(value)

【讨论】：

【解决方案27】：

纯原生 Javascript，完全向后兼容

function isObjectDefined (Obj) {
  if (Obj === null || typeof Obj !== 'object' ||
    Object.prototype.toString.call(Obj) === '[object Array]') {
    return false
  } else {
    for (var prop in Obj) {
      if (Obj.hasOwnProperty(prop)) {
        return true
      }
    }
    return JSON.stringify(Obj) !== JSON.stringify({})
  }
}

console.log(isObjectDefined()) // false
console.log(isObjectDefined('')) // false
console.log(isObjectDefined(1)) // false
console.log(isObjectDefined('string')) // false
console.log(isObjectDefined(NaN)) // false
console.log(isObjectDefined(null)) // false
console.log(isObjectDefined({})) // false
console.log(isObjectDefined([])) // false
console.log(isObjectDefined({a: ''})) // true

【讨论】：

【解决方案28】：

export function isObjectEmpty(obj) {
  return (
    Object.keys(obj).length === 0 &&
    Object.getOwnPropertySymbols(obj).length === 0 &&
    obj.constructor === Object
  );
}

这包括检查包含符号属性的对象。

Object.keys 不检索符号属性。

【讨论】：

【解决方案29】：

这是我想出来的，用来判断对象中是否有任何非空值。

function isEmpty(obj: Object): Boolean {
    for (const prop in obj) {
        if (obj.hasOwnProperty(prop)) {
            if (obj[prop] instanceof Object) {
                const rtn = this.isEmpty(obj[prop]);
                if (rtn === false) {
                  return false;
                }
            } else if (obj[prop] || obj[prop] === false) {
                return false;
            }
        }
    }
    return true;
}

【讨论】：

【解决方案30】：

下面的例子展示了如何测试一个 JavaScript 对象是否为空，如果为空，我们的意思是它没有自己的属性。

该脚本适用于 ES6。

const isEmpty = (obj) => {
    if (obj === null ||
        obj === undefined ||
        Array.isArray(obj) ||
        typeof obj !== 'object'
    ) {
        return true;
    }
    return Object.getOwnPropertyNames(obj).length === 0;
};
console.clear();
console.log('-----');
console.log(isEmpty(''));           // true
console.log(isEmpty(33));           // true
console.log(isEmpty([]));           // true
console.log(isEmpty({}));           // true
console.log(isEmpty({ length: 0, custom_property: [] })); // false
console.log('-----');
console.log(isEmpty('Hello'));      // true
console.log(isEmpty([1, 2, 3]));    // true
console.log(isEmpty({ test: 1 }));  // false
console.log(isEmpty({ length: 3, custom_property: [1, 2, 3] })); // false
console.log('-----');
console.log(isEmpty(new Date()));   // true
console.log(isEmpty(Infinity));     // true
console.log(isEmpty(null));         // true
console.log(isEmpty(undefined));    // true

【讨论】：