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

var a = {};

如何检查情况呢？

ECMA 5+：

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

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

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

lodash：

_.isEmpty({}); // true

下划线：

_.isEmpty({}); // true

ek

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

ExtJS

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

AngularJS（版本1）

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

拉姆达

R.isEmpty({}); // true

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

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

对于那些同样的问题但使用jQuery的人，可以使用jQuery.isEmptyObject。

这是我的首选解决方案：

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

您可以使用Underscore.js。

_.isEmpty({}); // true

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

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

如何使用JSON.stringify？它几乎在所有现代浏览器中都可用。

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

我只是遇到了类似情况。我不想使用JQuery，而是想使用纯Javascript做到这一点。

我所做的就是使用以下条件，它对我有用。

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

对于不等于，请使用： JSON.stringify(obj) !== '{}'

看看这个JSFiddle

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

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

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

对于空对象，使用Object.keys（obj）.length（如上文ECMA 5+所建议）的速度要慢10倍！保持老派的选择。

经过在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;
}

请参阅“对象为空吗？”中的详细测试结果和测试代码。

性能

今天，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种解决方案。如果要在计算机上运行性能测试，请单击此处。

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

您可以检查对象键的数量：

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

1. 只是一种解决方法。如果没有数据，您的服务器能否生成一些特殊属性？

   例如：

   var a = {empty:true};

   然后，您可以轻松地在AJAX回调代码中对其进行检查。

2. 另一种检查方法：

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

编辑：如果您使用任何JSON库（fe JSON.js），则可以尝试JSON.encode（）函数并针对空值字符串测试结果。

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

它使用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。

希望对您有所帮助。干杯!

我正在用这个。

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

下面的示例演示如何测试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

根据Object.entries（）上的ES2017规范，使用任何现代浏览器均可轻松进行检查-

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

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

jQuery isEmptyObject()在这种情况下具有特殊功能：

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

进一步了解http://api.jquery.com/jQuery.isEmptyObject/

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

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

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

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

您可以使用不使用jQuery或其他库的简单代码

var a=({});

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

JSON类及其功能（解析和字符串化）非常有用，但是IE7存在一些问题，您可以使用此简单代码http://www.json.org/js.html对其进行修复。

其他简单方式（simplest Way）：
您可以使用这种方式而无需使用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

我发现的最好方法：

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

我的看法：

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()目前所有的浏览器都可以实现。

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

_.isEmpty({}) // returns 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 ) );

显示

    谨防！！obj不为空！

    obj = {f：function（）{}}

    JSON.stringify（obj）

    退货

    {}

正确答案是：

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

这将检查：

• 该对象没有自己的属性（无论可枚举性如何）。
• 该对象没有自己的属性符号。
• 该对象的原型为Object.prototype。

换句话说，该对象与用创建的对象是无法区分的{}。

除了Thevs答案：

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

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

这是jquery + jquery.json

糖提供了扩展对象。代码简洁明了：

制作一个扩展对象：

a = Object.extended({})

检查它的大小：

a.size()