解决方案

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

lodash：

_.isEmpty({}); // true

Underscore：

_.isEmpty({}); // true

Hoek

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

ExtJS

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

AngularJS (version 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 support可用，则可以改为使用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

您可以使用Underscore.js。

_.isEmpty({}); // true

Answer 6

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

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

Answer 7

性能

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

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 8

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

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

Answer 9

我刚遇到类似的情况。我不想使用JQuery，并希望使用纯Javascript。

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

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

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

查看此JSFiddle

Answer 10

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

Answer 11

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

如果可能，它会使用Object.keys（ES5）功能中的ECMAScript 5来实现最佳性能（请参阅compatibility table）并回退到旧引擎（浏览器）的最兼容方法。< / p>

解决方案

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

以下是此代码的Gist。

这是JSFiddle演示和简单测试。

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

Answer 12

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

Select DATE=convert(varchar(10),a.DATE_NAV,104), TIME=convert(varchar(5),R.MAXTIME,108) 
from
(select max(DATE_NAV) as maxtime from @Temp group by day([DATE_NAV])) R
inner join  @Temp a on R.MAXTIME=A.DATE_NAV
order by R.MAXTIME asc

Answer 13

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

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

检查它的另一种方法：

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

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

Answer 14

使用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 object empty?

查看详细的测试结果和测试代码

Answer 15

我正在使用它。

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;

from here

<强>更新

OR

您可以使用isEmptyObject的jQuery实现

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

Answer 16

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

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

Answer 18

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

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

详细了解http://api.jquery.com/jQuery.isEmptyObject/

Answer 19

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

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

Answer 20

我找到的最佳方式：

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 21

您可以使用这个不使用 jQuery 或其他库

的简单代码

var a=({});

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

JSON 类及其功能（解析和 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 22

我的看法：

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 23

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

_.isEmpty({}) // returns true

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

Answer 24

2021 - 解决方案

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

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

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 25

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

Answer 26

根据 Object.entries() 上的 ES2017 规范，检查为使用任何现代浏览器都可以轻松实现-

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

Answer 27

买者！谨防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 28

正确答案是：

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

这会检查：

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

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

Answer 29

除了Thevs回答：

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

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

它是jquery + jquery.json

Answer 30

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

制作扩展对象：

a = Object.extended({})

检查它的大小：

a.size()

Answer 31

在所有库中，所有库中的所有空检查方法都使用对象键检查逻辑。它是一种让它易于理解的奇怪方法，你可以把它放在一个方法中，描述here。

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 32

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

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

显然所有这些库都不完全相同，所以如果你需要轻松操作DOM，那么jquery可能仍然是一个不错的选择，或者如果你需要的不只是类型检查，那么lodash或{ {3}}可能会很好。至于underscore，这是语法：

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

与下划线和lodash _.isObject()一样，这不仅适用于objects，也适用于arrays和strings。

这个库正在使用Object.getOwnPropertyNames，它类似于Object.keys，但Object.getOwnPropertyNames更加彻底，因为它将返回如{{3}所述的可枚举和不可枚举的属性}。

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 33

    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

Answer 34

与此同时，我们可以使用一个函数来检查所有'空'，例如 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;
    }
}

用例和结果。

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 35

1。使用Object.keys

Object.keys将返回一个Array，其中包含对象的属性名称。如果数组的长度为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。使用Underscore和Lodash

_.isEmpty(obj);

Resource

Answer 36

这一行代码有帮助

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.getOwnPropertyNames 在ECMA-5中实施。以上行适用于具有回退功能的旧浏览器。

JSFiddler

Answer 37

我能找到（更新）的最佳一线解决方案：

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 38

我知道这不能100％回答您的问题，但是我之前也遇到过类似的问题，这是我用来解决这些问题的方法：

我有一个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字段，则该对象为空。

Answer 39

您最想知道的是，对象在使用前是否具有属性。因此，除了询问isEmpty而不是像if(!isEmpty(obj))那样总是检查否定之外，您只需测试对象是否不为null而是具有属性

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

Answer 40

在这里有一些其他答案的帮助下，我喜欢我想到的这个。以为我会分享。

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

Answer 41

我们也可以使用null或undefined检查来检查香草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

Answer 42

检查值的新方法是 if（Object.entries（this.props.myarticle）.length === 0）{ }

这里的myarticles是对象

Answer 43

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

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

Object.keys 不会检索符号属性。

Answer 44

尝试Destructuring

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

Answer 45

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

Answer 46

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

这将递归过滤掉所有无效字段。

Answer 47

这与在 lodash 对象中检查来源的方式类似：

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

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

Answer 48

要真正接受唯一 {}，使用Lodash在Javascript中实现的最佳方法是：

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

Answer 49

纯香草Java脚本，并向后兼容


        for (int i = 0; i < length; i++){
            for (int j = 0; j < length; j++) {
                pointUp[i][j] = ' ';
            }
        }

        int end = length; 
        int j = 0;
        for (int column = 0; column < end; column++) {
            for (int row = j; row <= length/2; row++) {
                pointUp[row][column] = asterik;
            }
            j++;
            end++;

        }
        return pointUp;

Answer 50

我正在为AJAX调用返回一个空的JSON响应，而在IE8中，jQuery.isEmptyObject（）没有正确验证。我添加了一个额外的检查，似乎正确捕捉它。

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

Answer 51

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

class ProtectedResourceMixin(OAuthLibMixin):

        def dispatch(self, request, *args, **kwargs):

            if request.method.upper() == "OPTIONS":
                return super().dispatch(request, *args, **kwargs)

            valid, r = self.verify_request(request)
            if valid:
                request.resource_owner = r.user
                return super().dispatch(request, *args, **kwargs)
            else:

                request.oauth2_error = getattr(r, "oauth2_error", {})
                print(str(self.request.oauth2_error['error']))

                data= {
                            "errors": [
                                    {
                                      "message": str(self.request.oauth2_error['error'])
                                    }
                                ],
                }
                return HttpResponse(json.dumps(data,ensure_ascii=False),content_type="application/json; charset=utf-8",status= 401)
                #return HttpResponseForbidden()

Answer 52

这很奇怪，我在这里找不到按值进行比较（在许多解决方案中可能会漏掉）。我想介绍一种情况，如果对象的所有值都未定义，则认为该对象为空：

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /sub-directory-name
RewriteRule ^index\.php$ - [L]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . /sub-directory-name/index.php [L]
</IfModule>

因此，仅当提供子选项时，我们才能扩展选项对象

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

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

Answer 53

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

定义应如下所示：

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

享受！： - ）

Answer 54

只需检查索引rem classpath addition for LSB style path if exist %BASE_DIR%\share\java\kafka\* ( call:concat %BASE_DIR%\share\java\kafka\* )。

Answer 55

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

jQuery.isPlainObject({}) // true

jQuery.isPlainObject( "test" ) // false

Jquery api

Answer 56

你可以使用 lodash 库来代替普通的 JS 函数。

_.isEmpty({}) // 真

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

Answer 57

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

上面的代码足以检查一个对象的空性。

一篇很好的文章写在how-to-check-if-object-is-empty

Answer 58

完美而安全的解决方案

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

更好，更安全的解决方案将是。

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

Answer 59

将isEmpty（）添加到对象原型的版本：

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

如何测试空的JavaScript对象？

59 个答案:

性能

详细信息

解决方案

1。使用Object.keys

2。用for…in

4。使用jQuery

5。使用Underscore和Lodash

完美而安全的解决方案