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

голоса
1k

Если у меня есть объект JavaScript, скажем,

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

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

Задан 07/08/2008 в 20:42
источник пользователем
На других языках...                            


36 ответов

голоса
1k

Самый надежный ответ (т.е. фиксирует намерение, что вы пытаетесь сделать, в то время как вызывает наименьшее количество ошибок) будет:

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

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


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

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

Это не должны изменять любой существующий прототип поскольку Object.keys()теперь встроен в систему .

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

тип символ был добавлен к языку для создания уникальных идентификаторов для свойств объекта. Основное преимущество типа 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
Ответил 09/08/2008 в 09:31
источник пользователем

голоса
1k

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

Object.keys(myArray).length
Ответил 03/04/2011 в 02:44
источник пользователем

голоса
249

Обновление : Если вы используете 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;
};
Ответил 05/07/2012 в 15:39
источник пользователем

голоса
148

Используйте что-то же просто, как:

Object.keys(obj).length

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

Ответил 27/10/2014 в 03:46
источник пользователем

голоса
42

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

Это лучше, чем принято отвечать, поскольку она использует собственные 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;
Ответил 01/09/2013 в 17:12
источник пользователем

голоса
26

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

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

@palmsey: В справедливости по отношению к ОП, документация JavaScript на самом деле явно относятся к использованию переменных типа Object таким образом, как «ассоциативные массивы».

Ответил 07/08/2008 в 20:52
источник пользователем

голоса
25

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

Object.getOwnPropertyNames({"hi":"Hi","msg":"Message"}).length; // => 2
Ответил 01/07/2014 в 13:40
источник пользователем

голоса
19

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

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

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

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

Ответил 11/06/2011 в 16:44
источник пользователем

голоса
14

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

var element_count = 0;
for(var e in myArray)
    if(myArray.hasOwnProperty(e))
        element_count++;
Ответил 08/08/2008 в 20:18
источник пользователем

голоса
13

Вот это совершенно другое решение, которое будет работать только в более современных браузеров (IE9 +, 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);
Ответил 02/08/2013 в 09:49
источник пользователем

голоса
12

Использование:

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

Ответил 31/05/2016 в 04:49
источник пользователем

голоса
12

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

Ответил 29/07/2011 в 14:41
источник пользователем

голоса
11

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

Object.keys(myObject).length
Ответил 18/01/2018 в 10:29
источник пользователем

голоса
10

@palmsey: В справедливости по отношению к ОР, то JavaScript документы на самом деле явно относятся к использованию переменных типа Object таким образом, как «ассоциативные массивы».

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

JavaScript «Ассоциативные массивы» Продуманные Вредный

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

Указывает функцию размера прототипа () для объекта

Если что-то еще было добавлено в объект .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>

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

Ответил 08/08/2008 в 23:34
источник пользователем

голоса
8

Если вы используете 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>
Ответил 15/09/2015 в 19:15
источник пользователем

голоса
8

Если мы имеем хэш

хэш = { "а": "б", "в": "г"};

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

ключи (хэш) .length

Ответил 09/02/2014 в 07:48
источник пользователем

голоса
8

Что о чем-то вроде этого -

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--; }}
}
Ответил 24/08/2011 в 15:26
источник пользователем

голоса
6

Самый простой из них является Object.keys (MyObject) .length

Ответил 21/06/2018 в 02:25
источник пользователем

голоса
6

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

var myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3
Ответил 18/05/2016 в 18:16
источник пользователем

голоса
5

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

Смотрите также эту скрипку для демонстрации.

Ответил 07/03/2016 в 13:13
источник пользователем

голоса
5

Вариация на некоторые из выше:

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

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

Ответил 18/11/2011 в 19:06
источник пользователем

голоса
4

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

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

Ответил 17/09/2016 в 01:48
источник пользователем

голоса
4

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

Ответил 27/06/2013 в 00:47
источник пользователем

голоса
3

Это работает для меня:

var size = Object.keys(myObj).length;
Ответил 06/06/2018 в 06:51
источник пользователем

голоса
3

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

Ответил 12/01/2016 в 01:37
источник пользователем

голоса
2
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
Ответил 05/04/2018 в 23:45
источник пользователем

голоса
2

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

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

И вы можете просто использовать его следующим образом:

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

Даст 1.

Ответил 04/07/2017 в 15:20
источник пользователем

голоса
2

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

Object.values(myObject).length
Ответил 22/05/2017 в 13:42
источник пользователем

голоса
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
Ответил 06/01/2015 в 19:10
источник пользователем

голоса
2

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

Object.size = (obj) ->
  size = 0
  size++ for own key of obj
  size
Ответил 04/03/2013 в 18:38
источник пользователем

голоса
1

В лучшем случае ответ, на мой взгляд, if (obj.hasOwnProperty(key))контроль является излишним. Она всегда возвращает true.

Object.size = function(obj) {
    var size = 0, key;
    for (key in obj) {
     size++;
   }
   return size;
};
Ответил 28/06/2018 в 16:44
источник пользователем

голоса
1

Как и большинство проблем 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());
Ответил 09/05/2014 в 19:45
источник пользователем

голоса
0

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

Object.keys(myobject).length

где MyObject является объектом того, что вы хотите, длина

Ответил 30/05/2018 в 15:41
источник пользователем

голоса
0

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

var size = JSON.stringify(myObject).length;

document.write(size);

JSON.stringify(myObject)

Ответил 09/04/2018 в 10:24
источник пользователем

голоса
0

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

Код

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
Ответил 07/08/2016 в 16:28
источник пользователем

голоса
0

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

  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.
Ответил 11/04/2015 в 14:33
источник пользователем

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more