JavaScript 对象的长度

Question

如果我有一个 JavaScript 对象，比如说

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

是否有内置或公认的最佳实践方法来获取该对象的长度？

Answer 1

最有力的答案（即捕获您想要做的事情的意图，同时引起最少的错误）将是：

Object.size = function(obj) {
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

// Get the size of an object
var size = Object.size(myObj);

JavaScript 中有一种约定，您可以 不要向 Object.prototype 添加内容, ，因为它可以破坏各种库中的枚举。不过，向对象添加方法通常是安全的。

---

这是截至 2016 年的更新 ES5 的广泛部署 超越。 对于 IE9+ 和所有其他支持 ES5+ 的现代浏览器，您可以使用 Object.keys() 所以上面的代码就变成了：

var size = Object.keys(myObj).length;

这不必修改任何现有原型，因为 Object.keys() 现在已内置。

编辑: ：对象可以具有无法通过 Object.key 方法返回的符号属性。因此，如果不提及它们，答案将是不完整的。

语言中添加了符号类型，以便为对象属性创建唯一标识符。符号类型的主要好处是防止覆盖。

Object.keys 或者 Object.getOwnPropertyNames 不适用于符号属性。要归还它们，您需要使用 Object.getOwnPropertySymbols.

var person = {
  [Symbol('name')]: 'John Doe',
  [Symbol('age')]: 33,
  "occupation": "Programmer"
};

const propOwn = Object.getOwnPropertyNames(person);
console.log(propOwn.length); // 1

let propSymb = Object.getOwnPropertySymbols(person);
console.log(propSymb.length); // 2

Answer 2

如果你知道你就不用担心 hasOwnProperty 检查，您可以非常简单地执行此操作：

Object.keys(myArray).length

Answer 3

更新: ：如果您正在使用 下划线.js （推荐，它很轻量！），那么你就可以这样做

_.size({one : 1, two : 2, three : 3});
=> 3

如果不, ，并且您不想因为任何原因而弄乱对象属性，并且已经在使用 jQuery，那么插件同样可以访问：

$.assocArraySize = function(obj) {
    // http://stackoverflow.com/a/6700/11236
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

Answer 4

这是最跨浏览器的解决方案。

这比接受的答案更好，因为它使用本机 Object.keys（如果存在）。因此，它是所有现代浏览器中最快的。

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

Object.keys(obj).length;

Answer 5

我不是 JavaScript 专家，但看起来您必须循环遍历元素并计算它们，因为 Object 没有 length 方法：

var element_count = 0;
for (e in myArray) {  if (myArray.hasOwnProperty(e)) element_count++; }

@palmsey：公平地说，JavaScript 文档实际上明确地将这种使用 Object 类型的变量称为“关联数组”。

Answer 6

此方法将对象的所有属性名称获取到一个数组中，因此您可以获得该数组的长度，该长度等于对象的键的长度。

Object.getOwnPropertyNames({"hi":"Hi","msg":"Message"}).length; // => 2

Answer 7

为了不弄乱原型或其他代码，您可以构建并扩展自己的对象：

function Hash(){
    var length=0;
    this.add = function(key, val){
         if(this[key] == undefined)
         {
           length++;
         }
         this[key]=val;
    }; 
    this.length = function(){
        return length;
    };
}

myArray = new Hash();
myArray.add("lastname", "Simpson");
myArray.add("age", 21);
alert(myArray.length()); // will alert 2

如果您始终使用 add 方法，则 length 属性将是正确的。如果您担心自己或其他人忘记使用它，您也可以将其他人发布的属性计数器添加到 length 方法中。

当然，您始终可以覆盖这些方法。但即使您这样做，您的代码也可能会明显失败，从而使其易于调试。;)

Answer 8

最简单的是

Object.keys(myObject).length

Answer 9

方法如下，不要忘记检查该属性是否不在原型链上：

var element_count = 0;
for(var e in myArray)
    if(myArray.hasOwnProperty(e))
        element_count++;

Answer 10

只需使用它即可获得 length:

Object.keys(myObject).length

Answer 11

对于某些情况，最好将大小存储在单独的变量中。特别是，如果您在一个位置向数组添加一个元素，并且可以轻松增加大小。如果您需要经常检查尺寸，显然它的工作速度会快得多。

Answer 12

这是一个完全不同的解决方案，仅适用于更现代的浏览器（IE9+、Chrome、Firefox 4+、Opera 11.60+、Safari 5.1+）

看 jsFiddle

设置关联数组类

/**
 * @constructor
 */
AssociativeArray = function () {};

// Make the length property work
Object.defineProperty(AssociativeArray.prototype, "length", {
    get: function () {
        var count = 0;
        for (var key in this) {
            if (this.hasOwnProperty(key))
                count++;
        }
        return count;
    }
});

现在您可以按如下方式使用此代码...

var a1 = new AssociativeArray();
a1["prop1"] = "test";
a1["prop2"] = 1234;
a1["prop3"] = "something else";
alert("Length of array is " + a1.length);

Answer 13

使用：

var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
obj = Object.keys(myArray).length;
console.log(obj)

Answer 14

@palmsey：公平地说，JavaScript 文档实际上明确地将这种方式使用 Object 类型的变量称为“关联数组”。

公平地说，@palmsey 他是非常正确的，它们不是关联数组，它们绝对是对象:) - 执行关联数组的工作。但就更广泛的观点而言，根据我发现的这篇相当不错的文章，您似乎绝对有权利这样做：

JavaScript“关联数组”被认为是有害的

但根据这一切，是不是 接受的答案 本身就是不好的做法？

为 Object 指定原型 size() 函数

如果向 Object .prototype 添加了其他任何内容，则建议的代码将失败：

<script type="text/javascript">
Object.prototype.size = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
Object.prototype.size2 = function () {
  var len = this.length ? --this.length : -1;
    for (var k in this)
      len++;
  return len;
}
var myArray = new Object();
myArray["firstname"] = "Gareth";
myArray["lastname"] = "Simpson";
myArray["age"] = 21;
alert("age is " + myArray["age"]);
alert("length is " + myArray.size());
</script>

我认为这个答案不应该被接受，因为如果您在同一执行上下文中运行任何其他代码，则不能相信它可以工作。为了以稳健的方式做到这一点，您肯定需要在 myArray 中定义 size 方法，并在迭代成员时检查成员的类型。

Answer 15

像这样的事情怎么样——

function keyValuePairs() {
    this.length = 0;
    function add(key, value) { this[key] = value; this.length++; }
    function remove(key) { if (this.hasOwnProperty(key)) { delete this[key]; this.length--; }}
}

Answer 16

如果我们有哈希值

哈希= {“a”：“b”、“c”：“d”}；

我们可以使用键的长度（即哈希的长度）来获取长度：

键（散列）.length

Answer 17

如果您正在使用 AngularJS 在 1.x 中，您可以通过创建过滤器并使用任何其他示例中的代码以 AngularJS 方式执行操作，如下所示：

// Count the elements in an object
app.filter('lengthOfObject', function() {
  return function( obj ) {
    var size = 0, key;
    for (key in obj) {
      if (obj.hasOwnProperty(key)) size++;
    }
   return size;
 }
})

用法

在你的控制器中：

$scope.filterResult = $filter('lengthOfObject')($scope.object)

或者在你看来：

<any ng-expression="object | lengthOfObject"></any>

Answer 18

<script>
myObj = {"key1" : "Hello", "key2" : "Goodbye"};
var size = Object.keys(myObj).length;
console.log(size);
</script>

<p id="myObj">The number of <b>keys</b> in <b>myObj</b> are: <script>document.write(size)</script></p>

这对我有用：

var size = Object.keys(myObj).length;

Answer 19

如果您需要公开其大小的关联数据结构，最好使用映射而不是对象。

var myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3

Answer 20

上述一些内容的变体是：

var objLength = function(obj){    
    var key,len=0;
    for(key in obj){
        len += Number( obj.hasOwnProperty(key) );
    }
    return len;
};

这是集成 hasOwnProp 的一种更优雅的方式。

Answer 21

如果您不关心支持 Internet Explorer 8 或更低版本，则可以通过应用以下两个步骤轻松获取对象中的属性数量：

1. 运行任一 Object.keys() 获取一个仅包含那些属性名称的数组 可枚举的 或者 Object.getOwnPropertyNames() 如果您还想包含不可枚举的属性名称。
2. 获取 .length 该数组的属性。

---

如果您需要多次执行此操作，可以将此逻辑包装在一个函数中：

function size(obj, enumerablesOnly) {
    return enumerablesOnly === false ?
        Object.getOwnPropertyNames(obj).length :
        Object.keys(obj).length;
}

如何使用这个特定功能：

var myObj = Object.create({}, {
    getFoo: {},
    setFoo: {}
});
myObj.Foo = 12;

var myArr = [1,2,5,4,8,15];

console.log(size(myObj));        // Output : 1
console.log(size(myObj, true));  // Output : 1
console.log(size(myObj, false)); // Output : 3
console.log(size(myArr));        // Output : 6
console.log(size(myArr, true));  // Output : 6
console.log(size(myArr, false)); // Output : 7

也可以看看 这个小提琴 进行演示。

Answer 22

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;

1. Object.values(myObject).length
2. Object.entries(myObject).length
3. Object.keys(myObject).length

Answer 23

这是詹姆斯·科根答案的不同版本。无需传递参数，只需创建 Object 类的原型并使代码更简洁。

Object.prototype.size = function () {
    var size = 0,
        key;
    for (key in this) {
        if (this.hasOwnProperty(key)) size++;
    }
    return size;
};

var x = {
    one: 1,
    two: 2,
    three: 3
};

x.size() === 3;

jsfiddle 示例： http://jsfiddle.net/qar4j/1/

Answer 24

你可以简单地使用 Object.keys(obj).length 在任何物体上获取其长度。Object.keys 返回一个包含所有对象的数组 键 （属性）可以方便地使用相应数组的长度查找该对象的长度。你甚至可以写一个 功能 为了这。让我们得到 有创造力的 并写一个 方法 对于它也是如此（以及更方便的 getter 属性）：

function objLength(obj)
{
  return Object.keys(obj).length;
}

console.log(objLength({a:1, b:"summit", c:"nonsense"}));

// Works perfectly fine
var obj = new Object();
obj['fish'] = 30;
obj['nullified content'] = null;
console.log(objLength(obj));

// It also works your way, which is creating it using the Object constructor
Object.prototype.getLength = function() {
   return Object.keys(this).length;
}
console.log(obj.getLength());

// You can also write it as a method, which is more efficient as done so above

Object.defineProperty(Object.prototype, "length", {get:function(){
    return Object.keys(this).length;
}});
console.log(obj.length);

// probably the most effictive approach is done so and demonstrated above which sets a getter property called "length" for objects which returns the equivalent value of getLength(this) or this.getLength()

Answer 25

最简单的方法是这样的

Object.keys(myobject).length

其中 myobject 是您想要长度的对象

Answer 26

你总是可以做 Object.getOwnPropertyNames(myObject).length 得到相同的结果 [].length 会给出普通数组。

Answer 27

下面是 James Coglan 在 CoffeeScript 中为那些已经放弃直接使用 JavaScript 的人提供的答案:)

Object.size = (obj) ->
  size = 0
  size++ for own key of obj
  size

Answer 28

财产

Object.defineProperty(Object.prototype, 'length', {
    get: function () {
        var size = 0, key;
        for (key in this)
            if (this.hasOwnProperty(key))
                size++;
        return size;
    }
});

使用

var o = {a: 1, b: 2, c: 3};
alert(o.length); // <-- 3
o['foo'] = 123;
alert(o.length); // <-- 4

Answer 29

我们可以使用以下方法找到对象的长度：

Object.values(myObject).length

Answer 30

虽然有点晚了，但实现这一点的一个好方法（仅限 IE9+）是在 length 属性上定义一个神奇的 getter：

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

你可以像这样使用它：

var myObj = { 'key': 'value' };
myObj.length;

会给 1.