JavaScript nesnesinin uzunluğu

Bir JavaScript nesnem var, bu nesnenin uzunluğunu elde etmek için yerleşik veya kabul edilen en iyi uygulama yolu var mı?

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

En sağlam cevap (yani, en az hataya neden olurken yapmaya çalıştığınız şeyin amacını yakalayan):

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

JavaScript'te Object.prototype'e bir şeyler eklemediğiniz bir tür kural vardır , çünkü çeşitli kütüphanelerdeki numaralandırmaları kırabilir. Bununla birlikte, Object'e yöntem eklemek genellikle güvenlidir.

İşte 2016 itibariyle bir güncelleme ve ES5 ve ötesinin yaygın dağıtımı . IE9 + ve diğer tüm modern ES5 + tarayıcıları Object.keys()için yukarıdaki kodun olması için kullanabilirsiniz :

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

Object.keys()Şu anda yerleşik olduğundan , mevcut herhangi bir prototipi değiştirmek zorunda değildir .

Düzenleme : Nesneler, Object.key yöntemi ile döndürülemeyen sembolik özelliklere sahip olabilir. Yani cevap onlardan bahsetmeden eksik olurdu.

Nesne özellikleri için benzersiz tanımlayıcılar oluşturmak üzere dile sembol tipi eklendi. Symbol tipinin ana yararı üzerine yazmaların önlenmesidir.

Object.keysveya Object.getOwnPropertyNamessembolik özellikler için çalışmaz. Onları iade etmek için kullanmanız gerekir 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

hasOwnPropertyKontroller hakkında endişelenmenize gerek olmadığını biliyorsanız, bunu çok basit bir şekilde yapabilirsiniz:

Object.keys(myArray).length

Güncelleme : Underscore.js kullanıyorsanız (önerilir, hafif!), O zaman yapabilirsiniz

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

Değilse ve herhangi bir nedenle Object özellikleriyle uğraşmak istemiyorsanız ve zaten jQuery kullanıyorsanız, bir eklentiye eşit olarak erişilebilir:

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

İşte en çapraz tarayıcı çözümü.

Varsa, yerel Object.keys kullandığından bu kabul edilen yanıttan daha iyidir. Böylece, tüm modern tarayıcılar için en hızlısıdır.

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;

Ben bir JavaScript uzmanı değilim, ancak nesneler arasında döngü ve Nesne bir uzunluk yöntemi olmadığından onları saymak zorunda gibi görünüyor:

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

@palmsey: OP'ye adalet açısından, JavaScript belgeleri aslında açıkça Object türündeki değişkenlerin bu şekilde "ilişkilendirilebilir diziler" olarak kullanılmasını ifade eder.

Bu yöntem, nesnenizin tüm özellik adlarını bir dizide alır, böylece nesnenin anahtarlarının uzunluğuna eşit olan dizinin uzunluğunu elde edebilirsiniz.

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

Prototip veya başka bir kodla uğraşmamak için kendi nesnenizi oluşturabilir ve genişletebilirsiniz:

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

Her zaman add yöntemini kullanırsanız, length özelliği doğru olur. Siz veya başkalarının bunu kullanmayı unuttuğundan endişe ediyorsanız, diğerlerinin uzunluk yöntemine gönderdiği özellik sayacını da ekleyebilirsiniz.

Tabii ki, her zaman yöntemlerin üzerine yazabilirsiniz. Ancak bunu yapsanız bile, kodunuz muhtemelen fark edilir şekilde başarısız olur ve hata ayıklamayı kolaylaştırır. ;)

Özelliğin prototip zincirinde olup olmadığını nasıl kontrol edeceğinizi ve unutmayın:

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

Şunu elde etmek için bunu kullanın length:

Object.keys(myObject).length

İşte sadece daha modern tarayıcılarda (IE9 +, Chrome, Firefox 4+, Opera 11.60+, Safari 5.1+) çalışacak tamamen farklı bir çözüm

Bkz .

İlişkilendirilebilir Dizi sınıfınızı ayarlayın

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

Şimdi bu kodu aşağıdaki gibi kullanabilirsiniz ...

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>

Bu benim için çalışıyor:

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

Bazı durumlarda, boyutu ayrı bir değişkende saklamak daha iyidir. Özellikle, diziye tek bir yerde tek bir öğe ekliyorsanız ve boyutu kolayca artırabilirsiniz. Boyutu sık sık kontrol etmeniz gerekiyorsa çok daha hızlı çalışır.

kullanın:

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

@palmsey: OP'ye adaletli olarak, javascript dokümanları açıkça açıkça Object türündeki değişkenlerin bu şekilde "ilişkilendirilebilir diziler" olarak kullanılmasını ifade eder.

Ve @palmsey için adalet içinde oldukça doğruydu, ilişkilendirilebilir diziler değiller, kesinlikle nesneler :) - ilişkilendirilebilir bir dizinin işini yapıyorlar. Ancak daha geniş noktaya gelince, bulduğum bu oldukça iyi makaleye göre kesinlikle onun hakkına sahip görünüyorsunuz:

JavaScript “İlişkili Diziler” Zararlı Olarak Değerlendirildi

Ancak tüm bunlara göre, kabul edilen cevabın kendisi kötü uygulama değil mi?

Nesne için bir prototip boyut () işlevi belirtme

Object .prototype öğesine başka bir şey eklenmişse, önerilen kod başarısız olur:

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

Aynı yürütme bağlamında çalışan başka bir kod varsa, çalışmanın güvenilir olamayacağı için bu yanıtın kabul edilmesi gerektiğini düşünmüyorum. Bunu sağlam bir şekilde yapmak için, myArray içindeki boyut yöntemini tanımlamanız ve üyeler arasında yineleme yaparken türünü kontrol etmeniz gerekir.

Boyutunu ortaya çıkaran ilişkilendirilebilir bir veri yapısına ihtiyacınız varsa, nesne yerine bir harita kullanın.

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

Böyle bir şeye ne dersin --

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

Eğer hash varsa

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

hash uzunluğu olan tuşların uzunluğunu kullanarak uzunluğu alabiliriz:

anahtarlar (hash) .length

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

Eğer kullanıyorsanız angularjs bir filtre oluşturma ve Aşağıdaki gibi diğer örneklerden herhangi birinden kodu kullanarak şeyler angularjs yol yapabilirsiniz 1.x:

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

kullanım

Kumandanızda:

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

Veya sizce:

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

En basit yol böyle

Object.keys(myobject).length

myobject, uzunluğunu istediğiniz şeyin nesnesi

Internet Explorer 8 veya daha düşük sürümlerini desteklemeyi umursamıyorsanız, aşağıdaki iki adımı uygulayarak bir nesnedeki özellik sayısını kolayca elde edebilirsiniz:

1. Ya Run Object.keys()sadece bu özelliklerin adlarını içeren bir dizi almak için enumerable veya Object.getOwnPropertyNames()isterseniz de enumerable olmayan mallara isimler yer alıyor.
2. .lengthBu dizinin özelliğini alın .

Bunu bir kereden fazla yapmanız gerekiyorsa, bu mantığı bir işleve sarabilirsiniz:

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

Bu özel işlev nasıl kullanılır:

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

Demo için bu Fiddle'a da bakın .

Object.keys(myObject).lengthNesnenin / dizinin uzunluğunu elde etmek için kullanın

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

Yukarıdakilerin bazılarında bir varyasyon:

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

HasOwnProp'u entegre etmenin biraz daha zarif bir yoludur.

İşte James Cogan'ın cevabının farklı bir versiyonu. Bir argüman iletmek yerine, Object sınıfını prototipleyin ve kodu daha temiz hale getirin.

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 örneği: http://jsfiddle.net/qar4j/1/

Object.keys(obj).lengthUzunluğunu elde etmek için herhangi bir nesne üzerinde kullanabilirsiniz . Object.keys , karşılık gelen dizinin uzunluğunu kullanarak o nesnenin uzunluğunu bulmak için kullanışlı olabilecek tüm nesne anahtarlarını (özelliklerini) içeren bir dizi döndürür . Bunun için bir işlev bile yazabilirsiniz . Yaratıcı olalım ve bunun için de bir yöntem yazalım (daha uygun bir alıcı özelliği ile birlikte):

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

Her zaman normal dizi için verdiğiniz Object.getOwnPropertyNames(myObject).lengthsonucun aynısını alabilirsiniz [].length.

Nesne uzunluğunu aşağıdakileri kullanarak bulabiliriz:

Object.values(myObject).length

Oyuna biraz geç, ancak bunu başarmanın güzel bir yolu (sadece IE9 +) length özelliğinde sihirli bir alıcı tanımlamaktır:

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

Ve sadece şu şekilde kullanabilirsiniz:

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

Veririm 1.

Aşağıda, JavaScript'i düz bırakmış olanlar için James Coglan'ın CoffeeScript'teki cevabının bir sürümü bulunmaktadır :)

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