JavaScript对象的长度

时间：2008-08-07 19:42:21

标签： javascript javascript-objects

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

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

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

43 个答案:

答案 0 :(得分：2299)

最强大的答案（即捕获您尝试做的事情的意图，同时导致最少的错误）将是：

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 don't add things to Object.prototype中有一种约定，因为它可以破坏各种库中的枚举。但是，向Object添加方法通常是安全的。

以下是2016年及widespread deployment of 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

答案 1 :(得分：1550)

如果您知道自己不必担心hasOwnProperty支票，可以非常简单地执行此操作：

Object.keys(myArray).length

答案 2 :(得分：268)

已更新：如果您正在使用Underscore.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;
};

答案 3 :(得分：50)

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

这比接受的答案更好，因为它使用本机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;

答案 4 :(得分：33)

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

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

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

答案 5 :(得分：29)

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

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

答案 6 :(得分：24)

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

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

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

答案 7 :(得分：21)

最简单的是

length

答案 8 :(得分：18)

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

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

答案 9 :(得分：16)

只需使用它即可获得length：

Object.keys(myObject).length

答案 10 :(得分：15)

这是一个完全不同的解决方案，只适用于更现代的浏览器（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);

答案 11 :(得分：15)

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

答案 12 :(得分：14)

使用：

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

答案 13 :(得分：13)

  
    

@palmsey：为了公平对待OP，javascript文档实际上明确地将使用Object类型的变量称为“关联数组”。

  

对@palmsey来说，他是非常正确的，他们不是关联数组，他们肯定是对象:) - 做一个关联数组的工作。但是关于更广泛的观点，根据我发现的这篇相当精彩的文章，你肯定似乎拥有它的权利：

JavaScript “Associative Arrays” Considered Harmful

但根据这一切，accepted answer本身不是不好的做法吗？

  
    

为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方法，并在迭代它们时检查成员的类型。

答案 14 :(得分：11)

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

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

// o/p 3

答案 15 :(得分：11)

这样的事情怎么样 - 

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

答案 16 :(得分：11)

如果我们有哈希

  

hash = {“a”：“b”，“c”：“d”};

我们可以使用键的长度来获取长度，这是哈希的长度：

  

键（散列）。长度

答案 17 :(得分：10)

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

bList.SelectMany(x => x.CCollection).ToList().Select(c => new ChartDetailitem
{
  // other properties...
  TextColor = SetColor(c.DataColor)
})

<强>用法

在您的控制器中：

// 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)

答案 18 :(得分：9)

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

答案 19 :(得分：9)

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

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

答案 20 :(得分：7)

var myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;
  1. Object.values（myObject的）。长度
  2. Object.entries（myObject的）。长度
  3. Object.keys（myObject的）。长度

答案 21 :(得分：7)

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

  1. 如果您还想包含不可枚举的属性名称，请运行Object.keys()以获取仅包含enumerable或Object.getOwnPropertyNames()属性名称的数组。
  2. 获取该阵列的.length属性。

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

    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

    如何使用此特定功能：

    myApp.controller('myController', ['$scope', '$uibModal', function($scope, $uibModal) {
            $scope.hi = "hello world"; 

            $scope.open = function() {
                var modalInstance = $uibModal.open({
                    template: '<h1>Hello world</h1>',
                });
            }
        }]);

    另见this Fiddle演示。

答案 22 :(得分：7)

上述部分内容的变体是：

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

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

答案 23 :(得分：6)

这是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/

答案 24 :(得分：5)

您可以在任何对象上使用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()

答案 25 :(得分：5)

最简单的方法就是这样

Object.keys(myobject).length

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

答案 26 :(得分：4)

您始终可以Object.getOwnPropertyNames(myObject).length获得与[].length相同的结果。

答案 27 :(得分：4)

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

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

console.log(Object.keys(myObject).length); //3

答案 28 :(得分：3)

我们可以使用：

找到Object的长度 
Object.values(myObject).length

答案 29 :(得分：3)

游戏有点晚了，但实现这个目标的好方法（仅限IE9 +）是在长度属性上定义一个魔术吸气剂：

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

你可以像这样使用它：

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

会给1。

答案 30 :(得分：3)

属性

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

答案 31 :(得分：3)

以下是James Coglan在CoffeeScript中为那些放弃直接JavaScript的人提供的答案：）

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

答案 32 :(得分：2)

一个简单的班轮：

Object.values({id:"1",age:23,role_number:90}).length   // length : 3

答案 33 :(得分：2)

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

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

答案 34 :(得分：2)

使用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!!

您可以在这里看到，当对象仍从其父项继承该属性时，它仅返回其自身的属性。

有关更多信息，请参见：Reflect API

答案 35 :(得分：1)

简单解决方案： 

  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.

答案 36 :(得分：0)

如果对象为inheritance，则Object.keys 否返回正确的结果。要正确计算对象属性（包括继承的属性），请使用for-in，例如通过以下功能（相关question）

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)");

答案 37 :(得分：0)

let myobject= {}
let isempty =  Object.values(myobject);
console.log(isempty)

答案 38 :(得分：0)

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

<强>代码 

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

答案 39 :(得分：-1)

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

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

答案 40 :(得分：-1)

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

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

答案 41 :(得分：-1)

试试：Object.values(theObject).length

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

答案 42 :(得分：-3)

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)

相关问题
最新问题