Jak efektywnie policzyć liczbę kluczy / właściwości obiektu w JavaScript?

Jaki jest najszybszy sposób na policzenie liczby kluczy / właściwości obiektu? Czy można to zrobić bez iteracji nad obiektem? tzn. bez robienia

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

(Firefox zapewnił magiczną __count__właściwość, ale została ona usunięta gdzieś w pobliżu wersji 4.)

Aby to zrobić w dowolnym środowisku zgodnym z ES5 , takim jak Node , Chrome, IE 9+, Firefox 4+ lub Safari 5+:

Object.keys(obj).length

• Kompatybilność z przeglądarkami
• Dokumentacja Object.keys (zawiera metodę, którą można dodać do przeglądarek innych niż ES5)

Możesz użyć tego kodu:

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

Następnie możesz użyć tego również w starszych przeglądarkach:

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

Jeśli używasz Underscore.js , możesz użyć _.size (dzięki @douwe):
_.size(obj)

Alternatywnie możesz również użyć klawiszy _., Które mogą być bardziej zrozumiałe dla niektórych:
_.keys(obj).length

Bardzo polecam Underscore, to ciasna biblioteka do robienia wielu podstawowych rzeczy. Tam, gdzie to możliwe, dopasowują ECMA5 i przechodzą na implementację natywną.

W przeciwnym razie popieram odpowiedź @ Avi. Zredagowałem go, aby dodać link do dokumentu MDC, który zawiera metodę keys (), którą możesz dodać do przeglądarek innych niż ECMA5.

Standardowa implementacja obiektu ( ES5.1 Object Internal Properties and Methods ) nie wymaga Objectśledzenia liczby kluczy / właściwości, dlatego nie powinno być standardowego sposobu określania wielkości Objectbez jawnego lub niejawnego iterowania kluczy.

Oto najczęściej stosowane alternatywy:

1. Object.keys () w ECMAScript

Object.keys(obj).length;Działa poprzez wewnętrzne iterowanie po klawiszach w celu obliczenia tablicy tymczasowej i zwraca jej długość.

• Plusy - czytelna i czysta składnia. Nie wymaga biblioteki ani niestandardowego kodu, z wyjątkiem podkładki, jeśli natywna obsługa jest niedostępna
• Wady - narzut pamięci związany z tworzeniem tablicy.

2. Rozwiązania oparte na bibliotece

Wiele przykładów opartych na bibliotece gdzie indziej w tym temacie to przydatne idiomy w kontekście ich biblioteki. Jednak z punktu widzenia wydajności nie ma nic do zyskania w porównaniu z doskonałym kodem bez biblioteki, ponieważ wszystkie te metody biblioteczne faktycznie otaczają pętlę for lub ES5 Object.keys(natywną lub shimmed ).

3. Optymalizacja pętli for

Najwolniej część takiej dla pętli jest na ogół .hasOwnProperty()wywołania z powodu obciążania wywołaniu funkcji. Kiedy więc chcę tylko liczby wpisów obiektu JSON, po prostu pomijam .hasOwnProperty()wywołanie, jeśli wiem, że żaden kod nie był ani nie będzie rozszerzany Object.prototype.

W przeciwnym razie twój kod może być bardzo nieznacznie zoptymalizowany poprzez utworzenie klocal ( var k) i użycie operatora increment-increment ( ++count) zamiast postfix.

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

Kolejny pomysł polega na buforowaniu hasOwnPropertymetody:

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

To, czy jest to szybsze, czy nie w danym środowisku, jest kwestią testu porównawczego. W każdym razie można oczekiwać bardzo ograniczonego wzrostu wydajności.

Jeśli faktycznie masz problem z wydajnością, sugerowałbym zawinięcie wywołań dodających / usuwających właściwości do / z obiektu funkcją, która również zwiększa / zmniejsza odpowiednio nazwaną właściwość (rozmiar?).

Wystarczy tylko raz obliczyć początkową liczbę nieruchomości i przejść od tego miejsca. Jeśli nie ma rzeczywistego problemu z wydajnością, nie przejmuj się. Po prostu zawiń ten fragment kodu w funkcji getNumberOfProperties(object)i gotowe.

Jak stwierdził Avi Flax https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

zrobi lewę dla wszystkich wyliczalnych właściwości w twoim obiekcie, ale także włączy właściwości niewymierne, których możesz zamiast tego użyć Object.getOwnPropertyNames. Oto różnica:

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

Jak stwierdzono tutaj, ma to takie samo wsparcie przeglądarki jakObject.keys

Jednak w większości przypadków możesz nie chcieć uwzględniać niezliczonych elementów w tego typu operacjach, ale zawsze dobrze jest znać różnicę;)

Nie znam żadnego sposobu, aby to zrobić, jednak aby zminimalizować liczbę iteracji, możesz spróbować sprawdzić istnienie, __count__a jeśli nie istnieje (tzn. Nie Firefox), możesz iterować obiekt i zdefiniować do późniejszego wykorzystania np .:

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

W ten sposób skorzysta z niego dowolna obsługa przeglądarki __count__, a iteracje będą przeprowadzane tylko dla tych, które tego nie robią. Jeśli liczba się zmienia i nie możesz tego zrobić, zawsze możesz ustawić funkcję:

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

W ten sposób za każdym razem, gdy odwołujesz się do myobj. __count__funkcja uruchomi się i przeliczy.

Aby wykonać iterację na Avi Flax, odpowiedz Object.keys (obj) .length jest poprawny dla obiektu, który nie ma powiązanych z nim funkcji

przykład:

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

przeciw

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

kroki, aby tego uniknąć:

1. nie umieszczaj funkcji w obiekcie, w którym chcesz policzyć liczbę kluczy

2. użyj osobnego obiektu lub stwórz nowy obiekt specjalnie dla funkcji (jeśli chcesz policzyć, ile funkcji jest w pliku za pomocą Object.keys(obj).length)

również tak, w moim przykładzie użyłem modułu _ lub podkreślenia z nodejs

dokumentację można znaleźć tutaj http://underscorejs.org/, a także jej źródło na github i różne inne informacje

I wreszcie implementacja lodash https://lodash.com/docs#size

_.size(obj)

jak odpowiedziano powyżej: Object.keys(obj).length

Ale: ponieważ mamy teraz prawdziwą klasę Map w ES6, sugerowałbym użycie jej zamiast używania właściwości obiektu.

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

Dla tych, którzy mają Underscore.js w swoim projekcie, możesz:

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

lub funkcjonalny styl:

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

Oto kilka testów wydajności dla trzech metod;

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

Object.keys (). Długość

20 735 operacji na sekundę

Bardzo prosty i kompatybilny. Działa szybko, ale jest drogi, ponieważ tworzy nowy zestaw kluczy, który następnie zostaje wyrzucony.

return Object.keys(objectToRead).length;

zapętlić klucze

15 734 operacji na sekundę

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

Nieco wolniej, ale nigdzie w pobliżu użycia pamięci, więc prawdopodobnie lepiej, jeśli chcesz zoptymalizować pod kątem urządzeń mobilnych lub innych małych komputerów

Używanie mapy zamiast obiektu

953 839 338 operacji na sekundę

return mapToRead.size;

Zasadniczo mapa śledzi swój własny rozmiar, więc zwracamy tylko pole liczbowe. Daleko, znacznie szybciej niż jakakolwiek inna metoda. Jeśli masz kontrolę nad obiektem, zamień je na mapy.

Od: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty

Object.defineProperty (obj, prop, deskryptor)

Możesz dodać go do wszystkich swoich obiektów:

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

Lub pojedynczy obiekt:

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

Przykład:

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

Dodane w ten sposób nie będzie wyświetlane w pętlach for..in:

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

Wynik:

name:John Doe
email:leaked@example.com

Uwaga: nie działa w <przeglądarkach IE9.

Rozwiązałem ten problem, tworząc własną implementację podstawowej listy, która prowadzi rejestr liczby elementów przechowywanych w obiekcie. To jest bardzo proste. Coś takiego:

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

Możesz użyć Object.keys(data).lengthdo znalezienia długości obiektu JSON zawierającego kluczowe dane

Dla tych, którzy mają Ext JS 4 w swoim projekcie, możesz:

Ext.Object.getSize(myobj);

Zaletą tego jest to, że będzie działać na wszystkich przeglądarkach kompatybilnych z Ext (włącznie z IE6-IE8), jednak uważam, że czas działania nie jest lepszy niż O (n), jak w przypadku innych sugerowanych rozwiązań.

Możesz użyć:

Object.keys(objectName).length; 

i

Object.values(objectName).length;

OP nie określił, czy obiekt jest nodeList, jeśli tak, to możesz po prostu bezpośrednio użyć metody length . Przykład:

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

Jeśli powyższe jQuery nie działa, spróbuj

$(Object.Item).length

Nie sądzę, że jest to możliwe (przynajmniej nie bez użycia elementów wewnętrznych). I nie sądzę, byś dużo zyskał, optymalizując to.

Staram się udostępnić go wszystkim takim obiektom:

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 Closure ma niezłą funkcję do tego ... goog.object.getCount (obj)

spójrz na goog.Object Documentation