Bagaimana cara menghitung jumlah kunci / properti suatu objek dalam JavaScript secara efisien?

Apa cara tercepat untuk menghitung jumlah kunci / properti suatu objek? Mungkinkah melakukan ini tanpa mengulangi objek? yaitu tanpa melakukan

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

(Firefox memang memberikan __count__properti sulap , tetapi ini dihapus di suatu tempat di sekitar versi 4.)

Untuk melakukan ini di lingkungan yang kompatibel dengan ES5 , seperti Node , Chrome, IE 9+, Firefox 4+, atau Safari 5+:

Object.keys(obj).length

• Kompatibilitas browser
• Dokumentasi Object.keys (termasuk metode yang dapat Anda tambahkan ke browser non-ES5)

Anda bisa menggunakan kode ini:

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

Kemudian Anda dapat menggunakan ini di browser lama juga:

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

Jika Anda menggunakan Underscore.js, Anda dapat menggunakan _.size (terima kasih @douwe):
_.size(obj)

Atau Anda juga dapat menggunakan _.keys yang mungkin lebih jelas untuk beberapa:
_.keys(obj).length

Saya sangat merekomendasikan Underscore, ini adalah perpustakaan yang ketat untuk melakukan banyak hal dasar. Kapan saja mereka cocok dengan ECMA5 dan tunduk pada implementasi asli.

Kalau tidak, saya mendukung jawaban @ Avi. Saya mengeditnya untuk menambahkan tautan ke dokumen MDC yang mencakup metode keys () yang dapat Anda tambahkan ke browser non-ECMA5.

Implementasi Objek standar ( ES5.1 Objek Properti dan Metode Internal ) tidak memerlukan Objectuntuk melacak jumlah kunci / properti, sehingga tidak boleh ada cara standar untuk menentukan ukuran Objecttanpa berulang-ulang atau tersirat secara implisit atas kunci-kuncinya.

Jadi di sini adalah alternatif yang paling umum digunakan:

1. ECMAScript's Object.keys ()

Object.keys(obj).length;Bekerja dengan pengulangan internal atas kunci untuk menghitung array sementara dan mengembalikan panjangnya.

• Pro - Sintaks yang mudah dibaca dan bersih. Tidak perlu pustaka atau kode khusus kecuali shim jika dukungan asli tidak tersedia
• Kontra - Memori overhead karena penciptaan array.

2. Solusi berbasis perpustakaan

Banyak contoh berbasis perpustakaan di tempat lain dalam topik ini adalah idiom yang berguna dalam konteks perpustakaan mereka. Dari sudut pandang kinerja, bagaimanapun, tidak ada untungnya dibandingkan dengan kode tanpa pustaka yang sempurna karena semua metode pustaka tersebut benar-benar merangkum for-loop atau ES5 Object.keys(asli atau shimmed).

3. Mengoptimalkan for-loop

Bagian paling lambat dari for-loop umumnya adalah .hasOwnProperty()panggilan, karena fungsi panggilan overhead. Jadi ketika saya hanya ingin jumlah entri objek JSON, saya hanya melewatkan .hasOwnProperty()panggilan jika saya tahu bahwa tidak ada kode yang juga tidak akan diperpanjang Object.prototype.

Kalau tidak, kode Anda bisa sangat sedikit dioptimalkan dengan membuat klocal ( var k) dan dengan menggunakan pre-increment operator ( ++count) alih-alih postfix.

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

Gagasan lain bergantung pada caching hasOwnPropertymetode:

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

Apakah ini lebih cepat atau tidak pada lingkungan tertentu adalah masalah pembandingan. Bagaimanapun juga, perolehan kinerja yang sangat terbatas dapat diharapkan.

Jika Anda benar-benar mengalami masalah kinerja, saya sarankan membungkus panggilan yang menambah / menghapus properti ke / dari objek dengan fungsi yang juga menambah / mengurangi properti (ukuran?) Yang dinamai dengan tepat.

Anda hanya perlu menghitung jumlah awal properti sekali dan beralih dari sana. Jika tidak ada masalah kinerja aktual, jangan repot-repot. Hanya bungkus sedikit kode itu dalam suatu fungsi getNumberOfProperties(object)dan selesai dengan itu.

Seperti yang dinyatakan oleh Avi Flax https://stackoverflow.com/a/4889658/1047014

Object.keys(obj).length

akan melakukan trik untuk semua properti enumerable pada objek Anda tetapi untuk juga menyertakan properti non-enumerable yang Anda dapat gunakan Object.getOwnPropertyNames. Inilah perbedaannya:

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

Seperti yang dinyatakan di sini ini memiliki dukungan browser yang sama denganObject.keys

Namun, dalam sebagian besar kasus, Anda mungkin tidak ingin memasukkan yang tidak dapat dihitung dalam jenis operasi ini, tetapi selalu baik untuk mengetahui perbedaannya;)

Saya tidak mengetahui cara apa pun untuk melakukan ini, namun untuk menjaga iterasi seminimal mungkin, Anda dapat mencoba memeriksa keberadaan __count__dan jika tidak ada (mis. Bukan Firefox) maka Anda bisa beralih pada objek dan menentukan itu untuk digunakan nanti misalnya:

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

Dengan cara ini setiap pendukung browser __count__akan menggunakannya, dan iterasi hanya akan dilakukan untuk mereka yang tidak. Jika jumlah berubah dan Anda tidak bisa melakukan ini, Anda selalu bisa membuatnya berfungsi:

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

Dengan cara ini, kapan saja Anda merujuk myobj. __count__fungsi akan diaktifkan dan dihitung ulang.

Untuk beralih pada Avi Flax, jawab Object.keys (obj). Panjang sudah benar untuk objek yang tidak memiliki fungsi yang terkait dengannya

contoh:

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

melawan

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

langkah-langkah untuk menghindari ini:

1. jangan letakkan fungsi di objek yang ingin Anda hitung jumlah kunci

2. menggunakan objek terpisah atau membuat objek baru khusus untuk fungsi (jika Anda ingin menghitung berapa banyak fungsi yang ada dalam file menggunakan Object.keys(obj).length)

juga ya saya menggunakan modul _ atau garis bawah dari nodejs dalam contoh saya

dokumentasi dapat ditemukan di sini http://underscorejs.org/ serta sumbernya di github dan berbagai info lainnya

Dan akhirnya implementasi lodash https://lodash.com/docs#size

_.size(obj)

seperti yang dijawab di atas: Object.keys(obj).length

Tapi: seperti yang kita miliki sekarang kelas Peta nyata di ES6, saya akan menyarankan untuk menggunakannya daripada menggunakan properti dari suatu objek.

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

Bagi mereka yang memiliki Underscore.js termasuk dalam proyek mereka yang dapat Anda lakukan:

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

atau gaya fungsional:

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

Berikut adalah beberapa tes kinerja untuk tiga metode;

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

Panjang Object.keys ()

20.735 operasi per detik

Sangat sederhana dan kompatibel. Berjalan cepat tetapi mahal karena itu menciptakan array kunci baru, yang kemudian dibuang.

return Object.keys(objectToRead).length;

loop melalui tombol

15.734 operasi per detik

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

Sedikit lebih lambat, tetapi jauh dari penggunaan memori, jadi mungkin lebih baik jika Anda tertarik untuk mengoptimalkan untuk ponsel atau mesin kecil lainnya

Menggunakan Map, bukan Object

953.839.338 operasi per detik

return mapToRead.size;

Pada dasarnya, Peta melacak ukurannya sendiri sehingga kami hanya mengembalikan bidang angka. Jauh, jauh lebih cepat daripada metode lainnya. Jika Anda memiliki kendali atas objek, konversikan mereka ke peta.

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

Object.defineProperty (obj, prop, deskriptor)

Anda bisa menambahkannya ke semua objek Anda:

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

Atau satu objek:

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

Contoh:

var myObj = {};
myObj.name  = "John Doe";
myObj.email = "[email protected]";
myObj.length; //output: 2

Ditambahkan dengan cara itu, itu tidak akan ditampilkan dalam for..in loop:

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

Keluaran:

name:John Doe
email:leaked@example.com

Catatan: itu tidak berfungsi di <IE9 browser.

Bagaimana saya memecahkan masalah ini adalah membangun implementasi saya sendiri dari daftar dasar yang menyimpan catatan tentang berapa banyak item yang disimpan dalam objek. Sangat sederhana. Sesuatu seperti ini:

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

Anda dapat menggunakan Object.keys(data).lengthuntuk menemukan panjang objek JSON yang memiliki data kunci

Bagi mereka yang memiliki Ext JS 4 di proyek mereka yang dapat Anda lakukan:

Ext.Object.getSize(myobj);

Keuntungan dari ini adalah bahwa ia akan bekerja pada semua browser yang kompatibel dengan Ext (termasuk IE6-IE8), namun, saya percaya waktu yang berjalan tidak lebih baik daripada O (n), seperti solusi yang disarankan lainnya.

Kamu bisa menggunakan:

Object.keys(objectName).length; 

dan

Object.values(objectName).length;

OP tidak menentukan apakah objek tersebut adalah nodeList, jika ya maka Anda bisa langsung menggunakan metode panjang . Contoh:

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

Jika jQuery di atas tidak berfungsi, maka coba

$(Object.Item).length

Saya tidak berpikir ini mungkin (setidaknya tidak tanpa menggunakan beberapa internal). Dan saya tidak berpikir Anda akan mendapatkan banyak dengan mengoptimalkan ini.

Saya mencoba membuatnya tersedia untuk semua objek seperti ini:

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 Penutupan memiliki fungsi yang bagus untuk ini ... goog.object.getCount (obj)

lihat di Goog.Object Documentation