Какой самый быстрый способ подсчитать количество ключей/свойств объекта? Это можно сделать без итерации над объектом? т.е. без выполнения
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
Вы можете использовать этот код:
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
Я очень рекомендую Underscore, его плотную библиотеку для выполнения множества основных вещей. Когда это возможно, они соответствуют ECMA5 и относятся к исходной реализации.
В противном случае я поддерживаю ответ @Avi. Я отредактировал его, чтобы добавить ссылку на MDC-документ, который включает в себя метод keys(), который вы можете добавить в браузер, не относящийся к ECMA5.
Стандартная реализация объекта (ES5.1 "Внутренние свойства и методы объекта") не требует от Object отслеживания количества ключей/свойств, поэтому не должно быть стандартного способа определения размера Object без явной или неявной итерации его ключей.,
Итак, вот наиболее часто используемые альтернативы:
Object.keys(obj).length; Работает путем внутренней перебора ключей для вычисления временного массива и возвращает его длину.
Многие основанные на библиотеках примеры в других частях этой темы являются полезными идиомами в контексте их библиотеки. С точки зрения производительности, однако, выиграть нечего по сравнению с идеальным кодом без библиотеки, поскольку все эти библиотечные методы на самом деле инкапсулируют либо for-loop, либо ES5 Object.keys (нативный или shimmed).
Самая медленная часть такого цикла 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) и сделайте с ним.
Я не знаю, как это сделать, но чтобы свести итерации к минимуму, вы можете попробовать проверить существование __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 fooobar.com/questions/10792/...
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
Тем не менее, в большинстве случаев вы можете не захотеть включать nonenumerables в этот тип операций, но всегда полезно знать разницу;)
Итерация ответа 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);});}} */
чтобы избежать этого:
не помещать функции в объект, который вы хотите подсчитать количество клавиш в
используйте отдельный объект или создавайте новый объект специально для функций (если вы хотите подсчитать, сколько функций есть в файле, используя Object.keys(obj).length)
Также да, я использовал модуль _ или подчёркивания из nodejs в моем примере
документацию можно найти здесь http://underscorejs.org/, а также ее источник на github и другую другую информацию
И, наконец, реализация lodash https://lodash.com/docs#size
_.size(obj)
как и было Object.keys(obj).length выше: 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://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty
Object.defineProperty(obj, prop, descriptor)
Вы можете либо добавить его ко всем своим объектам:
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 = "[email protected]";
myObj.length; //output: 2
Добавлено таким образом, оно не будет отображаться в циклах for.in:
for(var i in myObj) {
console.log(i + ":" + myObj[i]);
}
Вывод:
name:John Doe
email:[email protected]
Примечание: он не работает в < 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];
}
}
Для тех, у кого есть Ext JS 4 в своем проекте, вы можете:
Ext.Object.getSize(myobj);
Преимущество этого заключается в том, что он будет работать на всех совместимых с Интернетом браузерах (включая IE6-IE8), однако я считаю, что время работы не лучше, чем O (n), хотя, как и в случае с другими предлагаемыми решениями.
Вы можете использовать Object.keys(data).length чтобы найти длину объекта JSON с ключевыми данными
Если jQuery выше не работает, попробуйте
$(Object.Item).length
OP не указал, является ли объект нодлистом, если это так, то вы можете просто использовать метод длины непосредственно для него. Пример:
buttons = document.querySelectorAll('[id=button)) {
console.log('Found ' + buttons.length + ' on the screen');
Я не думаю, что это возможно (по крайней мере, не без использования некоторых внутренних компонентов). И я не думаю, что вы выиграете, оптимизируя это.
Вы можете использовать:
Object.keys(objectName).length;
и
Object.values(objectName).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
Вот несколько тестов производительности для трех методов;
https://jsperf.com/get-the-number-of-keys-in-an-object
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;
По сути, Map отслеживает свой собственный размер, поэтому мы просто возвращаем числовое поле. Гораздо быстрее, чем любой другой метод. Если у вас есть контроль над объектом, вместо этого конвертируйте их в карты.
У Google Closure есть хорошая функция для этого... goog.object.getCount(obj)
Вы также можете разобрать Json, используя
JSON.parse(array).lenght