javascript - 如何测试一个空的 JavaScript 对象？

Question

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

var a = {};

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

score 6926 · Accepted Answer

ECMA 5+：

// because Object.keys(new Date()).length === 0;
// we have to do some additional check
obj //  null and undefined check
&& Object.keys(obj).length === 0
&& Object.getPrototypeOf(obj) === Object.prototype

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

前 ECMA 5：

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

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

jQuery :

jQuery.isEmptyObject({}); // true

lodash：

_.isEmpty({}); // true

下划线：

_.isEmpty({}); // true

胡克

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

ExtJS

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

AngularJS（版本 1）

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

拉姆达

R.isEmpty({}); // true

score 1175 · Accepted Answer

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

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

对于 ES3 和更早版本，没有简单的方法可以做到这一点。您必须明确地遍历属性：

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

    return true;
}

score 588 · Accepted Answer

588

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

于 2010-05-19T14:07:51.293 回答

score 266 · Accepted Answer

表现

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

结论

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

细节

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

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

score 226 · Accepted Answer

226

您可以使用Underscore.js。

_.isEmpty({}); // true

于 2011-03-22T20:35:44.120 回答

score 127 · Accepted Answer

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

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

score 95 · Accepted Answer

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

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

score 63 · Accepted Answer

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

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

score 45 · Accepted Answer

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

score 44 · Accepted Answer

对于空对象，使用 Object.keys(obj).length （如上面对 ECMA 5+ 的建议）要慢 10 倍！保持老派（for...in）选项。

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

查看详细的测试结果和测试代码，对象是否为空？

score 30 · Accepted Answer

我正在使用这个。

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

score 27 · Accepted Answer

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

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

另一种检查方法：

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

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

score 25 · Accepted Answer

我的看法：

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()目前并非所有浏览器都实现了。

score 18 · Accepted Answer

18

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

于 2009-04-24T13:09:02.817 回答

score 17 · Accepted Answer

下面的例子展示了如何测试一个 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

score 13 · Accepted Answer

jQueryisEmptyObject()对这种情况有特殊的功能：

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

阅读更多关于http://api.jquery.com/jQuery.isEmptyObject/

score 10 · Accepted Answer

正确答案是：

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

这将检查：

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

换句话说，该对象与使用创建的对象没有区别{}。

score 8 · Accepted Answer

警告！当心 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（对象）

    返回

    {}

score 8 · Accepted Answer

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

score 7 · Accepted Answer

除了 Thevs 的回答：

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

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

这是 jquery + jquery.json

score 6 · Accepted Answer

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

制作一个扩展对象：

a = Object.extended({})

检查它的大小：

a.size()

score 6 · Accepted Answer

纯原版 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

score 6 · Accepted Answer

要真正接受ONLY {}，使用 Lodash 在 Javascript 中执行此操作的最佳方法是：

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

score 5 · Accepted Answer

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

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

score 5 · Accepted Answer

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

资源

score 5 · Accepted Answer

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

[如果你不喜欢历史 - 可以直接跳到工作代码]

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

谢谢阅读！

score 4 · Accepted Answer

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

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

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

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

像 underscore's 和 lodash's 一样_.isObject()，这不仅适用于 and ，objects而且也适用于arraysand 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 快一点，只是因为你没有检查它是否是一个对象。

score 4 · Accepted Answer

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

    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中破坏值。如果它们都未定义，则它们将被排除在结果选项集之外。如果不是，它们不是，它们都包括在内。xysize

function paintOnCanvas ({ brush, x, y, size }) {
  const baseOptions = { brush }
  const areaOptions = { x, y, size }
  const options = isObjectEmpty(areaOptions) ? baseOptions : { ...baseOptions, areaOptions }
  // ...
}

score 4 · Accepted Answer

我知道这不能 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 字段，该对象将为空。

score 4 · Accepted Answer

我们也可以使用 vanilla js 来处理 null 或 undefined 检查，如下所示，

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

score 4 · Accepted Answer

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

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

score 3 · Accepted Answer

这一行代码也有助于回退到旧浏览器。

var a = {}; //if empty returns false
(Object.getOwnPropertyNames ? Object.getOwnPropertyNames(a).length !== 0 : (function(){ for(var key in a) break; return !!key })()) //Returns False

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

Object.getOwnPropertyNames在 ECMA-5 中实现。上面的行适用于具有后备功能的旧浏览器。

另一个快速解决方案是检查length, Object.keys或Object.entriesObject.values

知识文章：关注此 SO 帖子了解Object.keys 与 Object.getOwnPropertyNames之间的详细区别

score 3 · Accepted Answer

我不敢相信经过两年的 js 编程，它从来没有点击过空对象和数组不是假的，最奇怪的是它从来没有让我失望。

true如果输入默认为假，或者它是一个空对象或数组，这将返回。倒数是trueish函数

http://codepen.io/synthet1c/pen/pjmoWL

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

score 3 · Accepted Answer

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

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

Object.keys不检索符号属性。

score 3 · Accepted Answer

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

这里 myarticles 是对象

score 3 · Accepted Answer

大多数情况下，您想知道的是，对象在使用之前是否具有属性。因此，不要询问isEmpty然后总是检查否定，就像if(!isEmpty(obj))您可以测试对象是否不为空并且具有属性一样

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

score 2 · Accepted Answer

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

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

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

score 1 · Accepted Answer

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

jQuery.isPlainObject({}) // true

jQuery.isPlainObject( "test" ) // false

jQuery API

score 1 · Accepted Answer

我为 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
    }
});

score 1 · Accepted Answer

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

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

用法：

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

score 0 · Accepted Answer

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

定义应如下所示：

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

享受！:-)

score 0 · Accepted Answer

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

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

score 0 · Accepted Answer

这与在lodash源中检查 object 的方式类似：

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

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

score 0 · Accepted Answer

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

score 0 · Accepted Answer

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

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

score 0 · Accepted Answer

您可以使用 lodash 库而不是制作普通的 JS 函数。

_.isEmpty({}) // 真

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

score -1 · Accepted Answer

这是一个快速、简单的函数：

function isEmptyFunction () {
  for (const i in this) return false
  return true
}

作为吸气剂实现：

Object.defineProperty(Object.prototype, 'isEmpty', { get: isEmptyFunction })

console.log({}.isEmpty) // true

作为一个单独的函数实现：

const isEmpty = Function.prototype.call.bind(isEmptyFunction)

console.log(isEmpty({})) // true

score -1 · Accepted Answer

尝试解构

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

score -2 · Accepted Answer

完美的故障安全解决方案

我认为第一个接受的解决方案在大多数情况下都有效，但不是Failsafe。

更好和故障安全的解决方案将是。

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，则代码不会中断。并返回空值。