JavaScript'te bir nesnenin anahtar / özellik sayısını verimli bir şekilde nasıl sayabilirim?

Bir nesnenin anahtar / özellik sayısını saymanın en hızlı yolu nedir? Bunu nesne üzerinde yinelemeden yapmak mümkün mü? yani yapmadan

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

(Firefox sihirli bir __count__özellik sağladı , ancak bu sürüm 4'ün etrafında bir yerde kaldırıldı.)

Bunu Düğüm , Chrome, IE 9+, Firefox 4+ veya Safari 5+ gibi ES5 uyumlu herhangi bir ortamda yapmak için :

Object.keys(obj).length

• Tarayıcı Uyumluluğu
• Object.keys belgeleri ( ES5 olmayan tarayıcılara ekleyebileceğiniz bir yöntem içerir)

Bu kodu kullanabilirsiniz:

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

Ardından bunu eski tarayıcılarda da kullanabilirsiniz:

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

Eğer kullanıyorsanız Underscore.js kullanabileceğiniz _.size (teşekkür @douwe):
_.size(obj)

Alternatif olarak, bazıları için daha net olabilecek _.keys kullanabilirsiniz :
_.keys(obj).length

Underscore tavsiye ederim, onun çok temel şeyler yapmak için sıkı bir kütüphane. Mümkün olduğunda ECMA5 ile eşleşir ve yerel uygulamaya erteler.

Aksi takdirde @ Avi'nin cevabını destekliyorum. ECC5 olmayan tarayıcılara ekleyebileceğiniz keys () yöntemini içeren bir MDC dokümanı bağlantısı eklemek için düzenledim.

Standart Nesne uygulaması ( ES5.1 Nesne İç Özellikleri ve Yöntemleri ), Objectanahtar / özellik sayısını izlemek için a gerektirmez Object.

İşte en yaygın kullanılan alternatifler:

1. ECMAScript'in Object.keys ()

Object.keys(obj).length;Geçici bir dizi hesaplamak için tuşlar üzerinde dahili olarak yineleyerek çalışır ve uzunluğunu döndürür.

• Artıları - Okunabilir ve temiz sözdizimi. Yerel destek yoksa bir dolgu dışında kütüphane veya özel kod gerekmez
• Dezavantajları - Dizinin oluşturulması nedeniyle bellek ek yükü.

2. Kütüphane tabanlı çözümler

Bu konunun başka yerlerinde birçok kütüphane tabanlı örnek, kendi kütüphaneleri bağlamında yararlı deyimlerdir. Bununla birlikte, performans bakış açısından, mükemmel bir kütüphane olmayan kodla karşılaştırıldığında kazanılacak hiçbir şey yoktur, çünkü tüm bu kütüphane yöntemleri aslında bir for-loop veya ES5'i Object.keys(yerel veya shimmed) kapsamaktadır.

3. Bir for-loop'u optimize etme

Bu tür bir for- loop'un en yavaş kısmı.hasOwnProperty() , fonksiyon çağrısı yükü nedeniyle genellikle çağrıdır. Bu yüzden sadece bir JSON nesnesinin giriş sayısını istediğimde, .hasOwnProperty()hiçbir kodun ne kadar genişlemediğini bildiğimde aramayı atlıyorum Object.prototype.

Aksi takdirde, kodunuz klocal ( var k) yapılarak ++countve postfix yerine önek artış operatörü ( ) kullanılarak çok az optimize edilebilir .

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

Başka bir fikir, hasOwnPropertyyöntemin önbelleğe alınmasına dayanır :

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

Bunun belirli bir ortamda daha hızlı olup olmadığı bir kıyaslama meselesidir. Yine de çok sınırlı bir performans artışı beklenebilir.

Gerçekte bir performans sorunu ile karşılaşıyorsanız, nesneye / nesneden özellikler ekleyen / kaldıran çağrıları, uygun şekilde adlandırılmış (boyut?) Bir özelliği de artıran / azaltan bir işlevle sarmanızı öneririm.

İlk özellik sayısını yalnızca bir kez hesaplamanız ve oradan devam etmeniz gerekir. Gerçek bir performans sorunu yoksa, rahatsız etmeyin. Sadece bir kod parçasını bir fonksiyona sarın getNumberOfProperties(object)ve onunla yapın.

Avi Flax tarafından belirtildiği gibi https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

nesnenizdeki tüm numaralandırılabilir özellikler için hile yapar ancak bunun yerine numaralandırılamayan özellikleri de dahil eder Object.getOwnPropertyNames. Fark şu:

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

Belirtildiği gibi burada bu aynı tarayıcı desteği vardırObject.keys

Bununla birlikte, çoğu durumda, bu tür işlemlere sayılamayanları dahil etmek istemeyebilirsiniz, ancak farkı bilmek her zaman iyidir;)

Bunu yapmanın herhangi bir yolunun farkında değilim, ancak yinelemeleri minimumda tutmak için, varlığını kontrol etmeyi deneyebilirsiniz __count__ve yoksa (yani Firefox değil), nesne üzerinde yineleyebilir ve tanımlayabilirsiniz. daha sonra kullanmak için örneğin:

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

Bu şekilde destekleyici herhangi bir tarayıcı __count__bunu kullanır ve yinelemeler yalnızca kullanmayanlar için gerçekleştirilir. Sayı değişirse ve bunu yapamazsanız, bunu her zaman bir işlev haline getirebilirsiniz:

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

Bu şekilde myobj'e ne zaman başvurursanız. __count__fonksiyon patlayacak ve yeniden hesaplanacaktır.

Avi Keten üzerinde yineleme yapmak için, Object.keys (obj) .length, kendisine bağlı işlevlere sahip olmayan bir nesne için doğrudur.

misal:

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

karşı

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

bundan kaçınmak için adımlar:

1. içindeki anahtar sayısını saymak istediğiniz bir nesneye fonksiyon koymayın

2. ayrı bir nesne kullanın veya özellikle işlevler için yeni bir nesne yapın (kullanarak dosyada kaç işlev olduğunu saymak istiyorsanız Object.keys(obj).length)

Ayrıca evet benim örnekte nodejs gelen _ veya alt çizgi modülü kullanılır

belgelere http://underscorejs.org/ adresinin yanı sıra github ve diğer çeşitli bilgilerdeki kaynaklardan ulaşabilirsiniz.

Ve nihayet bir lodash uygulaması https://lodash.com/docs#size

_.size(obj)

yukarıda cevaplandığı gibi: Object.keys(obj).length

Ancak: şimdi ES6'da gerçek bir Map sınıfımız olduğu için, bir nesnenin özelliklerini kullanmak yerine bunu kullanmanızı öneririm .

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

Underscore.js projelerine dahil olanlar için şunları yapabilirsiniz:

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

veya fonksiyonel stil:

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

İşte üç yöntem için bazı performans testleri;

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

Object.keys (). Uzunlukta

Saniyede 20.735 işlem

Çok basit ve uyumlu. Hızlı ama pahalı bir şekilde çalışır çünkü yeni bir anahtar dizisi oluşturur, bu da daha sonra atılır.

return Object.keys(objectToRead).length;

anahtarlar arasında dolaşmak

Saniyede 15.734 işlem

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

Biraz daha yavaş, ancak bellek kullanımına yakın bir yer yok, bu yüzden mobil veya diğer küçük makineler için optimizasyon yapmak istiyorsanız daha iyi

Nesne yerine Harita Kullanma

Saniyede 953.839.338 işlem

return mapToRead.size;

Temel olarak, Harita kendi boyutunu izler, böylece sadece bir sayı alanı döndürürüz. Diğer yöntemlerden çok daha hızlı. Nesne üzerinde kontrolünüz varsa, bunları haritalara dönüştürün.

Gönderen: https://developer.mozilla.org/tr/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty

Object.defineProperty (obj, prop, tanımlayıcı)

Tüm nesnelerinize ekleyebilirsiniz:

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

Veya tek bir nesne:

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

Misal:

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

Bu şekilde eklendi, for döngülerinde görüntülenmeyecek:

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

Çıktı:

name:John Doe
email:leaked@example.com

Not: <IE9 tarayıcılarında çalışmaz.

Bu sorunu nasıl çözdüğüm, nesnede kaç öğe saklandığının kaydını tutan temel bir listeyi kendi uygulamam oluşturmaktır. Çok basit. Bunun gibi bir şey:

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

Object.keys(data).lengthAnahtar verilere sahip JSON nesnesinin uzunluğunu bulmak için kullanabilirsiniz

Projelerinde Ext JS 4 olanlar için şunları yapabilirsiniz:

Ext.Object.getSize(myobj);

Bunun avantajı, tüm Ext uyumlu tarayıcılarda (IE6-IE8 dahil) çalışacağıdır, ancak diğer önerilen çözümlerde olduğu gibi çalışma süresinin O (n) 'den daha iyi olmadığına inanıyorum.

Kullanabilirsiniz:

Object.keys(objectName).length; 

ve

Object.values(objectName).length;

OP nesnenin bir nodeList olup olmadığını belirtmedi, eğer öyleyse doğrudan uzunluk yöntemini kullanabilirsiniz . Misal:

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

Yukarıdaki jQuery çalışmazsa,

$(Object.Item).length

Bunun mümkün olduğunu düşünmüyorum (en azından bazı içselleri kullanmadan). Ve bunu optimize ederek fazla kazanacağınızı sanmıyorum.

Ben böyle tüm nesneler için kullanılabilir hale getirmeye çalışın:

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 Kapanış'ın bunun için güzel bir işlevi var ... goog.object.getCount (obj)

goog.Object Belgelerine bakın