Panjang objek JavaScript

Saya memiliki objek JavaScript, apakah ada cara praktik terbaik bawaan atau yang diterima untuk mendapatkan panjang objek ini?

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

Jawaban yang paling kuat (yaitu yang menangkap maksud dari apa yang Anda coba lakukan sambil menyebabkan bug paling sedikit) adalah:

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

Ada semacam konvensi dalam JavaScript yang Anda tidak menambahkan hal-hal ke Object.prototype , karena itu dapat merusak enumerasi di berbagai perpustakaan. Menambahkan metode ke Objek biasanya aman.

Berikut ini adalah pembaruan pada 2016 dan penyebaran luas ES5 dan seterusnya. Untuk IE9 + dan semua browser yang mampu ES5 + modern lainnya, Anda dapat menggunakan Object.keys()kode di atas menjadi:

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

Ini tidak harus memodifikasi prototipe yang ada karena Object.keys()sekarang sudah ada di dalamnya .

Sunting : Objek dapat memiliki sifat simbolis yang tidak dapat dikembalikan melalui metode Object.key. Jadi jawabannya tidak lengkap tanpa menyebutkannya.

Jenis simbol ditambahkan ke bahasa untuk membuat pengidentifikasi unik untuk properti objek. Manfaat utama dari tipe Symbol adalah pencegahan overwrites.

Object.keysatau Object.getOwnPropertyNamestidak berfungsi untuk properti simbolik. Untuk mengembalikannya, Anda harus menggunakan 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

Jika Anda tahu Anda tidak perlu khawatir tentang hasOwnPropertycek, Anda dapat melakukannya dengan sangat sederhana:

Object.keys(myArray).length

Diperbarui : Jika Anda menggunakan Underscore.js (disarankan, ini ringan!), Maka Anda bisa melakukannya

_.size({one : 1, two : 2, three : 3});
=> 3

Jika tidak , dan Anda tidak ingin dipusingkan dengan properti Object untuk alasan apa pun, dan sudah menggunakan jQuery, sebuah plugin dapat diakses dengan sama:

$.assocArraySize = function(obj) {
    // http://stackoverflow.com/a/6700/11236
    var size = 0, key;
    for (key in obj) {
        if (obj.hasOwnProperty(key)) size++;
    }
    return size;
};

Inilah solusi lintas-peramban yang paling banyak.

Ini lebih baik daripada jawaban yang diterima karena menggunakan Object.keys asli jika ada. Dengan demikian, ini adalah yang tercepat untuk semua browser modern.

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;

Saya bukan pakar JavaScript, tetapi sepertinya Anda harus mengulang-ulang elemen dan menghitungnya karena Object tidak memiliki metode panjang:

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

@palmsey: Sejujurnya pada OP, dokumentasi JavaScript sebenarnya secara eksplisit merujuk pada penggunaan variabel tipe Objek dengan cara ini sebagai "array asosiatif".

Metode ini mendapatkan semua nama properti objek Anda dalam array, sehingga Anda bisa mendapatkan panjang array yang sama dengan panjang kunci objek Anda.

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

Untuk tidak mengacaukan prototipe atau kode lain, Anda dapat membuat dan memperluas objek Anda sendiri:

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

Jika Anda selalu menggunakan metode add, properti panjang akan benar. Jika Anda khawatir bahwa Anda atau orang lain lupa menggunakannya, Anda bisa menambahkan penghitung properti yang juga diposkan orang lain ke metode panjang.

Tentu saja, Anda selalu bisa menimpa metode. Tetapi bahkan jika Anda melakukannya, kode Anda mungkin akan gagal terlihat, membuatnya mudah untuk di-debug. ;)

Inilah cara dan jangan lupa untuk memeriksa bahwa properti tersebut tidak ada dalam rantai prototipe:

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

Cukup gunakan ini untuk mendapatkan length:

Object.keys(myObject).length

Berikut adalah solusi yang sama sekali berbeda yang hanya akan berfungsi di browser yang lebih modern (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+)

Lihat jsFiddle

Atur kelas Array Asosiatif Anda

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

Sekarang Anda dapat menggunakan kode ini sebagai berikut ...

var a1 = new AssociativeArray();
a1["prop1"] = "test";
a1["prop2"] = 1234;
a1["prop3"] = "something else";
alert("Length of array is " + a1.length);

<script>
myObj = {"key1" : "Hello", "key2" : "Goodbye"};
var size = Object.keys(myObj).length;
console.log(size);
</script>

<p id="myObj">The number of <b>keys</b> in <b>myObj</b> are: <script>document.write(size)</script></p>

Ini bekerja untuk saya:

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

Untuk beberapa kasus, lebih baik menyimpan ukuran dalam variabel terpisah. Terutama, jika Anda menambahkan ke array dengan satu elemen di satu tempat dan dapat dengan mudah menambah ukuran. Jelas akan bekerja lebih cepat jika Anda perlu memeriksa ukurannya sesering mungkin.

Menggunakan:

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

@palmsey: Dalam keadilan untuk OP, dokumen javascript sebenarnya secara eksplisit merujuk menggunakan variabel tipe Objek dengan cara ini sebagai "array asosiatif".

Dan dalam keadilan untuk @palmsey dia cukup benar, mereka bukan array asosiatif, mereka pasti objek :) - melakukan pekerjaan array asosiatif. Tetapi mengenai poin yang lebih luas, Anda tampaknya memiliki hak untuk itu menurut artikel yang agak bagus yang saya temukan:

JavaScript “Array Asosiatif” Dianggap Berbahaya

Tetapi menurut semua ini, bukankah jawaban yang diterima itu sendiri merupakan praktik yang buruk?

Tentukan fungsi ukuran prototipe () untuk Objek

Jika ada yang lain telah ditambahkan ke Object .prototype, maka kode yang disarankan akan gagal:

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

Saya tidak berpikir bahwa jawaban harus yang diterima karena tidak dapat dipercaya untuk bekerja jika Anda memiliki kode lain yang berjalan dalam konteks eksekusi yang sama. Untuk melakukannya dengan cara yang kuat tentunya Anda perlu menentukan metode ukuran dalam myArray dan memeriksa jenis anggota saat Anda mengulanginya.

Jika Anda membutuhkan struktur data asosiatif yang memperlihatkan ukurannya, lebih baik gunakan peta daripada objek.

const myMap = new Map();
myMap.set("firstname", "Gareth");
myMap.set("lastname", "Simpson");
myMap.set("age", 21);
myMap.size; // 3

Bagaimana dengan sesuatu yang seperti ini --

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

Jika kita memiliki hash

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

kita bisa mendapatkan panjang menggunakan panjang kunci yang merupakan panjang dari hash:

kunci (hash) .panjang

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

Jika Anda menggunakan AngularJS 1.x Anda dapat melakukan berbagai hal dengan cara AngularJS dengan membuat filter dan menggunakan kode dari salah satu contoh lain seperti berikut:

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

Pemakaian

Di controller Anda:

$scope.filterResult = $filter('lengthOfObject')($scope.object)

Atau menurut Anda:

<any ng-expression="object | lengthOfObject"></any>

Cara paling sederhana adalah seperti ini

Object.keys(myobject).length

di mana objek saya adalah objek dari apa yang Anda inginkan panjangnya

Jika Anda tidak peduli tentang mendukung Internet Explorer 8 atau lebih rendah, Anda dapat dengan mudah mendapatkan jumlah properti di objek dengan menerapkan dua langkah berikut:

1. Jalankan baik Object.keys()untuk mendapatkan array yang hanya berisi nama-nama properti yang dapat dihitung atau Object.getOwnPropertyNames()jika Anda ingin juga menyertakan nama properti yang tidak dapat dihitung.
2. Dapatkan .lengthproperti dari array itu.

Jika Anda perlu melakukan ini lebih dari sekali, Anda bisa membungkus logika ini dalam suatu fungsi:

function size(obj, enumerablesOnly) {
    return enumerablesOnly === false ?
        Object.getOwnPropertyNames(obj).length :
        Object.keys(obj).length;
}

Cara menggunakan fungsi khusus ini:

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

Lihat juga Fiddle ini untuk demo.

Gunakan Object.keys(myObject).lengthuntuk mendapatkan panjang objek / array

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

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

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

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

// o/p 3

Variasi pada beberapa hal di atas adalah:

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

Ini adalah cara yang sedikit lebih elegan untuk mengintegrasikan hasOwnProp.

Inilah versi berbeda dari jawaban James Cogan. Alih-alih menyampaikan argumen, cukup prototipe kelas Object dan buat kode lebih bersih.

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;

contoh jsfiddle: http://jsfiddle.net/qar4j/1/

Anda cukup menggunakan Object.keys(obj).lengthpada objek apa saja untuk mendapatkan panjangnya. Object.keys mengembalikan array yang berisi semua kunci objek (properti) yang berguna untuk menemukan panjang objek yang menggunakan panjang array yang sesuai. Anda bahkan dapat menulis fungsi untuk ini. Mari berkreasi dan menulis metode untuk itu (bersama dengan properti pengambil yang lebih ramah):

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

Anda selalu dapat melakukan Object.getOwnPropertyNames(myObject).lengthuntuk mendapatkan hasil yang sama seperti yang [].lengthakan diberikan untuk array normal.

Kita dapat menemukan panjang Obyek dengan menggunakan:

Object.values(myObject).length

Agak terlambat untuk permainan, tetapi cara yang bagus untuk mencapai ini (hanya IE9 +) adalah dengan mendefinisikan pengambil sihir pada properti panjang:

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

Dan Anda bisa menggunakannya seperti ini:

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

Akan memberi 1.

Di bawah ini adalah versi jawaban James Coglan di CoffeeScript untuk mereka yang telah meninggalkan JavaScript langsung :)

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