Javascript 对象是空的吗？

检查对象是否为空的最快方法是什么

有没有比这更快更好的方法：

function count_obj(obj){
    var i = 0;
    for(var key in obj){
        ++i;
    }

    return i;
}

我假设空的意思是“没有自己的属性”

如果只需要处理，则可以使用而不是循环：

这将确保即使对象仅具有不可枚举的属性，isEmpty仍将为您提供正确的结果。

对于ECMAScript 5（但并非所有浏览器都支持），您可以使用：

Object.keys(obj).length === 0

---

它可能有点黑。你可以试试这个

if (JSON.stringify(data).length === 2) {
   // Do something
}

不确定这种方法是否有任何缺点。

如果您不介意添加一个额外的库，每个方法都有一个方便的

isEmpty（）

函数

_.isEmpty({});

function(){ //must be within a function
 var obj = {}; //the object to test

 for(var isNotEmpty in obj) //will loop through once if there is a property of some sort, then
    return alert('not empty')//what ever you are trying to do once

 return alert('empty'); //nope obj was empty do this instead;
}

---

编辑：请注意，您可能应该使用而不是此选项，因为ES5支持现在很流行。但它仍然适用于jQuery

---

使用

jQuery.isEmptyObject

，可以轻松地跨浏览器访问：

if ($.isEmptyObject(obj))
{
    // do something
}

更多：

但是您需要jquery。

不需要库

_.isEmpty({});

function(){ //must be within a function
 var obj = {}; //the object to test

 for(var isNotEmpty in obj) //will loop through once if there is a property of some sort, then
    return alert('not empty')//what ever you are trying to do once

 return alert('empty'); //nope obj was empty do this instead;
}

---

“字典”对象的快速联机程序：

function isEmptyDict(d){for (var k in d) return false; return true}

---

如果Array.isArray和Object.getOwnPropertyNames不可用，则可以编写回退

XX.isEmpty = function(a){
    if(Array.isArray(a)){
        return (a.length==0);
    }
    if(!a){
        return true;
    }
    if(a instanceof Object){

        if(a instanceof Date){
            return false;
        }

        if(Object.getOwnPropertyNames(a).length == 0){
            return true;
        }
    }
    return false;
}

---

很惊讶看到这么多关于JS的基本问题的答案如此之弱。。。最重要的答案也不好，原因如下：

它生成一个全局变量

在

未定义时返回
true

在中为…使用

，这本身速度非常慢

for…in

中的函数无效-返回

false

而不使用

hasOwnProperty

magic可以正常工作

事实上，有一个更简单的解决方案：

function isEmpty(value) {
    return Boolean(value && typeof value === 'object') && !Object.keys(value).length;
}

优雅的方式-使用钥匙

var myEmptyObj = {};
var myFullObj = {"key":"value"};
console.log(Object.keys(myEmptyObj).length); //0
console.log(Object.keys(myFullObj).length); //1

非常方便：

_.isEmpty({})   // true
_.isEmpty()     // true
_.isEmpty(null) // true
_.isEmpty("")   // true

这有多糟

function(obj){
    for(var key in obj){
        return false; // not empty
    }

    return true; // empty
}

---

可能您可以使用此决定：

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

这是我的解决办法

function isEmpty(value) {
    if(Object.prototype.toString.call(value) === '[object Array]') {
        return value.length == 0;
    } else if(value != null && typeof value === 'object') {
        return Object.getOwnPropertyNames(value).length  == 0;
    } else {
        return !(value || (value === 0));
    }
}

---

Chears

这里有一个很好的方法

function isEmpty(obj) {
  if (Array.isArray(obj)) {
    return obj.length === 0;
  } else if (typeof obj === 'object') {
    for (var i in obj) {
      return false;
    }
    return true;
  } else {
    return !obj;
  }
}

var hasOwnProperty=Object.prototype.hasOwnProperty；
函数isArray（a）{
返回Object.prototype.toString.call（a）=='[对象数组]'
}
功能对象（a）{
返回Object.prototype.toString.call（a）=='[Object]'
}
函数为空（a）{
如果（null==a | |“”==a）返回！0；
if（“number”==typeof a | |“string”==typeof a）返回！1；
变量b=！0；
如果（isArray（a））{
如果（！a.length）返回！0；
对于（var c=0；c

让我们把这个婴儿放到床上；在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) { return false; }
   return true;
}

或

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

节点下的结果：

• 第一个结果：

  return（Object.keys（obj.length==0）

• 第二个结果：

  for（obj中的var x）{return false；}…

• 第三个结果：

  for（obj中的var x）{if（obj.hasOwnProperty（x））返回false；}…

• 第四个结果：

  return（'{}'==JSON.stringify（obj））

测试具有0个键的对象 0.00018 0.000015 0.000015 0.000324

测试具有1个键的对象 0.000346 0.000458 0.000577 0.000657

使用2个键测试对象 0.000375 0.00046 0.000565 0.000773

测试具有3个键的对象 0.000406 0.000476 0.000577 0.000904

测试具有4个键的对象 0.000435 0.000487 0.000589 0.001031

测试具有5个键的对象 0.000465 0.000501 0.000604 0.001148

用6个键测试对象 0.000492 0.000511 0.000618 0.001269

测试具有7个键的对象 0.000528 0.000527 0.000637 0.00138

测试具有8个键的对象 0.000565 0.000538 0.000647 0.00159

测试具有100个键的对象 0.003718 0.00243 0.002535 0.01381

测试具有1000个键的对象 0.0337 0.0193 0.0194 0.1337

注意，如果你的典型用例测试了一个非空的对象，只有很少的键，并且很少使用10个或更多的键来测试空的对象或对象，请考虑对象.KEY（OBJ）。否则，使用更通用的（for…in…）实现

请注意，Firefox似乎更快地支持Object.keys（obj）.length和Object.getOwnPropertyNames（obj）.length，这使它成为任何非空对象的更好选择，但当涉及空对象时，（for…in…）只需快10倍

我的2美分就是那个Object.keys（obj）。length是个糟糕的主意，因为它创建一个keys对象只是为了计算里面有多少个键，而不是破坏它！为了创建那个对象，他需要在关键点上循环。。。那么为什么要使用它而不是（for…in…）选项：）

var a={}；
函数timeit（func，count）{
如果（！count）count=100000；
var start=Date.now（）；
对于（i=0；i我修改了Sean Vieira的代码以满足我的需要。null和undefined根本不算作对象，数字、布尔值和空字符串返回false


“严格使用”；
//加快对hasOwnProperty的调用
var hasOwnProperty=Object.prototype.hasOwnProperty；
var isObjectEmpty=函数（obj）{
//null和undefined不为空
if（obj==null）返回false；
如果（obj==false）返回false；
if（obj==true）返回false；
if（obj==“”）返回false；
如果（对象类型==“编号”）{
返回false；
}   
//假设它的长度属性值为非零值
//那个属性是正确的。
如果（obj.length>0）返回false；
if（obj.length==0）返回
function isEmpty(obj) {
  if (Array.isArray(obj)) {
    return obj.length === 0;
  } else if (typeof obj === 'object') {
    for (var i in obj) {
      return false;
    }
    return true;
  } else {
    return !obj;
  }
}

var hasOwnProperty = Object.prototype.hasOwnProperty;
function isArray(a) {
    return Object.prototype.toString.call(a) === '[object Array]'
}
function isObject(a) {
    return Object.prototype.toString.call(a) === '[object Object]'
}
function isEmpty(a) {
    if (null == a || "" == a)return!0;
    if ("number" == typeof a || "string" == typeof a)return!1;
    var b = !0;
    if (isArray(a)) {
        if (!a.length)return!0;
        for (var c = 0; c < a.length; c++)isEmpty(a[c]) || (b = !1);
        return b
    }
    if (isObject(a)) {
        for (var d in a)hasOwnProperty.call(a, d) && (isEmpty(a[d]) || (b = !1));
        return b
    }
    return!0
}

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

var obj1= {};
var obj2= {test: "test"};

function isEmpty(obj) {
   //check if it's an Obj first
   var isObj = obj !== null 
   && typeof obj === 'object' 
   && Object.prototype.toString.call(obj) === '[object Object]';

   if (isObj) {
       for (var o in obj) {
           if (obj.hasOwnProperty(o)) {
               return false;
               break;
           }
       }
       return true;
   } else {
       console.error("isEmpty function only accept an Object");
   }
}

isEmpty(obj1); //this returns true
isEmpty(obj2); //this returns false
isEmpty([]); // log in console: isEmpty function only accept an Object

funtion isEmpty(o,i)
{
    for(i in o)
    {
        return!1
    }
    return!0
}

var x= {}
var y= {x:'hi'}
console.log(Object.keys(x).length===0)
console.log(Object.keys(y).length===0)

true
false