如何测试空的JavaScript对象？

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

var a = {};

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

如果可用，可以使用

Object.keys（）

：

对于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

编辑：

---

如果您使用任何JSON库（f.e.JSON.js），那么您可以尝试JSON.encode（）函数，并根据空值字符串测试结果。

除了VS答案之外：

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

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

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

---

它是jquery+jquery.json

对于那些有同样问题但使用jquery的人，您可以使用。

jquery具有特殊的函数

isEmptyObject（）

，用于这种情况：

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

阅读有关您可以使用的

的更多信息

---

警告！小心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 {} 当心！！obj不是空的！ obj={f:function（）{} JSON.stringify（obj） 返回 {} 我的看法：

函数为空（obj）{
返回Object.keys（obj）.length==0；
}
变量a={
答:1,，
b:2
}
变量b={}
console.log（isEmpty（a））；//假的
console.log（isEmpty（b））；//如果您使用的是较新的浏览器，则有一种简单的方法。
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;
}

例如：


更新

或

您可以使用isEmptyObject的jQuery实现

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

使用JSON.stringify怎么样？它几乎可以在所有现代浏览器中使用

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

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

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



您可以使用这个不使用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存在一些问题，您可以用这个简单的代码来解决。



其他简单方式（最简单方式）：

您可以使用这种方式，而无需使用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

请参见
如果jQuery和web浏览器不可用，则underline.js中还有一个isEmpty函数

_.isEmpty({}) // returns true

此外，它不假定输入参数是对象。对于列表、字符串或未定义，它也将转换正确答案。
在引擎盖下，所有库中的所有空检查方法都使用对象键检查逻辑。这是一个奇怪的方式，让它可以理解，你可以把一个方法，描述

现在，简单地说，您可以使用
object.keys
方法检查对象的关键帧长度，该方法将对象作为其参数：

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

或者如果你正在使用（你必须）那么

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

如果可能的话，它使用from（ES5）功能来实现最佳性能（请参阅），并针对较旧的引擎（浏览器）回退到最兼容的方法

解决方案
下面是此代码的详细信息

下面是演示和简单测试的示例

我希望它能帮助别人。干杯
 这是我首选的解决方案：

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

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

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

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

对于不等于，请使用以下命令：
JSON.stringify（obj）！='{}'

看看这个
：

//因为Object.keys（new Date（））.length==0；
//我们必须做一些额外的检查
obj/使用Object.keys（obj）。对于空对象，长度（如上针对ECMA 5+的建议）要慢10倍！保持旧有的学校（为…保留）选项

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


（for…in…）是最快的使用选项

Object.keys（obj）。空对象的长度要慢10倍

JSON.stringify（obj）。长度总是最慢的（不足为奇）

Object.getOwnPropertyNames（obj）。长度比Object.keys（obj）长。在某些系统上，长度可以长得多


底线性能方面，使用：

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

或

详细的测试结果和测试代码，请参见我找到的最佳方法：

    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

工作对象：

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

下面的示例演示了如何测试JavaScript对象是否为空，如果是空的，则表示它没有自己的属性

该脚本适用于ES6


const isEmpty=（obj）=>{
如果（obj==null||
obj==未定义||
数组.isArray（obj）||
对象的类型！=“对象”
) {
返回true；
}
返回Object.getOwnPropertyNames（obj）.length==0；
};
console.clear（）；
console.log（'----'）；
console.log（isEmpty（“”））；//真的
console.log（isEmpty（33））；//真的
console.log（isEmpty（[]）；//真的
console.log（isEmpty（{}））；//真的
log（isEmpty（{length:0，custom_属性：[]}））；//假的
console.log（'----'）；
console.log（isEmpty（'Hello'））；//真的
log（isEmpty（[1,2,3]）；//真的
log（isEmpty（{test:1}））；//假的
log（isEmpty（{length:3，custom_属性：[1,2,3]}））；//假的
console.log（'----'）；
console.log（isEmpty（new Date（））；//真的
console.log（isEmpty（Infinity））；//真的
console.log（isEmpty（null））；//真的
console.log（isEmpty（未定义））；//true
您可以检查对象键的计数：

Boolean(Object.keys(obj || {})[0]) // obj || {} checks for undefined

正确答案是：

const isEmptyObject=obj=>
Object.getOwnPropertyNames（obj）.length==0&&
Object.getOwnPropertySymbols
/**
 * 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;
    }
}

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

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

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
obj // Using Object.keys(obj).length (as suggested above for ECMA 5+) is 10 times slower for empty objects!  keep with the old school (for...in) option.


Tested under Node, Chrome, Firefox and IE 9, it becomes evident that for most use cases:



(for...in...) is the fastest option to use! 
Object.keys(obj).length is 10 times slower for empty objects
JSON.stringify(obj).length is always the slowest (not suprising)
Object.getOwnPropertyNames(obj).length takes longer than Object.keys(obj).length can be much longer on some systems.


Bottom line performance wise, use:


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

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

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

Boolean(Object.keys(obj || {})[0]) // obj || {} checks for undefined

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