javascript对象的长度

Length of a JavaScript object

如果我有一个javascript对象，比如

1
2
3
4

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

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

最有力的答案(即捕捉到您在导致最少错误的同时尝试做的事情的意图)是：

1
2
3
4
5
6
7
8
9
10

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

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

以下是截至2016年的最新消息，以及ES5及以后的广泛部署。对于IE9+和所有其他支持ES5+的现代浏览器，您可以使用Object.keys()，因此上面的代码只是：

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

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

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

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

Object.keys或Object.getOwnPropertyNames不适用于符号属性。要退货，您需要使用Object.getOwnPropertySymbols。

1
2
3
4
5
6
7
8
9
10
11

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

相关讨论

如果你知道你不必担心hasOwnProperty支票，你可以很简单地做到：

1	Object.keys(myArray).length

相关讨论

为什么不？据我所知，它是一个标准：developer.mozilla.org/en/javascript/reference/global_objects&zwnj；&8203；/&hellip；
这不是一个普遍实现的方法，但是您可以通过这个表检查哪个浏览器支持它。
不支持IE8=不通过。
@裂土器234，取决于您的要求。
根据该表，IE8支持"标准"的4/34。真的。
是时候切换到firefox了=不幸的是，你的切换并不意味着你网站的用户会…
@裂土器234无IE支持=PolyFill时间
if (typeof Object.keys != 'function') { Object.keys = function(obj) { var ret = []; for (var x in obj) { if (obj.hasOwnProperty(x)) { ret[ret.length] = x; } } return ret; } }
至少，它在node.js服务器端工作：)谢谢你的回答。
@ripper234：没有ie8，Object.keys or= (obj) -> key for own key of obj(coffeeesccript，您可以轻松复制生成的输出)。
@Ripper234谁关心IE，谁也不应该关心IE不标准，只有标准。用户想使用IE，他们就不会浏览我的网站了，我不再在乎了。开发人员不应多道填充，而应采用IE"开发人员"制定的标准。
创建新数组只是为了计算它的长度？太浪费资源了
规范中说keys()方法只返回对象自身属性的名称，所以使用此方法可以避免进行hasownproperty检查。
@SteelBrain-不要过早优化。如果您需要节省资源，那么我建议您维护一个单独的长度变量(或者使用for循环)，但这可能只有在处理大量散列时才有必要。
@Albanx这种态度不会让你在网络开发中走得更远。网站是为访问者而不是开发者而设计的。
在developer.mozilla.org/en-us/docs/web/javascript/reference/&hellip；为传统IE提供了强大的polyfill。
map创建一个长度相同的数组。你是说filter吗？
即使你担心.hasOwnProperty*()函数，如果你想检查的对象是new Date()，你也不会得到正确的答案。
如果速度对你来说是个问题，那么事实证明Object.values(myObject).length更快。至少在铬v67中。gist.github.com/flekschas/5aad97d1c2520db7af0a9623dec005f
如果重复的钥匙是他们的，我们就不能应用这个。

更新：如果您使用的是underline.js(推荐，它是轻量级的！)那么你就可以

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

如果不是，并且您不想因为任何原因而乱搞对象属性，并且已经在使用jquery，则插件同样可以访问：

1
2
3
4
5
6
7
8

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

相关讨论

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

这比公认的答案更好，因为它使用本机object.keys(如果存在)。因此，它是所有现代浏览器中速度最快的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

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;

相关讨论

我不是javascript专家，但看起来您必须循环遍历元素并计算它们，因为对象没有长度方法：

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

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

相关讨论

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

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

相关讨论

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

如果总是使用add方法，那么length属性将是正确的。如果您担心您或其他人忘记使用它，您可以添加其他人发布到length方法的属性计数器。

当然，您可以覆盖这些方法。但是，即使这样做，代码也可能会明显失败，使调试变得容易。；)

相关讨论

最简单的是

1	Object.keys(myObject).length

相关讨论

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

1
2
3
4

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

这是一个完全不同的解决方案，只能在更现代的浏览器中使用(IE9+、Chrome、Firefox 4+、Opera 11.60+、Safari 5.1+)

参见JSFIDLE

设置关联数组类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

/**
* @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;
}
});

现在您可以使用以下代码…

1
2
3
4
5

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

相关讨论

在某些情况下，最好将大小存储在单独的变量中。特别是，如果你在一个地方用一个元素添加到数组中，并且可以很容易地增加大小。如果你需要经常检查尺寸，它显然会更快地工作。

只需使用这个来获取length：

1	Object.keys(myObject).length

相关讨论

用途：

1
2
3
4
5
6

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

@palmsey: In fairness to the OP, the javascript docs actually explicitly refer to using variables of type Object in this manner as"associative arrays".

< /块引用>
公平地说，@palmsey是非常正确的，它们不是关联数组，它们绝对是对象：)做关联数组的工作。但关于更广泛的观点，根据我发现的这篇相当好的文章，你似乎有权这样做：
javascript"关联数组"被认为是有害的
但根据所有这些，被接受的答案本身不是不好的做法吗？

Specify a prototype size() function for Object

< /块引用>
如果在object.prototype中添加了其他内容，则建议的代码将失败：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
<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());

我认为答案不应该是可接受的，因为如果在同一执行上下文中运行任何其他代码，那么它就不可能工作。要以一种健壮的方式完成这项工作，您当然需要在myarray中定义size方法，并在迭代成员时检查成员的类型。

如果我们有大麻

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

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

keys(hash).length

相关讨论

这是一个很好的答案，但是我找不到任何关于这个键功能的文档。所以我对跨浏览器的支持没有信心。

不幸的是，这并不像我最初想的那么好！事实证明，keys功能只在chrome和firefox web控制台中可用。如果将此代码放入脚本，则它将失败，并出现未捕获的引用错误：未定义键

stackoverflow.com/questions/32372685/&hellip；

这和埃奥斯尼斯的答案有什么不同？

像这样的东西怎么样--

1
2
3
4
5
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--; }}
}

如果您使用的是AngularJS 1.x，那么您可以通过创建一个过滤器并使用其他示例(如以下)中的代码来执行AngularJS方法：

1
2
3
4
5
6
7
8
9
10
// 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;
}
})

用法
在控制器中：

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

或者在你看来：

1
</any>

相关讨论

has not for the作品要在angularjs version。This is not a valid to the回答的问题。

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

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

上面的一些变化是：

1
2
3
4
5
6
7
var objLength = function(obj){
var key,len=0;
for(key in obj){
len += Number( obj.hasOwnProperty(key) );
}
return len;
};

这是一种更优雅的方法来集成hasownprop。

1
2
3
4
5
6
7
myObj = {"key1" :"Hello","key2" :"Goodbye"};
var size = Object.keys(myObj).length;
console.log(size);

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

这对我很有用：

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

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

运行Object.keys()以获取一个数组，该数组只包含那些可枚举的属性的名称；如果您还希望包含那些不可枚举的属性的名称，则运行Object.getOwnPropertyNames()。

获取该数组的.length属性。

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

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

如何使用此特定功能：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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

另请参见此小提琴的演示。

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

对象.值(myObject).length

对象.条目(myObject).length

对象.键(myObject).length

这是詹姆斯·科根答案的另一个版本。不要传递参数，只需将对象类原型化并使代码更清晰。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;

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

相关讨论

Object.prototype—坏主意。

@你能解释一下为什么吗？

这里有一篇文章：bit.ly/1行。我不是说不能做，只是说在做这件事之前你需要知道所有的影响。

您可以简单地在任何对象上使用Object.keys(obj).length来获取其长度。object.keys返回一个包含所有对象键(属性)的数组，使用相应数组的长度可以方便地找到该对象的长度。甚至可以为此编写函数。让我们创造性地为它编写一个方法(以及更方便的getter属性)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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()

相关讨论

how is this different from aeosynth' S答案？

这是因为它让shows how to as a function method(黑莓和全局对象面向对象的形态和uses some of胶囊成囊)；不aeosynth'不管一个人多的答案。

最简单的方法是这样

1
Object.keys(myObject).length

其中myObject是所需长度的对象

相关讨论

this appears to be of this只是重复现有的答案。

它也表示赞同."does not庞，和任何其他提供给进一步的context类的答案。

您可以始终执行Object.getOwnPropertyNames(myObject).length，以获得与正常数组[].length相同的结果。

相关讨论

Object.keys()归来that contains the names of an阵列，只有那些属性是可枚举的。如果你想在西安与阵列属性，你应该使用Object.getOwnPropertyNames()instead。欧洲经济区developer.mozilla.org /恩/文档/ / / /参考JavaScript Web & hellip；

how is this different from aeosynth' S答案？

下面是一个版本的詹姆斯·科格兰(JamesCoglan)在《咖啡描述》(Coffeescript)中对那些放弃了纯javascript的人的回答：)

1
2
3
4
Object.size = (obj) ->
size = 0
size++ for own key of obj
size

相关讨论

你可能想说size++ for own key of obj(own key是咖啡描述中的语法糖)。直接从物体上使用hasOwnProperty是危险的，因为当物体具有这样的性质时，它就会断裂。

该操作没有要求一个咖啡脚本版本，也没有这样的标签。这不是问题的有效答案。

财产

1
2
3
4
5
6
7
8
9
Object.defineProperty(Object.prototype, 'length', {
get: function () {
var size = 0, key;
for (key in this)
if (this.hasOwnProperty(key))
size++;
return size;
}
});

使用

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

我们可以通过以下方法找到物体的长度：

1
Object.values(myObject).length

虽然比游戏晚了一点，但实现这一点的一个好方法(仅限IE9+)是在length属性上定义一个魔力getter：

1
2
3
4
5
Object.defineProperty(Object.prototype,"length", {
get: function () {
return Object.keys(this).length;
}
});

你可以这样使用它：

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

会给1。

相关讨论

not to modify the prototype伟大的想法：)

和大多数javascript问题一样，有很多解决方案。您可以扩展对象，使其更好或更差地工作，就像许多其他语言的字典(+一流公民)。这没什么错，但另一个选择是构造一个满足您特定需求的新对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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());

相关讨论

不要修改原型：)

修饰the prototype of a function is the Way You extend工厂他们。

简单解决方案：

1
2
3
4
5
6
7
8
9
10
11
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.

对象继承时，Object.keys不返回权利结果。要正确计算对象属性，包括继承的属性，请使用for-in，例如通过以下函数(相关问题)

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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)");

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
};

数据实例：

1
2
3
4
5
6
7
8
9
10
11
12
13
// 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;

用法

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

在我看来，最好的答案是，if (obj.hasOwnProperty(key))控制是多余的。它总是返回true。

1
2
3
4
5
6
7
Object.size = function(obj) {
var size = 0, key;
for (key in obj) {
size++;
}
return size;
};

相关讨论

misleading this is incorrect布尔。如果你不明白为什么队列is written is like EN，EN不要变化。外观检查方法，而不是试图了解什么他们做和茶。hasOwnPropertyis the reason is used to the keys on its prototype防止计数。实例：parent = {a: 1, b:2}; child = Object.create(parent); Object.keys(child) === 0; Object.size(child) === 2;。using this is not the correct your Object.size，酮。

1
2
3
4
5
6
7
8
var myObject = new Object();
myObject["firstname"] ="Gareth";
myObject["lastname"] ="Simpson";
myObject["age"] = 21;

var size = JSON.stringify(myObject).length;

document.write(size);

1
JSON.stringify(myObject)

相关讨论

在the number of the question的时间分辨特性。你的答案是"shows the length of one(out of many！)是序列化形式。