如何测试空的JavaScript对象？

Question

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

var a = {};

我怎样才能检查是否是这种情况？

Answer 1

ECMA 7+:

// because Object.entries(new Date()).length === 0;
// we have to do some additional check
Object.entries(obj).length === 0 && obj.constructor === Object

ECMA 5+:

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
Object.keys(obj).length === 0 && obj.constructor === Object

ECMA 5之前:

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

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

jQuery:

jQuery.isEmptyObject({}); // true

洛达什:

_.isEmpty({}); // true

下划线:

_.isEmpty({}); // true

霍克

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

ExtJS的

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

AngularJS(版本1)

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

Ramda

R.isEmpty({}); // true

Answer 2

没有简单的方法可以做到这一点.您必须显式遍历属性:

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

    return true;
}

如果ECMAScript 5支持可用,您可以使用Object.keys():

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

Answer 3

对于那些有相同问题但使用jQuery的人,可以使用jQuery.isEmptyObject.

Answer 4

这是我的首选解决方案:

var obj = {};
return Object.keys(obj).length; //returns 0 if empty or an integer > 0 if non-empty

Answer 5

表现

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

结论

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

细节

下面的代码段中提供了 15 种解决方案。如果您想在您的机器上运行性能测试，请单击此处。此链接已于 2021.07.08 更新，但在此处进行了oryginaly 测试- 上表中的结果来自那里（但现在看起来该服务不再有效）。

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

如果我的回答有帮助你可以给我买杯咖啡

Answer 6

您可以使用Underscore.js.

_.isEmpty({}); // true

Answer 7

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

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

Answer 8

如何使用JSON.stringify？它几乎适用于所有现代浏览器.

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

Answer 9

老问题,但只是有问题.如果您的唯一目的是检查对象是否为空,那么包含JQuery并不是一个好主意.相反,只需深入了解JQuery的代码,您就会得到答案:

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

Answer 10

我刚遇到类似的情况.我不想使用JQuery,并希望使用纯Javascript来做到这一点.

而我所做的是,使用了以下条件,它对我有用.

var obj = {};
if(JSON.stringify(obj) === '{}') { //This will check if the object is empty
   //Code here..
}

如果不相等,请使用: JSON.stringify(obj) !== '{}'

看看这个JSFiddle

Answer 11

如果您使用的是较新的浏览器,则有一种简单的方法. Object.keys(obj).length == 0

Answer 12

您可以检查对象键的计数:

if (Object.keys(a).length > 0) {
    // not empty
}

Answer 13

使用Object.keys(obj).length(如上面针对ECMA 5+所建议的)对于空对象来说慢10倍!保持旧学校(for ... in)选项.

在Node,Chrom,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对象为空的详细测试结果和测试代码？

Answer 14

1. 只是一个解决方法.如果没有数据,您的服务器可以生成一些特殊属性吗？

   例如:

   var a = {empty:true};
   

   然后,您可以在AJAX回调代码中轻松检查它.

2. 检查它的另一种方法:

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

编辑:如果您使用任何JSON库(fe JSON.js),那么您可以尝试JSON.encode()函数并针对空值字符串测试结果.

Answer 15

我已经创建了一个完整的函数来确定对象是否为空.

它使用Object.keys从ECMAScript中5(ES5)功能,如果可能的话,以达到最佳性能(见兼容性表)并回退给老式引擎(浏览器)最兼容的方法.

解

/**
 * Returns true if specified object has no properties,
 * false otherwise.
 *
 * @param {object} object
 * @returns {boolean}
 */
function isObjectEmpty(object)
{
    if ('object' !== typeof object) {
        throw new Error('Object must be specified.');
    }

    if (null === object) {
        return true;
    }

    if ('undefined' !== Object.keys) {
        // Using ECMAScript 5 feature.
        return (0 === Object.keys(object).length);
    } else {
        // Using legacy compatibility mode.
        for (var key in object) {
            if (object.hasOwnProperty(key)) {
                return false;
            }
        }
        return true;
    }
}

这是此代码的要点.

这是JSFiddle的演示和简单的测试.

我希望它能帮助别人.干杯!

Answer 16

我正在使用这个.

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;

从这里

更新

要么

你可以使用isEmptyObject的jQuery实现

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

Answer 17

以下示例显示如何测试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

Answer 18

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

Answer 19

根据Object.entries()上的ES2017规范,使用任何现代浏览器检查都很简单 -

Object.entries({}).length === 0

Answer 20

jQuery isEmptyObject()对于这种情况有特殊功能:

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

阅读更多信息,请访问http://api.jquery.com/jQuery.isEmptyObject/

Answer 21

在幕后，所有库中的所有空检查方法都使用对象键检查逻辑。使它易于理解是一种奇怪的方式，您可以将其放入方法中，在此进行描述。

for(key in obj){
   //your work here.
 break;
}

在ES5中得到了发展，现在简单地说，您可以使用Object.Keys将对象作为参数的方法来检查对象的密钥长度：

if(Object.keys(obj).length > 0){
 //do your work here
}

或者，如果您正在使用Lodash（必须），则使用。

 _.isEmpty(obj) //==true or false

Answer 22

我会去检查它是否至少有一把钥匙.这足以告诉我它不是空的.

typeof obj !== "undefined" && Boolean(Object.keys(obj)[0])

Answer 23

你可以使用这个不使用jQuery或其他库的简单代码

var a=({});

//check is an empty object
if(JSON.stringify(a)=='{}') {
    alert('it is empty');
} else {
    alert('it is not empty');
}

JSON类及其函数(parse和stringify)非常有用,但是IE7存在一些问题,您可以使用这个简单的代码http://www.json.org/js.html修复它.

其他简单方法(最简单的方法):
您可以使用这种方式而不使用jQuery或JSON对象.

var a=({});

function isEmptyObject(obj) {
    if(typeof obj!='object') {
        //it is not object, so is not empty
        return false;
    } else {
        var x,i=0;
        for(x in obj) {
            i++;
        }
        if(i>0) {
            //this object has some properties or methods
            return false;
        } else {
            //this object has not any property or method
            return true;
        }
    }
}

alert(isEmptyObject(a));    //true is alerted

Answer 24

我找到的最佳方式:

function isEmpty(obj)
{
    if (!obj)
    {
        return true;
    }

    if (!(typeof(obj) === 'number') && !Object.keys(obj).length)
    {
        return true;
    }

    return false;
}

效劳于:

    t1: {} -> true
    t2: {0:1} -: false
    t3: [] -> true
    t4: [2] -> false
    t5: null -> true
    t6: undefined -> true
    t7: "" -> true
    t8: "a" -> false
    t9: 0 -> true
    t10: 1 -> false

Answer 25

我的看法:

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()目前都在实施.

Answer 26

如果jQuery和Web浏览器不可用,则underscore.js中还有一个isEmpty函数.

_.isEmpty({}) // returns true

此外,它不会将输入参数视为对象.对于列表或字符串或未定义,它也将转换正确的答案.

Answer 27

一个更简单的解决方案：var a = {};
案例 a 为空：!Object.keys(a).length返回true。

Answer 28

2021 - 解决方案

你需要的是Object.entries(obj).length。在原生原型中触摸不好。

您可以创建自己的函数并根据需要使用它。就我而言，我有一个名为的文件夹utils，其中有一个像这样的模块定义：

实用程序/isEmpty.js

export default (obj) => !Object.entries(obj).length

someFileToUse.js

import isEmpty from '~/utils/isEmpty.js'

const obj1 = {};
const obj2 = {somekey: "someValue"};

console.log(isEmpty(obj1)) 
// -> true

console.log(isEmpty(obj2)) 
// -> false

Answer 29

正确答案是:

const isEmptyObject = obj =>
  Object.getOwnPropertyNames(obj).length === 0 &&
  Object.getOwnPropertySymbols(obj).length === 0 &&
  Object.getPrototypeOf(obj) === Object.prototype;

这检查:

• 该对象没有自己的属性(无论可枚举性如何).
• 该对象没有自己的属性符号.
• 对象的原型正是如此Object.prototype.

换句话说,该对象与创建的对象无法区分{}.

Answer 30

同时，我们可以有一个函数来检查所有“空”，例如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

Answer 31

警告!谨防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

    {}

Answer 32

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

Answer 33

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

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

Answer 34

除了Thevs答案：

var o = {};
alert($.toJSON(o)=='{}'); // true

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

这是jquery + jquery.json

Answer 35

Sugar.JS为此提供了扩展对象。代码简洁明了：

制作一个扩展对象：

a = Object.extended({})

检查它的大小：

a.size()

Answer 36

另一种选择是使用is.js (14kB)，而不是jquery (32kB)、lodash (50kB) 或underscore (16.4kB)。is.js 被证明是上述库中最快的库，可用于确定对象是否为空。

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

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

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

与 underscore 和 lodash 一样_.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 快一点，只是因为您没有检查它是否是一个对象。

Answer 37

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

    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 }
  // ...
}

Answer 38

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

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

Answer 39

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

资源

Answer 40

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

[如果你不喜欢历史 - 请随意跳到工作代码]

我看到了很多很好的答案\这个问题的解决方案\问题。然而，获取 ECMA Script 的最新扩展并不是正确的方法。过去，我们曾经阻止 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

谢谢阅读！