Длина объекта JavaScript

У меня есть объект JavaScript. Есть ли встроенный или общепринятый способ получить длину этого объекта?

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

Это отчасти правда, но так много людей привыкли к «ассоциативному массиву» PHP, что они могут предположить, что это означает «упорядоченную ассоциативную карту», хотя объекты JS на самом деле неупорядочены.

В приведенном выше примере myObject.length не определен, по крайней мере в среде браузера. Вот почему он недействителен

Варианты Object.{keys, values, entries}(obj).length были упомянуты в общей сложности 38 раз в 16 ответах плюс в комментариях к этому вопросу, и еще 11 раз в 7 удаленных ответах. Думаю, теперь достаточно.

44 ответа

Обновленный ответ

Вот обновление по состоянию на 2016 год и широкое распространение ES5 и далее. Для IE9+ и всех других современных браузеров, поддерживающих ES5+, вы можете использовать Object.keys() так, что приведенный выше код просто становится:

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

Для этого не нужно изменять какой-либо существующий прототип, поскольку Object.keys() он уже встроен.

Редактировано: Объекты могут иметь символические свойства, которые не могут быть возвращены через метод Object.key. Поэтому ответ был бы неполным без их упоминания.

Тип Symbol был добавлен в язык для создания уникальных идентификаторов для свойств объектов. Главное преимущество типа 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

Предыдущий ответ

Наиболее обоснованный ответ (то есть отражающий цель того, что вы пытаетесь сделать, и при этом вызывающий наименьшее количество ошибок) будет следующим:

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
const myObj = {}
var size = Object.size(myObj);

В JavaScript есть своего рода соглашение, что вы не добавляете вещи в Object.prototype, потому что это может сломать перечисления в различных библиотеках. Добавление методов в Object обычно безопасно, хотя.

Ваш код может быть сломан, если кто-то придет и переопределит свойство «size», не зная, что вы уже объявили его где-то в коде, поэтому всегда стоит проверять, определено ли оно уже.

Вы очень правы. Всегда следует проводить необходимые проверки работоспособности :)

Я оформил этот ответ в виде плагина jQuery, для тех, кто не любит возиться с Object

почему вы объявляете функцию внутри Object класса, а не просто как обычную функцию? т. е. функцию getSize(obj) {...} ?

Думаю, он просто поддерживает правильную структуру. Эта функция возвращает размер объекта, поэтому имеет смысл сделать ее расширением Object. Сохраняйте свой код чистым и поддерживаемым.

Однако этот метод более глючный, особенно когда hasownprop редко очищается при удалении ключей объектов с помощью ключевого слова delete.

Почему все это игнорируют: Object.keys(obj).length

Вероятно, потому что этот метод даже не существовал, когда этот ответ был написан. Даже сегодня его использование, вероятно, потребует полифилла для старых браузеров.

Re Object.keys(obj).length: Это потому, что IE8 не поддерживает этот метод.

IE8, IE9, IE10 — это мертвые браузеры, которые не поддерживаются Microsoft. Пользователи IE8, IE9, IE10 получают уведомление от Microsoft о том, что они используют старый, неподдерживаемый браузер и должны ожидать, что у них ничего не будет работать.

Да, сейчас 2017 год. Никто не должен использовать ничего, кроме Object.keys(myObj).length. Этот ответ был правильным в 2008 году, но не сейчас.

Не уверен, упоминалось ли об этом ранее, потому что, если говорить кратко, расширение встроенных объектов JavaScript не приветствуется.

Ни Object.keys() ни getOwnProperty*() из функций не даст вам правильного ответа, если их параметром будет new Date(), который, конечно же, является объектом (typeof new Date() === 'object').

Я не понимаю, что вы имеете в виду. Object.keys(new Date()).length дает 0, x = new Date(); Object.keys(x).length также дает 0.

Если вы знаете, что вам не придется беспокоиться о hasOwnProperty проверках, вы можете использовать этот Object.keys() метод следующим образом:

Object.keys(myArray).length

почему бы и нет? насколько я знаю, это стандарт: JavaScript - Reference - Global_Objects- Object - keys

Это не универсальный метод, но вы можете проверить, какой браузер его поддерживает, с помощью этой таблицы.

Это зависит от ваших требований.

Согласно этой таблице, IE8 поддерживает 4/34 «стандарта».

пора переходить на Firefox = к сожалению, переход не означает, что пользователи вашего сайта будут...

нет поддержки IE = время для полифилла

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

Нет IE8, Object.keys or= (obj) -> key for own key of obj (CoffeeScript, вы можете легко скопировать сгенерированный вывод).

кого волнует IE, никого не должны волновать нестандарты IE, только стандарты. пользователи хотят использовать IE, тогда они не будут перемещаться по моему сайту. Мне все равно. разработчики не должны использовать полифиллы, а не стандарты, созданные «разработчиками» IE

Создание нового массива только для того, чтобы посчитать его длину? Это перебор ресурсов

В спецификации сказано, что keys() метод возвращает только имена собственных свойств объекта, поэтому использование этого метода позволит избежать проверки hasOwnProperty.

Не оптимизируйте преждевременно. Если вам нужно сэкономить ресурсы, я бы рекомендовал поддерживать отдельную переменную длины (или использовать цикл for), но это, вероятно, необходимо только при работе с огромными хэшами.

Такое отношение не поможет вам продвинуться в веб-разработке. Веб-сайты созданы для посетителей, а не для разработчиков.

Отличный полифил для устаревшего IE: JavaScript - Reference - Global_Objects - Object

map создает массив с той же длиной. Вы имели в виду filter?

Даже если вас интересуют .hasOwnProperty*() функции, вы не получите правильный ответ, если объект, с которым вы хотите свериться, — это new Date().

Если для вас важна скорость, то она оказывается Object.values(myObject).length быстрее. По крайней мере в Chrome v67.

Обновлено: Если вы используете Underscore _ js (рекомендуется, он легкий!), то вы можете просто сделать

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

Если нет, и вы по какой-либо причине не хотите возиться с Object свойствами и уже используете jQuery, плагин также доступен:

$.assocArraySize = function(obj) {
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

_.size() было идеальным решением для моего проекта Meteor, в котором реализована поддержка undercore _ js.

Я использую underscore, и этот пост просто напомнил мне, что я недостаточно его использую в этом проекте. Если вы работаете с объектами, у вас должен быть underscore _ js.

Подчеркивание > (all -['lo-dash'])

underscorejs, вещи, которые должны быть под js :)

Вопрос: Зачем нужен дополнительный оператор if в цикле?

отличать реальные свойства объекта от унаследованных.

Вот наиболее кроссбраузерное решение.

Это лучше, чем принятый ответ, потому что он использует нативный 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;

Object.keys() возвращает массив, содержащий имена только тех свойств, которые являются перечислимыми. Если вам нужен массив со ВСЕМИ свойствами, вы должны использовать Object.getOwnPropertyNames() вместо этого.

Просто используйте это, чтобы получить length:

Object.keys(myObject).length

пожалуйста, объясните, чем ваш ответ отличается от

Хорошо, всегда лучше называть переменные в соответствии с тем, что они на самом деле из себя представляют. Делает ваш код более читабельным для других разработчиков.

До "myArray" -> "myObject" редактирования этот ответ был идентичен ответу, набравшему второе по количеству голосов.

То же, что и в предыдущих ответах.

То же, что и в ответе по ссылке, но без каких-либо пояснений.

Я не эксперт по JavaScript, но похоже, что вам придется перебирать элементы и подсчитывать их, поскольку Object у него нет метода length:

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

Справедливости ради надо сказать, что в документации JavaScript использование переменных типа Object таким образом явно упоминается как «ассоциативные массивы».

Не сработает, поскольку будут учитываться и методы, добавленные через прототип.

Этот метод извлекает все имена свойств вашего объекта в массив, так что вы можете получить длину этого массива, которая равна длине ключей вашего объекта.

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

Метод keys не возвращает свойства из цепочки прототипов. Так зачем здесь нужен hasOwnProperty. Также getOwnProperty вернет скрытые свойства, так как length находится в массиве и т. д.

Чтобы не возиться с прототипом или другим кодом, вы можете создать и расширить свой собственный объект:

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 будет правильным. Если вы беспокоитесь, что вы или другие забудете об его использовании, вы можете добавить счетчик свойств, который другие разместили в методе length.

Конечно, вы всегда можете перезаписать методы. Но даже если вы это сделаете, ваш код, скорее всего, будет заметно глючить, что упростит отладку. ;)

Я думаю, что это лучшее решение, так как оно не требует циклов с 'for', которые могут быть затратными, если массив большой.

Мы можем найти длину Object используя:

const myObject = {};
console.log(Object.values(myObject).length);

Теоретически этот метод будет медленнее, чем метод "keys", если у вас длинные значения, поскольку он напрямую обращается к значениям, а затем подсчитывает их.

Вот как это сделать, и не забудьте проверить, что объект не находится в цепочке прототипов:

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

Вот совершенно другое решение, которое будет работать только в более современных браузерах (Internet Explorer 9+, Chrome, Firefox 4+, Opera 11.60+ и Safari 5.1+).

Настройте класс ассоциативного массива

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

Я думаю, что это небезопасно. Например, он не может иметь элемент с ключом "length", оператор a1["length"] = "Hello world"; не может сохранить запись. Также оператор a1["hasOwnProperty"] = "some prop"; полностью ломает функцию

Я не думаю, что вы хотели бы, чтобы он сохранял значение, если вы использовали свойство length, любой код, который его использовал, должен был бы гарантировать, что он не пытается сохранить против length, но я думаю, это было бы то же самое, если бы это был стандартный массив. Переопределение hasOwnProperty для любого объекта, скорее всего, приведет к нежелательному результату.

Если вам нужна ассоциативная структура данных, которая отображает ее размер, лучше использовать карту вместо объекта.

const myMap = new Map();

myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);

console.log(myMap.size); // 3

Используйте Object.keys(myObject).length для получения длины объекта/массива

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

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

Использовать:

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

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

В некоторых случаях лучше просто хранить размер в отдельной переменной. Особенно, если вы добавляете к массиву один элемент в одном месте и можете легко увеличить размер. Очевидно, что это будет работать намного быстрее, если вам нужно часто проверять размер.

Самый простой способ такой:

Object.keys(myobject).length

Где находится объект myobject, длину которого вы хотите узнать?

Похоже, это просто повторение уже существующего ответа.

согласен, и он не предоставляет никакого дополнительного контекста, как другие ответы.

И справедливости ради, Палмси был совершенно прав. Это не ассоциативные массивы; это определенно объекты :) - выполняющие работу ассоциативного массива. Но что касается более широкого вопроса, вы определенно правы, судя по этой довольно хорошей статье, которую я нашел:

«Ассоциативные массивы» JavaScript считаются вредными

Но, исходя из всего этого, сам принятый ответ является плохой практикой?

Укажите функцию-прототип size() для Object

Если в 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>

Я не думаю, что этот ответ должен быть принят, поскольку нельзя быть уверенным, что он сработает, если у вас есть другой код, работающий в том же контексте выполнения. Чтобы сделать это надежным способом, вам, конечно, нужно определить метод size внутри myArray и проверять тип членов по мере их итерации.

Использование метода Object.entries для получения длины является одним из способов достижения этого.

const objectLength = obj => Object.entries(obj).length;

const person = {
    id: 1,
    name: 'John',
    age: 30
}
  
const car = {
    type: 2,
    color: 'red',
}

console.log(objectLength(person)); // 3
console.log(objectLength(car)); // 2

Если у нас есть хэш

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

мы можем получить длину, используя длину ключей, которая является длиной хеша:

keys(hash).length

Это отличный ответ, однако я не могу найти никакой документации для этой функции клавиш. Поэтому я не могу быть уверен в кроссбраузерной поддержке.

К сожалению, это не такой хороший ответ, как я сначала подумал! Оказывается, функция keys доступна только в веб-консолях Chrome и Firefox. Если вы поместите этот код в скрипт, то он выдаст ошибку Uncaught ReferenceError: keys is not defined

Чем это отличается от ответа aeosynth?

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

Object.values(myObject).length
Object.entries(myObject).length
Object.keys(myObject).length

Какой из трех вышеперечисленных быстрее?

Object.values(myObject).length

как мы можем сказать, что это Object.values(myObject).length быстрее, есть ли какой-нибудь пример?

просто попробуйте это в консоли: var myObject = {}; for (let i=0; i<10000000; i++) myObject[i] = i;

почему Object.values(myObject).length быстрее, а Object.entries(myObject).length не выдает результат даже спустя некоторое время, в чем здесь причина?

Объяснение будет уместным. Вы можете редактировать свой ответ.

А как насчет чего-то вроде этого...

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, создав фильтр и используя код из любого другого примера, например, следующего:

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

Или по вашему мнению:

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

OP не запрашивал версию AngularJS. Это не является допустимым ответом на вопрос.

Вот несколько методов:

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


//first method
console.log(Object.entries(myObject).length); //3

//second method
let len = 0;
for(let i in myObject)len++;
console.log(len); //3

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

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

// o/p 3

Что означает «о/п 3»?

Было бы уместно пояснить этот ответ.

И чем он отличается от предыдущих ответов, например, от ответа Шахеба?

«o/p», вероятно, означает «выход».

o/p означает выход

Вариация некоторых из вышеперечисленных вариантов:

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

Это немного более элегантный способ интеграции hasOwnProp.

Если вас не волнует поддержка Internet Explorer 8 или более ранних версий, вы можете легко получить количество свойств в объекте, выполнив следующие два шага:

Запустите его либо Object.keys() для получения массива, содержащего имена только тех свойств, которые являются перечисляемыми , либо Object.getOwnPropertyNames() если вы хотите также включить имена свойств, которые не являются перечисляемыми.
Получить свойство .length этого массива.

Если вам нужно сделать это более одного раза, вы можете обернуть эту логику в функцию:

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

Как использовать эту конкретную функцию:

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

Вот другая версия ответа Джеймса Когана. Вместо того, чтобы передавать аргумент, просто прототипируйте класс 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;

Object.prototype - плохая идея.

Можете ли вы объяснить, почему?

Я не говорю, что этого делать нельзя, просто нужно знать все последствия, прежде чем это делать.

Если вы собираетесь расширить встроенные прототипы или полифиллить свойство (например, monkey-patch), пожалуйста, делайте это правильно: для прямой совместимости сначала проверьте, существует ли свойство, затем сделайте его неперечисляемым, чтобы собственные ключи сконструированных объектов не загрязнялись. Для методов используйте реальные методы. Мой совет: следуйте этим примерам, которые показывают, как добавить метод, который ведет себя максимально похоже на встроенные методы.

Вы всегда можете сделать так Object.getOwnPropertyNames(myObject).length, чтобы получить тот же результат, что и [].length для обычного массива.

Чем это отличается от ответа aeosynth?

Вы можете просто использовать Object.keys(obj).length на любом объекте, чтобы получить его длину. Object.keys возвращает массив, содержащий все ключи (свойства) объекта, которые могут пригодиться для нахождения длины этого объекта с использованием длины соответствующего массива. Вы даже можете написать функцию для этого. Давайте проявим креативность и напишем метод для него (вместе с более удобным свойством-геттером):

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

Чем это отличается от ответа aeosynth?

Потому что он показывает, как сделать это функцией и глобальным объектным методом (более объектно-ориентированным и использующим некоторую форму инкапсуляции); однако ответ aeosynth этого не делает.

И как написание метода может быть «более эффективным»?

Хороший способ добиться этого (только для Internet Explorer 9+) — определить магический геттер для свойства length:

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

И вы можете просто использовать это вот так:

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

Это дало бы 1.

Оставив в стороне аргументы против модификации прототипов, лично у меня НИКОГДА не возникало ошибок, вызванных ею, и для меня это одна из сильных сторон JavaScript.

Ниже приведена версия ответа Джеймса Коглана на CoffeeScript для тех, кто отказался от чистого JavaScript :)

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

Вы, вероятно, хотели сказать size++ for own key of obj (own key будучи синтаксическим сахаром в CoffeeScript). Использование hasOwnProperty напрямую из объекта опасно, так как оно ломается, когда объект на самом деле имеет такое свойство.

OP не запрашивал версию CoffeeScript, и она не помечена как таковая. Это не является допустимым ответом на вопрос.

Свойство

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

С помощью встроенного в 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

Пытаться: Object.values(theObject).length

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

Как и большинство проблем JavaScript, существует множество решений. Вы можете расширить Object, что работает лучше или хуже, как словарь многих других языков (+ граждане первого класса). В этом нет ничего плохого, но другой вариант — построить new 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());

не изменяйте прототип :)

Изменение прототипа фабричной функции — это способ ее расширения.

Простая однострочная фраза:

console.log(Object.values({id:"1",age:23,role_number:90}).length);

Простое решение:

  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.

Здесь вы можете указать любой тип переменной: массив, объект, строка

function length2(obj){
    if (typeof obj==='object' && obj!== null){return Object.keys(obj).length;}
   //if (Array.isArray){return obj.length;}
    return obj.length;

}

Решение работает во многих случаях и кроссбраузерно:

Код

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

Object.keys не возвращает правильный результат в случае наследования объектов. Для правильного подсчета свойств объектов, включая унаследованные, используйте for-in. Например, с помощью следующей функции (смежный вопрос):

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

 vendor = {1: "", 2: ""}
 const keysArray = Object.keys(vendor)
 const objectLength = keysArray.length
 console.log(objectLength)
 Result 2

Ответ, содержащий только код, не является высококачественным. Хотя этот код может быть полезен, вы можете улучшить его, указав, почему он работает, как он работает, когда его следует использовать и каковы его ограничения. Отредактируйте свой ответ, включив пояснение и ссылку на соответствующую документацию.

У меня была похожая потребность в расчете пропускной способности, используемой объектами, полученными через веб-сокет. Мне было достаточно просто найти длину объекта Stringified.

Это не ответ на вопрос.

Как опубликовать и затем перенаправить на внешний URL из ASP_Net?

Размещение и последующее перенаправление на внешний URL из ASP_Net

Как опубликовать и перенаправить на внешний URL-адрес из ASP_Net? ASP_NET серверные элементы управления возвращают данные на свою собственную страницу. Это делает случаи, когда вы хотите перенаправить пользователя на внешнюю страницу, но по какой-то причине (например, для аутентификации) вам нужно сделать публикацию на этой странице, болезненными. Отлично работает HttpWebRequest , если вы не хотите перенаправлять, и JavaScript тоже хорош в некоторых случаях, но может оказаться сложным, если вам действительно нужен код на стороне сервера для сбора данных для публикации. Так как же вам одновременно разместить сообщение на внешнем URL-адресе и перенаправить пользователя к результату из вашего кода ASP_NET codebehind? Вот как я решил эту проблему сегодня. Я начал с этой статьи на C# Corner, но нашел пример - хотя технически и правильный - немного неполным. Все, что он сказал, было правильно, но мне нужно было зайти на несколько внешних сайтов, чтобы собрать все это воедино…

Подробнее »

Как настроить переключатель CSS

Я работаю над сайтом, который перейдет на новый стиль в установленную дату. Встроенный семантический HTML и CSS сайта, поэтому изменение должно потребовать только изменения ссылки CSS. Я работаю с дизайнером, которому нужно будет увидеть, как он выглядит, а также с клиентом, которому нужно будет просмотреть обновления контента в текущем виде, а также ход разработки нового вида. Я планирую использовать магическое значение строки запроса и/или ссылку javascript в нижнем колонтитуле, которая записывает cookie для выбора новой страницы CSS. Мы работаем в ASP_NET 3.5. Есть какие-нибудь рекомендации? Я должен упомянуть, что мы…

Подробнее »

Объединение списков в столбцы

Я использую ColdFusion для заполнения шаблона, который включает в себя неупорядоченные списки HTML ( <ul> ы). Большинство из них не такие уж длинные, но некоторые имеют смехотворно большую длину и могли бы поместиться в 2-3 колонки Есть ли способ сделать это легко с помощью HTML, ColdFusion или, может быть, JavaScript (я принимаю решения jQuery)? Не стоит использовать слишком сложное тяжеловесное решение, чтобы сэкономить время на прокрутке. Этот плагин jquery вам…

Подробнее »