Độ dài của một đối tượng JavaScript

Tôi có một đối tượng JavaScript, có cách thực hành tốt nhất được tích hợp hoặc chấp nhận để có được độ dài của đối tượng này không?

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

Câu trả lời mạnh mẽ nhất (nghĩa là nắm bắt được ý định của những gì bạn đang cố gắng thực hiện trong khi gây ra ít lỗi nhất) sẽ là:

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

Có một loại quy ước trong JavaScript mà bạn không thêm các thứ vào Object.prototype , vì nó có thể phá vỡ các liệt kê trong các thư viện khác nhau. Thêm các phương thức vào Object thường là an toàn.

Đây là bản cập nhật vào năm 2016 và triển khai rộng rãi ES5 và hơn thế nữa. Đối với IE9 + và tất cả các trình duyệt có khả năng ES5 + hiện đại khác, bạn có thể sử dụng Object.keys()để đoạn mã trên trở thành:

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

Điều này không phải sửa đổi bất kỳ nguyên mẫu hiện có kể từ khi Object.keys()được xây dựng.

Chỉnh sửa : Các đối tượng có thể có các thuộc tính tượng trưng không thể được trả về thông qua phương thức Object.key. Vì vậy, câu trả lời sẽ không đầy đủ mà không đề cập đến chúng.

Loại biểu tượng đã được thêm vào ngôn ngữ để tạo định danh duy nhất cho các thuộc tính đối tượng. Lợi ích chính của loại Biểu tượng là ngăn ngừa ghi đè.

Object.keyshoặc Object.getOwnPropertyNameskhông làm việc cho các thuộc tính tượng trưng. Để trả lại chúng, bạn cần sử dụng 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

Nếu bạn biết bạn không phải lo lắng về hasOwnPropertyséc, bạn có thể thực hiện việc này rất đơn giản:

Object.keys(myArray).length

Đã cập nhật : Nếu bạn đang sử dụng Underscore.js (được khuyến nghị, nó rất nhẹ!), Thì bạn có thể làm

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

Nếu không , và bạn không muốn gây rối với các thuộc tính Object vì bất kỳ lý do gì và đã sử dụng jQuery, một plugin có thể truy cập như nhau:

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

Đây là giải pháp đa trình duyệt nhất.

Điều này tốt hơn câu trả lời được chấp nhận vì nó sử dụng Object.keys gốc nếu tồn tại. Vì vậy, nó là nhanh nhất cho tất cả các trình duyệt hiện đại.

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;

Tôi không phải là chuyên gia về JavaScript, nhưng có vẻ như bạn sẽ phải lặp qua các phần tử và đếm chúng vì Object không có phương thức độ dài:

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

@palmsey: Để công bằng cho OP, tài liệu JavaScript thực sự đề cập rõ ràng đến việc sử dụng các biến loại Object theo cách này như là "mảng kết hợp".

Phương thức này lấy tất cả các tên thuộc tính của đối tượng của bạn trong một mảng, do đó bạn có thể nhận được độ dài của mảng đó bằng với độ dài của khóa đối tượng của bạn.

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

Để không gây rối với nguyên mẫu hoặc mã khác, bạn có thể xây dựng và mở rộng đối tượng của riêng mình:

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

Nếu bạn luôn sử dụng phương thức add, thuộc tính length sẽ đúng. Nếu bạn lo lắng rằng bạn hoặc người khác quên sử dụng nó, bạn cũng có thể thêm bộ đếm tài sản mà những người khác đã đăng vào phương thức độ dài.

Tất nhiên, bạn luôn có thể ghi đè lên các phương thức. Nhưng ngay cả khi bạn làm như vậy, mã của bạn có thể sẽ thất bại đáng chú ý, làm cho nó dễ dàng gỡ lỗi. ;)

Đây là cách và đừng quên kiểm tra rằng tài sản không nằm trong chuỗi nguyên mẫu:

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

Chỉ cần sử dụng điều này để có được length:

Object.keys(myObject).length

Đây là một giải pháp hoàn toàn khác sẽ chỉ hoạt động trong các trình duyệt hiện đại hơn (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Xem jsFiddle

Thiết lập lớp Associative Array của bạn

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

Bây giờ bạn có thể sử dụng mã này như sau ...

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

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

Điều này làm việc cho tôi:

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

Đối với một số trường hợp, tốt hơn là chỉ lưu trữ kích thước trong một biến riêng biệt. Đặc biệt, nếu bạn thêm vào mảng bởi một yếu tố ở một nơi và có thể dễ dàng tăng kích thước. Nó rõ ràng sẽ hoạt động nhanh hơn nhiều nếu bạn cần kiểm tra kích thước thường xuyên.

Sử dụng:

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

@palmsey: Để công bằng cho OP, các tài liệu javascript thực sự đề cập đến việc sử dụng các biến của loại Object theo cách này là "mảng kết hợp".

Và công bằng với @palmsey, anh ta hoàn toàn chính xác, họ không phải là mảng liên kết, họ chắc chắn là đối tượng :) - thực hiện công việc của một mảng kết hợp. Nhưng liên quan đến điểm rộng hơn, bạn chắc chắn có quyền của nó theo bài viết khá hay này tôi tìm thấy:

JavaScript liên kết các mảng được coi là có hại

Nhưng theo tất cả những điều này, không phải là câu trả lời được chấp nhận thực tế xấu?

Chỉ định hàm kích thước nguyên mẫu () cho Object

Nếu bất cứ điều gì khác đã được thêm vào Object .prototype, thì mã được đề xuất sẽ thất bại:

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

Tôi không nghĩ câu trả lời đó phải là câu được chấp nhận vì nó không đáng tin cậy để hoạt động nếu bạn có bất kỳ mã nào khác đang chạy trong cùng bối cảnh thực thi. Để làm điều đó một cách mạnh mẽ, chắc chắn bạn sẽ cần xác định phương thức kích thước trong myArray và kiểm tra loại thành viên khi bạn lặp qua chúng.

Nếu bạn cần một cấu trúc dữ liệu liên kết để lộ kích thước của nó, tốt hơn nên sử dụng bản đồ thay vì một đối tượng.

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

Những gì như thế này -

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

Nếu chúng ta có hàm băm

hàm băm = {"a": "b", "c": "d"};

chúng ta có thể lấy chiều dài bằng cách sử dụng độ dài của các phím là độ dài của hàm băm:

khóa (băm) .length

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

Nếu bạn đang sử dụng AngularJS 1.x, bạn có thể thực hiện mọi thứ theo cách AngularJS bằng cách tạo bộ lọc và sử dụng mã từ bất kỳ ví dụ nào khác, chẳng hạn như sau:

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

Sử dụng

Trong bộ điều khiển của bạn:

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

Hoặc theo quan điểm của bạn:

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

Cách đơn giản nhất là như thế này

Object.keys(myobject).length

trong đó myobject là đối tượng của những gì bạn muốn chiều dài

Nếu bạn không quan tâm đến việc hỗ trợ Internet Explorer 8 hoặc thấp hơn, bạn có thể dễ dàng lấy số lượng thuộc tính trong một đối tượng bằng cách áp dụng hai bước sau:

1. Chạy hoặc Object.keys()để có được một mảng chứa tên của chỉ những thuộc tính đó là đếm được hoặc Object.getOwnPropertyNames()nếu bạn muốn cũng bao gồm tên của tính năng mà không đếm được.
2. Lấy thuộc .lengthtính của mảng đó.

Nếu bạn cần làm điều này nhiều lần, bạn có thể gói logic này trong một hàm:

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

Cách sử dụng chức năng đặc biệt này:

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

Xem thêm Fiddle này cho một bản demo.

Sử dụng Object.keys(myObject).lengthđể có được chiều dài của đối tượng / mảng

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

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

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

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

// o/p 3

Một biến thể của một số ở trên là:

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

Đó là một cách thanh lịch hơn một chút để tích hợp hasOwnProp.

Đây là một phiên bản khác nhau của câu trả lời của James Cogan. Thay vì chuyển một đối số, chỉ cần tạo nguyên mẫu cho lớp Object và làm cho mã sạch hơn.

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;

ví dụ jsfiddle: http://jsfiddle.net/qar4j/1/

Bạn chỉ có thể sử dụng Object.keys(obj).lengthtrên bất kỳ đối tượng để có được chiều dài của nó. Object.keys trả về một mảng chứa tất cả các khóa đối tượng (thuộc tính) có thể có ích để tìm độ dài của đối tượng đó bằng cách sử dụng độ dài của mảng tương ứng. Bạn thậm chí có thể viết một chức năng cho việc này. Chúng ta hãy sáng tạo và viết một phương thức cho nó (cùng với một thuộc tính getter tiện lợi hơn):

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

Bạn luôn có thể làm Object.getOwnPropertyNames(myObject).lengthđể có được kết quả tương tự như [].lengthsẽ cung cấp cho mảng bình thường.

Chúng ta có thể tìm thấy độ dài của Object bằng cách sử dụng:

Object.values(myObject).length

Một trò chơi hơi muộn, nhưng một cách hay để đạt được điều này (chỉ IE9 +) là xác định một getter ma thuật trên thuộc tính độ dài:

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

Và bạn chỉ có thể sử dụng nó như vậy:

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

Sẽ cho 1.

Dưới đây là phiên bản câu trả lời của James Coglan trong CoffeeScript cho những người đã từ bỏ JavaScript thẳng :)

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