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

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

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

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

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

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

@palmsey: In fairness to the OP, the JavaScript documentation actually explicitly refer to using variables of type Object in this manner as "associative arrays".

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

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

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

Specify a prototype size() function for 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>

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

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

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 обычно безопасно.

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

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

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

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

В язык был добавлен тип символа для создания уникальных идентификаторов свойств объекта. Основное преимущество типа символа - предотвращение перезаписи.

Object.keys или Object.getOwnPropertyNames не работают для символьных свойств. Для их возврата нужно использовать Object.getOwnPropertySymbols.

var person = {
  [Symbol('name')]: 'John Doe',
  [Symbol('age')]: 33,
  "occupation": "Programmer"
};

const propOwn = Object.getOwnPropertyNames(person);
console.info(propOwn.length); // 1

let propSymb = Object.getOwnPropertySymbols(person);
console.info(propSymb.length); // 2

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

Object.keys(myArray).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

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

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

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

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

Обновлено: Если вы используете 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;
};

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

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

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

Вот совершенно другое решение, которое будет работать только в более современных браузерах (Internet Explorer 9+, 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);

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

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

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

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

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

keys(hash).length

Как и у большинства проблем с JavaScript, существует множество решений. Вы можете расширить Объект, который лучше или хуже работает, как Словарь многих других языков (+ граждане первого класса). В этом нет ничего плохого, но другой вариант - создать новый объект, отвечающий вашим конкретным потребностям.

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

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

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

Свойство

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

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

  var myObject = {};      // ... your object goes here.

  var length = 0;

  for (var property in myObject) {
    if (myObject.hasOwnProperty(property)){
      length += 1;
    }
  };

  console.info(length);    // logs 0 in my example.

Если вы используете 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>

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

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

1. Запустите либо Object.keys(), чтобы получить массив, содержащий имена только тех свойств, которые являются перечислимый или Object.getOwnPropertyNames(), если вы хотите также включить имена свойств, которые не являются перечислимыми.
2. Получите свойство .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.info(size(myObj));        // Output : 1
console.info(size(myObj, true));  // Output : 1
console.info(size(myObj, false)); // Output : 3
console.info(size(myArr));        // Output : 6
console.info(size(myArr, true));  // Output : 6
console.info(size(myArr, false)); // Output : 7

См. Также эта рабочий пример для демонстрации.

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

const myMap = new Map();

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

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

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

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

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

Код

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

function objLength(obj)
{
  return Object.keys(obj).length;
}

console.info(objLength({a:1, b:"summit", c:"nonsense"}));

// Works perfectly fine
var obj = new Object();
obj['fish'] = 30;
obj['nullified content'] = null;
console.info(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.info(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.info(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()

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

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

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

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

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

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

Это дало бы 1.

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

Object.keys(myObject).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

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

Object.keys(myobject).length

Где myobject - это объект, длину которого вы хотите.

<script>
myObj = {"key1" : "Hello", "key2" : "Goodbye"};
var size = Object.keys(myObj).length;
console.info(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 возвращает нет правильный результат в случае объекта наследование. Для правильного подсчета свойств объекта, в том числе унаследованных, используйте 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.info("Object.keys(myObject):", Object.keys(myObject).length, "(OK)");
console.info("Object.keys(child)   :", Object.keys(child).length, "(wrong)");
console.info("objLength(child)     :", objLength(child), "(OK)");

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

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

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

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

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

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

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

// o/p 3

С помощью встроенного объекта Reflect в ECMAScript 6 вы можете легко подсчитать свойства объекта:

Reflect.ownKeys(targetObject).length

Это даст вам длину собственных свойств целевого объекта (важный).

Reflect.ownKeys(target)

Returns an array of the target object's own (not inherited) property keys.

Что это значит? Чтобы объяснить это, давайте посмотрим на этот пример.

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.info(Reflect.ownKeys(student).length) // 2
console.info(student.getIntro()) // Anuj is 11 years old!!

Здесь вы можете видеть, что он вернул только свои собственные свойства, в то время как объект все еще наследует свойство от своего родителя.

Для получения дополнительной информации обратитесь к этому: Reflect API

Простой однострочник:

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