一个长度 JavaScript object

Question

我有一个 JavaScript object。是否有内置或公认的最佳实践方法来获取此 object 的长度？

const 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 const myObj = {} var size = Object.size(myObj);

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

---

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

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

这不需要修改任何现有的原型，因为Object.keys()现在是内置的。

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

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

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()方法：

Object.keys(myArray).length

Answer 3

更新：如果你使用Underscore.js （推荐，它是轻量级的！），那么你可以这样做

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

如果没有，并且您不想出于任何原因弄乱 Object 属性，并且已经在使用 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

只需使用它来获取length ：

Object.keys(myObject).length

Answer 7

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

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

Answer 8

最简单的是

Object.keys(myObject).length

Answer 9

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

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 属性将是正确的。 如果您担心您或其他人忘记使用它，您也可以将其他人发布的属性计数器添加到长度方法中。

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

Answer 10

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

 const myObject = {}; console.log(Object.values(myObject).length);

Answer 11

以下是如何并且不要忘记检查该属性是否不在原型链上：

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

Answer 12

这是一个完全不同的解决方案，仅适用于更现代的浏览器（Internet Explorer 9+、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

使用Object.keys(myObject).length获取对象/数组的长度

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

Answer 14

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

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

Answer 15

 <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 16

用：

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

Answer 17

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

Answer 18

@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 19

最简单的方法是这样的：

Object.keys(myobject).length

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

Answer 20

使用Object.entries方法获取长度是实现它的一种方法

 const objectLength = obj => Object.entries(obj).length; const person = { id: 1, name: 'John', age: 30 } const car = { type: 2, color: 'red', } console.log(objectLength(person)); // 3 console.log(objectLength(car)); // 2

Answer 21

如果我们有哈希

hash = {"a": "b", "c": "d"};

我们可以使用密钥的长度（即散列的长度）来获得长度：

键（哈希）。长度

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

这样的事情呢——

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 24

如果您使用的是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 25

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

console.log(Object.keys(myObject).length)

// o/p 3

Answer 26

如果您不关心是否支持 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

另请参阅此 Fiddle以获取演示。

Answer 27

上述一些的变化是：

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

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

Answer 28

这是 James Cogan 答案的不同版本。 而不是传递参数，只需原型出 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 29

您始终可以执行Object.getOwnPropertyNames(myObject).length以获得与[].length为普通数组提供的结果相同的结果。

Answer 30

您可以简单地在任何对象上使用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 31

实现此目的的一个好方法（仅限 Internet Explorer 9+）是在 length 属性上定义一个魔法 getter：

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

你可以像这样使用它：

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

它会给1 。

Answer 32

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

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

Answer 33

属性

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 34

使用 ECMAScript 6 内置的 Reflect 对象，您可以轻松计算对象的属性：

Reflect.ownKeys(targetObject).length

它将为您提供目标对象自身属性的长度（重要）。

Reflect.ownKeys(target)

返回目标对象自己的（非继承的）属性键的数组。

这是什么意思？ 为了解释这一点，让我们看看这个例子。

function Person(name, age){
  this.name = name;
  this.age = age;
}

Person.prototype.getIntro= function() {
  return `${this.name} is ${this.age} years old!!`
}

let student = new Person('Anuj', 11);

console.log(Reflect.ownKeys(student).length) // 2
console.log(student.getIntro()) // Anuj is 11 years old!!

您可以在此处看到，它仅返回自己的属性，而对象仍从其父级继承该属性。

有关更多信息，请参阅： 反射 API

Answer 35

像大多数 JavaScript 问题一样，有很多解决方案。 您可以扩展对象，无论好坏，都可以像许多其他语言的字典（+ 一等公民）一样工作。 没有错，但另一种选择是构建一个满足您特定需求的新对象。

function uberject(obj){
    this._count = 0;
    for(var param in obj){
        this[param] = obj[param];
        this._count++;
    }
}

uberject.prototype.getLength = function(){
    return this._count;
};

var foo = new uberject({bar:123,baz:456});
alert(foo.getLength());

Answer 36

简单的解决方案：

  var myObject = {};      // ... your object goes here.

  var length = 0;

  for (var property in myObject) {
    if (myObject.hasOwnProperty(property)){
      length += 1;
    }
  };

  console.log(length);    // logs 0 in my example.

Answer 37

该解决方案适用于许多情况和跨浏览器：

代码

var getTotal = function(collection) {

    var length = collection['length'];
    var isArrayObject =  typeof length == 'number' && length >= 0 && length <= Math.pow(2,53) - 1; // Number.MAX_SAFE_INTEGER

    if(isArrayObject) {
        return collection['length'];
    }

    i= 0;
    for(var key in collection) {
        if (collection.hasOwnProperty(key)) {
            i++;
        }
    }

    return i;
};

数据示例：

// case 1
var a = new Object();
a["firstname"] = "Gareth";
a["lastname"] = "Simpson";
a["age"] = 21;

//case 2
var b = [1,2,3];

// case 3
var c = {};
c[0] = 1;
c.two = 2;

用法

getLength(a); // 3
getLength(b); // 3
getLength(c); // 2

Answer 38

Object.keys不会在对象的情况下返回正确的结果继承。 要正确计算对象属性，包括继承的属性，请使用for-in 。 例如，通过以下函数（相关问题）：

var objLength = (o,i=0) => { for(p in o) i++; return i }

 var myObject = new Object(); myObject["firstname"] = "Gareth"; myObject["lastname"] = "Simpson"; myObject["age"] = 21; var child = Object.create(myObject); child["sex"] = "male"; var objLength = (o,i=0) => { for(p in o) i++; return i } console.log("Object.keys(myObject):", Object.keys(myObject).length, "(OK)"); console.log("Object.keys(child) :", Object.keys(child).length, "(wrong)"); console.log("objLength(child) :", objLength(child), "(OK)");

Answer 39

简单的一个班轮：

 console.log(Object.values({id:"1",age:23,role_number:90}).length);

Answer 40

尝试： Object.values(theObject).length

 const myObject = new Object(); myObject["firstname"] = "Gareth"; myObject["lastname"] = "Simpson"; myObject["age"] = 21; console.log(Object.values(myObject).length);

Answer 41

 vendor = {1: "", 2: ""}
 const keysArray = Object.keys(vendor)
 const objectLength = keysArray.length
 console.log(objectLength)
 Result 2

Answer 42

在这里你可以给出任何类型的变量数组、对象、字符串

function length2(obj){
    if (typeof obj==='object' && obj!== null){return Object.keys(obj).length;}
    if (Array.isArray){return obj.length;}
    return obj.length;

}

Answer 43

我也有类似的需求来计算通过 websocket 接收的对象所使用的带宽。 对我来说，只需找到 Stringified 对象的长度就足够了。

websocket.on('message', data => {
    dataPerSecond += JSON.stringify(data).length;
}

Answer 44

 var myObject = new Object(); myObject["firstname"] = "Gareth"; myObject["lastname"] = "Simpson"; myObject["age"] = 21; var size = JSON.stringify(myObject).length; document.write(size);

 JSON.stringify(myObject)