如何有效地计算 JavaScript 中对象的键/属性的数量

Question

计算对象的键/属性数量的最快方法是什么？是否可以在不迭代对象的情况下做到这一点？即，不做：

var count = 0;
for (k in myobj) if (myobj.hasOwnProperty(k)) ++count;

（Firefox 确实提供了一个神奇的 __count__ 属性，但它在版本 4 左右被删除了。）

Answer 1

我认为这是不可能的（至少在不使用一些内部组件的情况下是不可能的）。而且我认为优化它不会给您带来太多收益。

Answer 2

如果您确实遇到了性能问题，我建议您将向对象添加/删除属性的调用封装在一个函数中，该函数还增加/减少适当命名的（大小？）属性。

您只需要计算一次属性的初始数量，然后从那里继续。如果没有实际的性能问题，请不要打扰。只需将那段代码包装在函数 getNumberOfProperties(object) 中即可。

Answer 3

我不知道有什么方法可以做到这一点。但是，为了将迭代保持在最低限度，您可以尝试检查 __count__ 是否存在，如果它不存在（即不是 Firefox），那么您可以遍历该对象并定义它以供以后使用，例如：

if (myobj.__count__ === undefined) {
  myobj.__count__ = ...
}

这样，任何支持__count__ 的浏览器都会使用它，并且只会对不支持的浏览器进行迭代。如果计数发生变化而您无法执行此操作，则始终可以将其设为函数：

if (myobj.__count__ === undefined) {
  myobj.__count__ = function() { return ... }
  myobj.__count__.toString = function() { return this(); }
}

这样，每当您引用 myobj.__count__ 时，该函数都会触发并重新计算。

Answer 4

要在任何ES5-兼容环境中执行此操作，例如Node.js、Chrome、Internet Explorer 9+、Firefox 4+ 或 Safari 5+：

Object.keys(obj).length

• Browser compatibility
• Object.keys documentation（包括一个可以添加到非 ES5 浏览器的方法）

Answer 5

您可以使用以下代码：

if (!Object.keys) {
    Object.keys = function (obj) {
        var keys = [],
            k;
        for (k in obj) {
            if (Object.prototype.hasOwnProperty.call(obj, k)) {
                keys.push(k);
            }
        }
        return keys;
    };
}

那么您也可以在旧版浏览器中使用它：

var len = Object.keys(obj).length;

Answer 6

如果您使用Underscore.js，您可以使用_.size (thanks douwe)：

_.size(obj)

您也可以使用_.keys，这对某些人来说可能更清楚：

_.keys(obj).length

我强烈推荐 Underscore.js。这是一个紧凑的库，可以做很多基本的事情。只要有可能，它们就会匹配 ECMAScript 5 并遵循本机实现。

否则我支持Avi Flax' answer。我对其进行了编辑以添加指向 MDC 文档的链接，其中包含可以添加到非 ECMAScript 5 浏览器的 keys() 方法。

Answer 7

我解决此问题的方法是构建我自己的基本列表实现，该列表记录对象中存储了多少项目。这很简单。像这样的：

function BasicList()
{
   var items = {};
   this.count = 0;

   this.add = function(index, item)
   {
      items[index] = item;
      this.count++;
   }

   this.remove = function (index)
   {
      delete items[index];
      this.count--;
   }

   this.get = function(index)
   {
      if (undefined === index)
        return items;
      else
        return items[index];
   }
}

Answer 8

对于那些在他们的项目中包含 Underscore.js 的人，您可以这样做：

_({a:'', b:''}).size() // => 2

或功能风格：

_.size({a:'', b:''}) // => 2

Answer 9

对于那些在他们的项目中有Ext JS 4 的人，你可以这样做：

Ext.Object.getSize(myobj);

这样做的好处是它适用于所有与 Ext JS 兼容的浏览器（包括Internet Explorer 6 - Internet Explorer 8）。但是，我相信运行时间并不比 O(n) 好，与其他建议的解决方案一样。

Answer 10

如果之前答案中的 jQuery 不起作用，请尝试

$(Object.Item).length

Answer 11

作为stated by Avi Flax，

Object.keys(obj).length

将为您的对象上的所有可枚举属性做这个技巧，但也包括不可枚举的属性，您可以改用Object.getOwnPropertyNames。区别如下：

var myObject = new Object();

Object.defineProperty(myObject, "nonEnumerableProp", {
  enumerable: false
});
Object.defineProperty(myObject, "enumerableProp", {
  enumerable: true
});

console.log(Object.getOwnPropertyNames(myObject).length); //outputs 2
console.log(Object.keys(myObject).length); //outputs 1

console.log(myObject.hasOwnProperty("nonEnumerableProp")); //outputs true
console.log(myObject.hasOwnProperty("enumerableProp")); //outputs true

console.log("nonEnumerableProp" in myObject); //outputs true
console.log("enumerableProp" in myObject); //outputs true

作为stated here，它与Object.keys具有相同的浏览器支持。

但是，在大多数情况下，您可能不想在这些类型的操作中包含不可枚举，但了解它们的区别总是好的；）

Answer 12

标准的 Object 实现 (ES5.1 Object Internal Properties and Methods) 不需要 Object 来跟踪其键/属性的数量，因此不应该有标准的方法来确定 Object 的大小而无需显式或隐式迭代它的钥匙。

所以这里是最常用的替代方案：

1。 ECMAScript 的 Object.keys()

Object.keys(obj).length; 通过内部迭代键来计算临时数组并返回其长度。

• 优点 - 可读且简洁的语法。如果本机支持不可用，则不需要任何库或自定义代码，除了 shim
• 缺点 - 由于创建数组而导致的内存开销。

2。基于库的解决方案

本主题其他地方的许多基于库的示例在其库的上下文中都是有用的习语。然而，从性能的角度来看，与完美的无库代码相比，没有任何好处，因为所有这些库方法实际上都封装了 for 循环或 ES5 Object.keys（本机或填充）。

3。优化 for 循环

这种for循环的最慢​​的部分通常是.hasOwnProperty()调用，因为函数调用开销。因此，当我只想要 JSON 对象的条目数时，如果我知道没有代码也不会扩展 Object.prototype，我就跳过 .hasOwnProperty() 调用。

否则，您的代码可以通过将 k 设为本地 (var k) 并使用前缀增量运算符 (++count) 而不是后缀来略微优化。

var count = 0;
for (var k in myobj) if (myobj.hasOwnProperty(k)) ++count;

另一个想法依赖于缓存hasOwnProperty方法：

var hasOwn = Object.prototype.hasOwnProperty;
var count = 0;
for (var k in myobj) if (hasOwn.call(myobj, k)) ++count;

这在给定环境中是否更快是基准测试的问题。无论如何，可以预期的性能提升非常有限。

Answer 13

要在Avi Flax' answer 上进行迭代，Object.keys(obj).length 对于没有与之绑定函数的对象是正确的。

例子：

obj = {"lol": "what", owo: "pfft"};
Object.keys(obj).length; // should be 2

对

arr = [];
obj = {"lol": "what", owo: "pfft"};
obj.omg = function(){
    _.each(obj, function(a){
        arr.push(a);
    });
};
Object.keys(obj).length; // should be 3 because it looks like this
/* obj === {"lol": "what", owo: "pfft", omg: function(){_.each(obj, function(a){arr.push(a);});}} */

避免这种情况的步骤：

1. 不要将函数放在要计算其中键数的对象中

2. 使用单独的对象或专门为函数创建一个新对象（如果您想使用Object.keys(obj).length 计算文件中有多少个函数）

另外，是的，我在示例中使用了来自 Node.js 的 _ 或 Underscore.js 模块。

可以在here 上找到文档以及它在 GitHub 上的来源和各种其他信息。

最后是 lodash 实现 https://lodash.com/docs#size

_.size(obj)

Answer 14

来自Object.defineProperty()：

Object.defineProperty(obj, prop, 描述符)

您可以将其添加到所有对象中：

Object.defineProperty(Object.prototype, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

或单个对象：

var myObj = {};
Object.defineProperty(myObj, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

例子：

var myObj = {};
myObj.name  = "John Doe";
myObj.email = "leaked@example.com";
myObj.length; // Output: 2

这样添加，它不会显示在 for..in 循环中：

for(var i in myObj) {
    console.log(i + ": " + myObj[i]);
}

输出：

name: John Doe
email: leaked@example.com

注意：在Internet Explorer 9之前的浏览器中不起作用。

Answer 15

如上一个答案中的回答：Object.keys(obj).length

但是：由于我们现在在 ES6 中有一个真正的 Map 类，我会 suggest 使用它而不是使用对象的属性。

const map = new Map();
map.set("key", "value");
map.size; // THE fastest way

Answer 16

您可以使用：

Object.keys(objectName).length; 

和

Object.values(objectName).length;

Answer 17

我尝试使其对所有对象都可用，如下所示：

Object.defineProperty(Object.prototype,
                      "length",
                      {
                          get() {
                              if (!Object.keys) {
                                  Object.keys = function (obj) {
                                      var keys = [],k;
                                      for (k in obj) {
                                          if (Object.prototype.hasOwnProperty.call(obj, k)) {
                                              keys.push(k);
                                          }
                                      }
                                      return keys;
                                  };
                              }
                              return Object.keys(this).length;
                      },});

console.log({"Name":"Joe", "Age":26}.length) // Returns 2

Answer 18

OP 没有指定对象是否为 nodeList。如果是，那么您可以直接在其上使用 length 方法。示例：

buttons = document.querySelectorAll('[id=button)) {
console.log('Found ' + buttons.length + ' on the screen');

Answer 19

以下是对三种方法的一些性能测试；

https://jsperf.com/get-the-number-of-keys-in-an-object

Object.keys().length

每秒 20,735 次操作

它非常简单且兼容，运行速度很快但很昂贵，因为它会创建一个新的键数组，然后将其丢弃。

return Object.keys(objectToRead).length;

遍历键

每秒 15,734 次操作

let size=0;
for(let k in objectToRead) {
  size++
}
return size;

它稍微慢一些，但与内存使用量相差甚远，因此如果您有兴趣针对移动设备或其他小型机器进行优化，它可能会更好。

使用地图代替对象

每秒 953,839,338 次操作

return mapToRead.size;

基本上，Map 会跟踪它自己的大小，所以我们只是返回一个数字字段。它比任何其他方法都快得多。如果您可以控制该对象，请将其转换为地图。