关于JSON：如何测试空的javascript对象？


How do I test for an empty JavaScript object?

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

1
var a = {};

我该怎么检查情况呢？

相关讨论

ECMA 7＋：

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

ECMA 5＋：

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

预ECMA 5：

1
2
3
4
5
6
7
8
9
function isEmpty(obj) {
  for(var prop in obj) {
    if(obj.hasOwnProperty(prop)) {
      return false;
    }
  }

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

jQuery：

1
jQuery.isEmptyObject({}); // true

拉达什：

1
_.isEmpty({}); // true

强调：

1
_.isEmpty({}); // true

胡克

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

EXTJS

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

AngularJS(版本1)

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

拉姆达

1
R.isEmpty({}); // true
相关讨论

这样做不容易。您必须显式地循环属性：

1
2
3
4
5
6
7
8
function isEmpty(obj) {
    for(var prop in obj) {
        if(obj.hasOwnProperty(prop))
            return false;
    }

    return true;
}

如果ecmascript 5支持可用，则可以使用Object.keys()：

1
2
3
function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}
相关讨论

对于有相同问题但使用jquery的用户，可以使用jquery.isEmptyObject。

相关讨论

这是我的首选解决方案：

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

您可以使用underline.js。

1
_.isEmpty({}); // true
相关讨论

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

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

相关讨论

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

1
2
3
function isEmptyObject(obj){
    return JSON.stringify(obj) === '{}';
}
相关讨论

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

1
2
3
4
5
6
7
8
9
function isEmptyObject(obj) {
    var name;
    for (name in obj) {
        if (obj.hasOwnProperty(name)) {
            return false;
        }
    }
    return true;
}
相关讨论

我也遇到过类似的情况。我不想使用jquery，我想使用纯javascript来实现这一点。

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

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

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

看看这个J小提琴

相关讨论

如果你在一个更新的浏览器上，有一个简单的方法。Object.keys(obj).length == 0

相关讨论

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

如果可能的话，它使用ECMAScript 5(ES5)功能中的Object.keys，以获得最佳性能(参见兼容性表)，并回退到旧引擎(浏览器)最兼容的方法。

解决方案

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * 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;
    }
}

这是这个代码的要点。

这里是JS处理演示和一个简单的测试。

我希望它能帮助别人。干杯！

相关讨论

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

1
2
3
if (Object.keys(a).length > 0) {
    // not empty
}
相关讨论

  • 只是权宜之计。您的服务器能否在没有数据的情况下生成一些特殊属性？

    例如：

    1
    var a = {empty:true};

    然后您可以在Ajax回调代码中轻松地检查它。

  • 另一种检查方法：

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

    • 编辑：如果使用任何JSON库(f.e.json.js)，则可以尝试json.encode()函数，并根据空值字符串测试结果。

    相关讨论

    对于空对象，使用object.keys(obj).length(如上面对ecma 5+的建议)要慢10倍！保留旧学校的选择。

    在node、chrom、firefox和ie 9下测试，很明显对于大多数用例：

    • (对于…在…)是最快的选择使用！
    • object.keys(obj).length对于空对象来说慢10倍
    • json.stringify(obj).length总是最慢的(而不是最慢的)
    • object.getownprotynames(obj).length比object.keys(obj)长。在某些系统上，length可以长很多。

    底线性能，使用：

    1
    2
    3
    4
    function isEmpty(obj) {
       for (var x in obj) { return false; }
       return true;
    }

    或

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

    请参阅详细的测试结果和测试代码，该代码位于对象是否为空？

    我在用这个。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    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;
    }

    如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    var myObject = {}; // Object is empty
    var isEmpty  = isObjectEmpty(myObject); // will return true;

    // populating the object
    myObject = {"name":"John Smith","Address":"Kochi, Kerala
    <div class="    suo-content">[collapse title=""]<ul><li>你好。当使用数字或布尔值true或false测试此函数时，返回true，这是不正确的结果。IsObjectEmpty(true)。IsObjectEmpty(假)。IsObjectEmpty(1)</li><li>我们正在检查对象是否为空，而不是数据类型是否为对象。在您的情况下，要检查它是否是一个对象，我们需要类似于if(typeof a=="object")…</li></ul>[/collapse]</div><hr><P>下面的示例演示如何测试javascript对象是否为空，如果为空，则表示它没有自己的属性。</P><P>该脚本在ES6上工作。</P><P>[cc lang="javascript"]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

    jquery对于这种情况有特殊的功能isEmptyObject()：

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

    请访问http://api.jquery.com/jquery.isEmptyObject了解更多信息/

    相关讨论

    1
    2
    3
    4
    function isEmpty(obj) {
      for(var i in obj) { return false; }
      return true;
    }
    相关讨论

    我发现最好的方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    function isEmpty(obj)
    {
        if (!obj)
        {
            return true;
        }

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

        return false;
    }

    作品：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
        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
    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    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来修复它。
    BR/>其他简单方式(最简单方式)：
    您可以这样使用而不使用jquery或json对象。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    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
    相关讨论

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

    1
    typeof obj !=="undefined" && Boolean(Object.keys(obj)[0])
    相关讨论

    我的拿手：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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浏览器不可用，那么在underline.js中还有一个isEmpty函数。

    1
    _.isEmpty({}) // returns true

    此外，它不假定输入参数是对象。对于列表、字符串或未定义的，它还将转换正确的答案。

    相关讨论

    As per the ES2017 specification on Object.entries(), the check is
    simple using any modern browser--

    1
    Object.entries({}).length === 0
    相关讨论

    正确答案是：

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

    这将检查：

    • 对象没有自己的属性(不考虑可枚举性)。
    • 对象没有自己的属性符号。
    • 对象的原型正是Object.prototype。

    换句话说，对象与使用{}创建的对象是不可区分的。

    警告！注意JSON的限制。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    javascript:
      obj={  f:function(){}  };
      alert("Beware!! obj is NOT empty!

    obj = {  f:function(){}  }"     +
                  "

    JSON.stringify( obj )

    returns

    "     +
                            JSON.stringify( obj ) );

    显示器

    1
    2
    3
    4
    5
    6
    7
    8
    9
        Beware!! obj is NOT empty!

        obj = {  f:function(){}  }

        JSON.stringify( obj )

        returns

        {}

    Sugar.JS provides extended objects for this purpose. The code is clean and simple:

    Make an extended object:

    1
    a = Object.extended({})

    检查尺寸：

    1
    a.size()

    除了vs回答：

    1
    2
    3
    4
    5
    var o = {};
    alert($.toJSON(o)=='{}'); // true

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

    是jquery+jquery.json

    相关讨论

    Another alternative is to use is.js (14kB) as opposed to jquery (32kB), lodash (50kB), or underscore (16.4kB). is.js proved to be the fastest library among aforementioned libraries that could be used to determine whether an object is empty.

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

    Obviously all these libraries are not exactly the same so if you need to easily manipulate the DOM then jquery might still be a good choice or if you need more than just type checking then lodash or underscore might be good. As for is.js, here is the syntax:

    1
    2
    3
    4
    5
    6
    7
    var a = {};
    is.empty(a); // true
    is.empty({"hello":"world
    <hr><P>在引擎盖下，所有库中的所有空检查方法都使用对象键检查逻辑。这是一个奇怪的方法，使它可以理解，你可以在这里描述一个方法。</P>[cc lang="    javascript"]for(key in obj){
       //your work here.
     break;
    }

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

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

    或者如果你使用的是罗达什(你必须这样)。

    1
     _.isEmpty(obj) //==true or false
    相关讨论

    这一行代码有助于

    1
    2
    3
    4
    5
    var a = {}; //if empty returns false
    (Object.getOwnPropertyNames != undefined ? Object.getOwnPropertyNames(a).length != 0 : (function(){for(var key in a) break; return (key != null) && (key != undefined);})()) //Returns False

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

    object.getownprotyname在ECMA-5中实现。上面这一行在具有回退功能的旧浏览器中工作。

    杰斯菲德勒

    1
    2
    3
    4
    5
    6
        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;
        }

    这将检查字符串、数组或对象(映射)的空性。

    用途：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    var a = {"a":"xxx","b":[1],"c":{"c_a":"
    <hr><P>我不敢相信，经过两年的JS编程，它从来没有点击过空对象和数组不是假的，最奇怪的是它从来没有抓住我。</P><P>如果默认输入是错误的，或者输入是空对象或数组，则返回<wyn>true</wyn>。逆函数是<wyn>trueish</wyn>函数。</P><P>http://codepen.io/synthet1c/pen/pjmowl</P>[cc lang="    javascript"]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({})           //=> true
    falsish({foo:'bar'})  //=> false
    falsish([])           //=> true
    falsish(['foo'])      //=> false
    falsish(false)        //=> true
    falsish(true)         //=> false
    // the rest are on codepen
    相关讨论

    同时，我们可以有一个函数来检查所有的"空"如空、未定义、""、""、、[]。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    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;
        }
    }

    用例和结果。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    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
    相关讨论

    尝试破坏

    1
    2
    3
    4
    const a = {};
    const { b } = a;
    const emptryOrNot = (b) ? 'not Empty' : 'empty';
    console.log(emptryOrNot)
    相关讨论

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

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    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;
    }

    我为Ajax调用返回了一个空的JSON响应，而在ie8 jquery.isEmptyObject()中没有正确验证。我又加了一张支票，似乎能正确地抓住它。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    .done(function(data)
    {  
        // Parse json response object
        var response = jQuery.parseJSON(data);

        // In IE 8 isEmptyObject doesn't catch the empty response, so adding additional undefined check
        if(jQuery.isEmptyObject(response) || response.length === 0)
        {
            //empty
        }
        else
        {
            //not empty
        }
    });

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

    1
    2
    3
    jQuery.isPlainObject({}) // true

    jQuery.isPlainObject("test" ) // false

    jQuery API

    1
    2
    3
    4
    5
    6
    7
    export function isObjectEmpty(obj) {
      return (
        Object.keys(obj).length === 0 &&
        Object.getOwnPropertySymbols(obj).length === 0 &&
        obj.constructor === Object
      );
    }

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

    object.keys不检索符号属性。

    纯普通JavaScript，完全向后兼容

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    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({})
      }
    }

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

    You can define you own object prototype, just before its usage or at the beginning of your code.

    The definition should look like this:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Object.prototype.hasOwnProperties = function()
    {
      for (var k in this)
      {
        if ( this.hasOwnProperty(k) )
        {
          return true;
        }
      }
      return false;
    }

    下面是一个用法示例：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    var a = {};

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

    享受！-)

    奇怪的是，我在这里没有发现按价值进行比较(可能在这么多解决方案中遗漏了)。如果对象的所有值都未定义，我将介绍对象被视为空的情况：

    1
    2
    3
    4
    const isObjectEmpty = ( obj ) => Object.values( obj  ).every( val => typeof val ==="undefined" );

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

    因此，我们只能在提供子选项时扩展选项对象

    1
    2
    3
    4
    5
    6
    function onSubmit({ fullPage, width, height }) {
    const baseOptions = { fullPage },
          clip = { width, height },
          options = isObjectEmpty( clip ) ? baseOptions : { ...baseOptions, clip };
    //...
    }

    向对象原型添加isEmpty()的版本：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    // As a prototype:
    Object.prototype.isEmpty = function() {
        for(var i in this)
            return false;
        return true;
    }

    // As a function
    function objectIsEmpty(obj) {
        for (var i in obj) return false;
        return true;
    }

    var obj = {};
    if (obj.isEmpty()) console.log('empty');
    if (objectIsEmpty(obj)) console.log('empty');
    相关讨论