小开

如果ECMAScript 5支持可用，您可以使用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;}

小开

只是一个变通方法。您的服务器可以在没有数据的情况下生成一些特殊属性吗？

例如：
```
var a = {empty:true};
```
然后您可以轻松地在AJAX回调代码中检查它。

另一种检查方法：

if (a.toSource() === "({})")  // then 'a' is empty

EDIT:If you use any JSON library (f.e. JSON.js) then you may try JSON.encode() function and test the result against empty value string.

小开

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

小开

除了Thevs的回答：

var o = {};alert($.toJSON(o)=='{}'); // true
var o = {a:1};alert($.toJSON(o)=='{}'); // false

jQuery+jquery.json

小开

对于那些有同样问题但使用jQuery的人，您可以使用jQuery.is空对象。

小开

对于这种情况，jQuery有特殊的函数isEmptyObject()：

jQuery.isEmptyObject({}) // truejQuery.isEmptyObject({ foo: "bar" }) // false

小开

您可以使用Underscore.js。

_.isEmpty({}); // true

小开

警告！小心JSON的限制。

javascript:obj={  f:function(){}  };alert( "Beware!! obj is NOT empty!\n\nobj = {  f:function(){}  }" +"\n\nJSON.stringify( obj )\n\nreturns\n\n" +JSON.stringify( obj ) );

显示

Beware!! obj is NOT empty!
obj = {  f:function(){}  }
JSON.stringify( obj )
returns
{}

小开

我的看法：

function isEmpty(obj) {return Object.keys(obj).length === 0;}
var a = {a: 1,b: 2}var b = {}
console.log(isEmpty(a)); // falseconsole.log(isEmpty(b)); // true

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

小开

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

function isEmptyFunction () {for (const i in this) return falsereturn 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.keys(obj).length === 0

小开

我正在使用这个。

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 emptyvar isEmpty  = isObjectEmpty(myObject); // will return true; 
// populating the objectmyObject = {"name":"John Smith","Address":"Kochi, Kerala"}; 
// check if the object is emptyisEmpty  = isObjectEmpty(myObject); // will return false;

从这里

更新

或

你可以用jQuery来实现is空对象

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

小开

Sugar.JS为此目的提供了扩展对象。代码干净简单：

创建一个扩展对象：

a = Object.extended({})

检查它的大小：

a.size()

小开

使用JSON.stringify?它几乎可以在所有现代浏览器中使用。

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

小开

老问题，但刚刚有问题。如果你的唯一目的是检查对象是否为空，那么包含JQuery并不是一个好主意。相反，深入jQuery的代码，你会得到答案：

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

小开

if(Object.getOwnPropertyNames(obj).length === 0){//is empty}

见http://bencollier.net/2011/04/javascript-is-an-object-empty/

小开

从jQuery 1.4isEmptyObject()开始，方法检查对象本身的属性和从原型继承的属性（因为它不使用hasOwnProperty）。参数应始终是普通JavaScript对象，因为其他类型的对象（DOM元素、原始字符串/数字、主机对象）可能无法在浏览器上给出一致的结果。要确定对象是否是普通JavaScript对象，请使用$.isPlainObject()。

jQuery.isPlainObject({}) // true
jQuery.isPlainObject( "test" ) // false

jQuery API

小开

我为AJAX调用返回了一个空的JSON响应，并且在IE8中jQuery.is空对象（）没有正确验证。我添加了一个额外的检查，似乎可以正确捕获它。

.done(function(data){// Parse json response objectvar response = jQuery.parseJSON(data);
// In IE 8 isEmptyObject doesn't catch the empty response, so adding additional undefined checkif(jQuery.isEmptyObject(response) || response.length === 0){//empty}else{//not empty}});

小开

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

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.get属性名称在ECMA-5中实现。上面的行在具有回退功能的旧浏览器中工作。

另一个快速解决方案是检查length属性#0、#1或#2

知识篇：关注这篇SO文章，了解Object.keysvsObject.getOwnProperties tyNames之间的详细区别

小开

    isEmpty = function(obj) {if (obj == null) return true;if (obj.constructor.name == "Array" || obj.constructor.name == "String") return obj.length === 0;for (var key in obj) if (isEmpty(obj[key])) return true;return false;}

这将检查String、Array或Object（Maps）是否为空。

用法：

var a = {"a":"xxx","b":[1],"c":{"c_a":""}}isEmpty(a); // true, because a.c.c_a is empty.isEmpty("I am a String"); //false

小开

另一种选择是使用is.js（14kB）而不是jQuery（32kB），豆沙（50kB）或强调（16.4kB）。is.js被证明是上述库中最快的库，可用于确定对象是否为空。

http://jsperf.com/check-empty-object-using-libraries

显然，所有这些库都不完全相同，因此如果您需要轻松操作DOM，那么jQuery可能仍然是一个不错的选择，或者如果您需要的不仅仅是类型检查，那么豆沙或强调可能会很好。至于is.js，这是语法：

var a = {};is.empty(a); // trueis.empty({"hello": "world"}) // false

就像下划线和洛达什的_.isObject()一样，这不仅适用于objects，也适用于arrays和strings。

在引擎盖下，这个库使用Object.getOwnPropertyNames，它类似于Object.keys，但Object.getOwnPropertyNames更彻底，因为它将返回可枚举和不可枚举的属性，如这里所述。

is.empty = function(value) {if(is.object(value)){var num = Object.getOwnPropertyNames(value).length;if(num === 0 || (num === 1 && is.array(value)) || (num === 2 && is.arguments(value))){return true;}return false;} else {return value === '';}};

如果你不想引入库（这是可以理解的），并且你知道你只是检查对象（不是数组或字符串），那么下面的函数应该适合你的需要。

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

这只比is.js快一点，因为你没有检查它是否是一个对象。

小开

您可以在使用对象原型之前或代码开始时定义自己的对象原型。

定义应该看起来像这样：

Object.prototype.hasOwnProperties = function(){for (var k in this){if ( this.hasOwnProperty(k) ){return true;}}return false;}

下面是一个用法示例：

var a = {};
while ( a.status !== "finished" ){if ( status === "processing" ){a.status = "finished";}  
if ( status === "starting" ){a.status = "processing";}  
if ( !a.hasOwnProperties() ){a.status = "starting";}}

享受！：-）

小开

最佳答案

ecma5+：

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

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

预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

豆沙：

_.isEmpty({}); // true

下划线：

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS（版本1）

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

Ramda

R.isEmpty({}); // true

小开

我不敢相信经过两年的js编程，它从来没有点击过空对象和数组不是假的，最奇怪的是它从来没有抓住我。

如果默认情况下输入是false sey，或者它是一个空对象或数组，这将返回true。反过来是trueish函数

function falsish( obj ){if( (typeof obj === 'number' && obj > 0) || obj === true ){return false;}return !!obj? !Object.keys( obj ).length: true;}
function trueish( obj ){return !falsish( obj );}
falsish({})           //=> truefalsish({foo:'bar'})  //=> falsefalsish([])           //=> truefalsish(['foo'])      //=> falsefalsish(false)        //=> truefalsish(true)         //=> false// the rest are on codepen

小开

使用Object.keys（obj）. long（如上面针对ECMA 5+所建议的那样）对于空对象来说要慢10倍！保持旧的学校（for… in）选项。

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

（for… in…）是最快的选择！
空对象的Object.keys（obj）.长度慢10倍
JSON.stringify（obj）的长度总是最慢的（不意外）
Object.getOwnProperties tyNames（obj）的长度比Object.keys（obj）的长度长在某些系统上可能更长。

底线性能明智，使用：

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;}

在对象是否为空？中查看详细的测试结果和测试代码

小开

以下示例显示如何测试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(''));           // trueconsole.log(isEmpty(33));           // trueconsole.log(isEmpty([]));           // trueconsole.log(isEmpty({}));           // trueconsole.log(isEmpty({ length: 0, custom_property: [] })); // falseconsole.log('-----');console.log(isEmpty('Hello'));      // trueconsole.log(isEmpty([1, 2, 3]));    // trueconsole.log(isEmpty({ test: 1 }));  // falseconsole.log(isEmpty({ length: 3, custom_property: [1, 2, 3] })); // falseconsole.log('-----');console.log(isEmpty(new Date()));   // trueconsole.log(isEmpty(Infinity));     // trueconsole.log(isEmpty(null));         // trueconsole.log(isEmpty(undefined));    // true

小开

尝试破坏

const a = {};const { b } = a;const emptryOrNot = (b) ? 'not Empty' : 'empty';console.log(emptryOrNot)

小开

正确答案是:

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

这个检查表明:

这个物体的原型正是 Object.prototype。
该对象没有自己的属性(不管可枚举性如何)。
对象没有自己的属性符号。

换句话说，该对象与用 {}创建的对象没有区别。

小开

奇怪的是，我还没有遇到一个解决方案，比较对象的 价值观与任何条目的存在(也许我错过了许多给定的解决方案)。
我想讨论这样一种情况: 如果一个对象的所有值都没有定义，那么它就被认为是空的:

    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)中析构值。如果其中的所有没有定义，那么它们将被排除在结果选项集之外。如果不是，那么它们都包括在内。

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

小开

这就是我想出来的，告诉是否有任何非空值的对象。

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;
}

小开

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

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

Key 不检索符号属性。

小开

纯香草 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

小开

要真正接受 仅此而已 {}，在 Javascript 中使用 Lodash 的最佳方法是:

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

小开

这与在浪荡源代码中检查 object 的方式类似:

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

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

小开

值为任何类型的 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;
}
};

小开

    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
})

这将递归地筛选出所有无效字段。

小开

完美的故障安全解决方案

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

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

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 设置为未定义或 null，则代码不会中断。返回空。

小开

表演

今天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)的解决方案也很慢
注意: 此表没有与下面的照片相匹配。

细节

下面的代码片段提供了15个解决方案。如果要在计算机上运行性能测试，请单击给你。这个链接是在2021.07.08更新的，但是最初执行的测试是给你-上面表格中的结果来自这里(但是现在看起来这个服务不再工作了)。

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);

小开

我知道这不能百分百回答你的问题，但是我以前也遇到过类似的问题，下面是我如何解决它们的方法:

我有一个 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 字段，那么它对于我的调用函数将是空的。

小开

检查值的新方法是如果(Object.entry (this.pros.myarticle) . length = = = 0){ }

在这里我的文章是对象

小开

我能找到的最好的一行程序解决方案(已更新) :

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

小开

1. 使用 Object.keys

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

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

我们还可以使用 Object.value 和 Object.entry 检查这一点。这通常是确定对象是否为空的最简单方法。

使用 for... in 循环对象属性

语句将循环通过 object 的可枚举属性。

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


return true;
}

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

使用 JSON.stringify 如果我们将对象字符串化，并且结果只是一个开始和结束括号，那么我们知道对象是空的。

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

4. 使用 jQuery

jQuery.isEmptyObject(obj);

5. 使用下划线和 Lodash

_.isEmpty(obj);

资源

小开

我们可以使用带处理 null 或未定义 check 的香草 js 进行检查，如下所示,

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

小开

我喜欢我想出来的这个答案，这里有一些其他的答案，我想我应该分享一下。

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',
''
);

小开

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

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

小开

您可以使用 loash 库而不是使用普通的 JS 函数。

_. isEmpty ({})//true

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

小开

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

上面的代码足以检查 Object 是否为空。

一篇非常好的文章是在如何检查对象是否为空写的

小开

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

[如果您不喜欢历史，请直接跳到工作代码]

对于这个问题，我看到了许多不错的答案。然而，抓住 ECMA 脚本的最新扩展并不是一种诚实的做法。我们过去常常为了让 Netscape 4.x 和基于 Netscape 的页面和项目保持活力而阻碍互联网的发展，顺便说一句，这些都是极其原始的落后和特殊的，拒绝使用新的 W3C 标准和主张(这些标准和主张在当时是相当革命性的，对编码者也很友好) ，而现在则是对我们自己的遗产的残酷对待。

杀害 Internet Explorer 11是完全错误的！是的，一些自“冷战”时代以来一直潜伏在微软内部的老战士同意了这个计划——但是他们的理由都是错误的。但这不代表就是对的！

在你的答案中使用一个新引入的方法属性，并把它作为一个发现(“它一直在那里，但我们没有注意到它”) ，而不是 一项新发明(它真正是什么) ，有点“绿色”和有害。大约20年前，我曾经犯过这样的错误，当时我仍然不知道里面已经有什么，并且把所有我能找到的参考资料都当作一种常见的工作解决方案... ..。

向下兼容很重要！

我们只是还不知道而已。这就是为什么我需要分享我的“几个世纪以来”的通用解决方案，它仍然向后和向前兼容不可预见的未来。

有很多针对 < strong > in 运算符的攻击，但是我认为这些攻击者最终都理智了，真正开始理解并欣赏真正的动态类型语言，比如 JavaScript 及其美丽的本质。

我的方法的目标是简单和核心，由于上面提到的原因，我不称之为“空”，因为这个词的意思不再准确。是可枚举的，似乎是具有确切含义的单词。

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

一些用例:

isEnum({1:0})
true


isEnum({})
false


isEnum(null)
false

感谢您的阅读！

如何测试一个空的JavaScript对象？