Як ефективно підрахувати кількість ключів / властивостей об’єкта в JavaScript?

Який найшвидший спосіб підрахувати кількість ключів / властивостей об’єкта? Чи можна це зробити без ітерації над об’єктом? тобто не роблячи

var count = 0;
for (k in myobj) if (myobj.hasOwnProperty(k)) count++;

(Firefox надав магічну __count__властивість, але це було видалено десь у версії 4.)

Для цього в будь -якому середовищі , сумісному з ES5 , наприклад, Node , Chrome, IE 9+, Firefox 4+ або Safari 5+:

Object.keys(obj).length

• Сумісність браузера
• Документація Object.keys (включає метод, який ви можете додати до браузерів, які не є ES5)

Ви можете використовувати цей код:

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

Потім ви можете використовувати це і в старих браузерах:

var len = Object.keys(obj).length;

Якщо ви використовуєте Underscore.js, ви можете використовувати _.size (спасибі @douwe):
_.size(obj)

Ви також можете використовувати _.keys, які для деяких можуть бути зрозумілішими:
_.keys(obj).length

Я настійно рекомендую підкреслити, його щільну бібліотеку для виконання багатьох основних речей. По можливості вони відповідають ECMA5 та відкладаються до нативного втілення.

Інакше я підтримую відповідь @ Avi. Я відредагував це, щоб додати посилання на документ MDC, який включає метод ключів (), який ви можете додати до браузерів, які не входять до ECMA5.

Стандартна реалізація об'єкта ( ES5.1 Object Internal Properties and Methods ) не вимагає Objectвідстежувати його кількість ключів / властивостей, тому не повинно бути стандартного способу визначення розміру Objectбез чітко або неявно ітерації над його ключами.

Ось ось найчастіше використовувані альтернативи:

1. Object.keys ECMAScript ()

Object.keys(obj).length;Працює шляхом внутрішньої ітерації ключів для обчислення тимчасового масиву та повертає його довжину.

• Плюси - читаний і чистий синтаксис. Ніяка бібліотека чи спеціальний код не потрібен, за винятком shim, якщо нативна підтримка не доступна
• Мінуси - накладні витрати на пам'ять за рахунок створення масиву.

2. Бібліотечні рішення

Багато прикладів, заснованих на бібліотеці в інших місцях цієї теми, є корисними ідіомами в контексті їх бібліотеки. З точки зору продуктивності, однак, нічого виграти в порівнянні з ідеальним кодом без бібліотеки, оскільки всі ці методи бібліотеки насправді інкапсулюють або цикл for-циклу, або ES5 Object.keys(рідний або прошитий).

3. Оптимізація циклу for

Повільна частина такого для циклу , як правило, .hasOwnProperty()виклик, через накладних витрат виклику функції. Отже, коли я просто хочу кількість записів об'єкта JSON, я просто пропускаю .hasOwnProperty()виклик, якщо знаю, що жоден код не зробив і не пошириться Object.prototype.

В іншому випадку ваш код може бути дуже незначно оптимізований, зробивши kлокальний ( var k) та використовуючи оператор з збільшенням префікса ( ++count) замість постфікса.

var count = 0;
for (var k in myobj) if (myobj.hasOwnProperty(k)) ++count;

Інша ідея спирається на кешування hasOwnPropertyметоду:

var hasOwn = Object.prototype.hasOwnProperty;
var count = 0;
for (var k in myobj) if (hasOwn.call(myobj, k)) ++count;

Це швидше чи ні в даному середовищі - це питання бенчмаркінгу. У будь-якому випадку можна очікувати дуже обмеженого підвищення продуктивності.

Якщо ви насправді стикаєтеся з проблемою продуктивності, я б запропонував завершити виклики, які додають / видаляють властивості до / з об'єкта, функцією, яка також збільшує / зменшує властивість, що має належну назву (size?).

Вам потрібно лише один раз обчислити початкову кількість властивостей і рухатися далі. Якщо немає справжньої проблеми з роботою, не турбуйтеся. Просто ввімкніть цей фрагмент коду у функцію getNumberOfProperties(object)і виконайте його.

Як зазначає Avi Flax https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

зробить трюк для всіх перелічених властивостей на вашому об'єкті, але також включить неперелічені властивості, які ви можете замість цього використовувати Object.getOwnPropertyNames. Ось різниця:

var myObject = new Object();

Object.defineProperty(myObject, "nonEnumerableProp", {
  enumerable: false
});
Object.defineProperty(myObject, "enumerableProp", {
  enumerable: true
});

console.log(Object.getOwnPropertyNames(myObject).length); //outputs 2
console.log(Object.keys(myObject).length); //outputs 1

console.log(myObject.hasOwnProperty("nonEnumerableProp")); //outputs true
console.log(myObject.hasOwnProperty("enumerableProp")); //outputs true

console.log("nonEnumerableProp" in myObject); //outputs true
console.log("enumerableProp" in myObject); //outputs true

Як зазначено тут, ця версія веб-переглядача є такою ж, як і у веб-переглядачаObject.keys

Однак у більшості випадків ви, можливо, не захочете включати ненумеровані в цей тип операцій, але завжди добре знати різницю;)

Я не знаю жодного способу зробити це, однак для того, щоб ітерації були мінімальними, ви можете спробувати перевірити наявність, __count__і якщо його не існує (тобто не Firefox), то ви можете переглядати об'єкт і визначати це для подальшого використання, наприклад:

if (myobj.__count__ === undefined) {
  myobj.__count__ = ...
}

Таким чином, будь-який браузер, що підтримує __count__, використовував би це, а ітерації виконувалися б лише для тих, хто цього не робить. Якщо кількість змін змінюється, і ви не можете цього зробити, ви завжди можете зробити це функцією:

if (myobj.__count__ === undefined) {
  myobj.__count__ = function() { return ... }
  myobj.__count__.toString = function() { return this(); }
}

Таким чином, у будь-який час ви посилаєтесь на myobj. __count__функція запустить і перерахує.

Щоб повторити відповідь на Avi Flax Object.keys (obj) .length є правильним для об'єкта, який не має функцій, прив'язаних до нього

приклад:

obj = {"lol": "what", owo: "pfft"};
Object.keys(obj).length; // should be 2

проти

arr = [];
obj = {"lol": "what", owo: "pfft"};
obj.omg = function(){
    _.each(obj, function(a){
        arr.push(a);
    });
};
Object.keys(obj).length; // should be 3 because it looks like this 
/* obj === {"lol": "what", owo: "pfft", omg: function(){_.each(obj, function(a){arr.push(a);});}} */

кроки, щоб цього уникнути:

1. не ставте функції в об’єкт, в якому потрібно підраховувати кількість клавіш

2. використовувати окремий об'єкт або створити новий об’єкт спеціально для функцій (якщо ви хочете порахувати, скільки функцій у файлі є за допомогою Object.keys(obj).length)

також так, у моєму прикладі я використав модуль _ або підкреслення від nodejs

Документацію можна знайти тут http://underscorejs.org/ , а також її джерело на github та іншу іншу інформацію

І нарешті впровадження lodash https://lodash.com/docs#size

_.size(obj)

як відповів вище: Object.keys(obj).length

Але: як у нас зараз справжній клас Map у ES6, я б запропонував використовувати його замість властивостей об'єкта.

const map = new Map();
map.set("key", "value");
map.size; // THE fastest way

Для тих, хто Underscore.js включений у свій проект, ви можете:

_({a:'', b:''}).size() // => 2

або функціональний стиль:

_.size({a:'', b:''}) // => 2

Ось кілька тестів на ефективність трьох методів;

https://jsperf.com/get-the-number-of-keys-in-an-object

Object.keys (). Довжина

20 735 операцій в секунду

Дуже простий і сумісний. Працює швидко, але дорого, тому що створює новий масив ключів, який потім викидається.

return Object.keys(objectToRead).length;

петлю через ключі

15 734 операції в секунду

let size=0;
for(let k in objectToRead) {
  size++
}
return size;

Трохи повільніше, але ніде немає використання пам'яті, тому, напевно, краще, якщо ви зацікавлені в оптимізації для мобільних або інших маленьких машин

Використання карти замість об'єкта

953,839,338 операцій в секунду

return mapToRead.size;

В основному, Карта відстежує свій розмір, тому ми просто повертаємо числове поле. Далеко, набагато швидше, ніж будь-який інший метод. Якщо ви маєте контроль над об'єктом, перетворіть їх на карти.

Від: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty

Object.defineProperty (obj, prop, дескриптор)

Ви можете додати його до всіх своїх об'єктів:

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

Або один об'єкт:

var myObj = {};
Object.defineProperty(myObj, "length", {
    enumerable: false,
    get: function() {
        return Object.keys(this).length;
    }
});

Приклад:

var myObj = {};
myObj.name  = "John Doe";
myObj.email = "leaked@example.com";
myObj.length; //output: 2

Додано таким чином, він не відображатиметься в циклі для ..

for(var i in myObj) {
     console.log(i + ":" + myObj[i]);
}

Вихід:

name:John Doe
email:leaked@example.com

Примітка: вона не працює в <IE9 браузерах.

Як я вирішив цю проблему, це створити власну реалізацію базового списку, який веде облік того, скільки предметів зберігається в об’єкті. Це дуже просто. Щось на зразок цього:

function BasicList()
{
   var items = {};
   this.count = 0;

   this.add = function(index, item)
   {
      items[index] = item;
      this.count++;
   }

   this.remove = function (index)
   {
      delete items[index];
      this.count--;
   }

   this.get = function(index)
   {
      if (undefined === index)
        return items;
      else
        return items[index];
   }
}

Ви можете використовувати Object.keys(data).lengthдовжину об'єкта JSON, що містить ключові дані

Для тих, хто має Ext JS 4 у своєму проекті, ви можете:

Ext.Object.getSize(myobj);

Перевага цього в тому, що він працюватиме на всіх сумісних браузерах Ext (включено IE6-IE8), однак, я вважаю, що час роботи не кращий, ніж O (n), як і в інших пропонованих рішеннях.

Ви можете використовувати:

Object.keys(objectName).length; 

і

Object.values(objectName).length;

OP не вказав, чи об'єкт nodeList, якщо він є, то ви можете просто використовувати метод довжини на ньому безпосередньо. Приклад:

buttons = document.querySelectorAll('[id=button)) {
console.log('Found ' + buttons.length + ' on the screen'); 

Якщо jQuery вище не працює, спробуйте

$(Object.Item).length

Я не думаю, що це можливо (принаймні, не без використання внутрішніх даних). І я не думаю, що ви багато чого заробляте, оптимізуючи це.

Я намагаюся зробити його доступним для всіх таких об’єктів:

Object.defineProperty(Object.prototype, "length", {
get() {
    if (!Object.keys) {
        Object.keys = function (obj) {
            var keys = [],k;
            for (k in obj) {
                if (Object.prototype.hasOwnProperty.call(obj, k)) {
                    keys.push(k);
                }
            }
            return keys;
        };
    }
    return Object.keys(this).length;
},});

console.log({"Name":"Joe","Age":26}.length) //returns 2

Google Closing має гарну функцію для цього ... goog.object.getCount (obj)

дивіться на goog.Object Documentation