Lengte van een JavaScript-object

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

Antwoord 17

@palmsey: In alle eerlijkheid tegenover de OP, verwijst de JavaScript-documentatie eigenlijk expliciet naar het gebruik van variabelen van het type Object op deze manier als “associatieve arrays”.

En om eerlijk te zijn tegenover @palmsey had hij helemaal gelijk. Het zijn geen associatieve arrays; het zijn zeker objecten 🙂 – doen het werk van een associatieve array. Maar wat betreft het bredere punt, je lijkt er zeker recht op te hebben volgens dit nogal mooie artikel dat ik vond:

JavaScript “Associative arrays” als schadelijk beschouwd

Maar volgens dit alles is het geaccepteerde antwoordzelf een slechte gewoonte ?

Specificeer een functie voor prototype size() voor Object

Als er iets anders is toegevoegd aan Object .prototype, zal de voorgestelde code mislukken:

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

Ik denk niet dat dat antwoord het geaccepteerde antwoord moet zijn, omdat het niet kan worden vertrouwd om te werken als er andere code in dezelfde uitvoeringscontext wordt uitgevoerd. Om het op een robuuste manier te doen, moet u zeker de groottemethode binnen myArray definiëren en controleren op het type leden terwijl u ze doorloopt.

Antwoord 18

De eenvoudigste manier is als volgt:

Object.keys(myobject).length

waar MyObject het doel is van wat u wilt dat de lengte van.

Antwoord 19

Hoe zit het met zoiets –

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

Antwoord 20

Als we de hash

hebben

HASH = {“A”: “B”, “C”: “D”};

We kunnen de lengte krijgen met behulp van de lengte van de sleutels die de lengte van de hash is:

KEYS (HASH) .LENGTH

Antwoord 21

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

1. object.Values ​​(myobject) .length
2. Object.Entries (MyObject). Lengte
3. Object.Keys (MyObject) .lengte

Antwoord 22

Als u angularjs 1.x kunt doen, kunt u dingen doen die de Angularjs-manier is door een Filter en gebruik de code van een van de andere voorbeelden zoals het volgende:

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

gebruik

In uw controller:

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

Of naar jouw mening:

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

Antwoord 23

const myObject = new Object();
myObject["firstname"] = "Gareth";
myObject["lastname"] = "Simpson";
myObject["age"] = 21;
console.log(Object.keys(myObject).length)
// o/p 3

Antwoord 24

Een variatie op een aantal van bovenstaande is:

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

Het is een wat elegantere manier om hasOwnProp te integreren.

Antwoord 25

Als u Internet Explorer 8 of lager niet wilt ondersteunen, kunt u eenvoudig het aantal eigenschappen in een object verkrijgen door de volgende twee stappen toe te passen:

1. Voer een van de Object.keys()om een array te krijgen die de namen bevat van alleen die eigenschappen die enumerableof Object.getOwnPropertyNames()als u ook de namen wilt opnemen van eigenschappen die niet opsombaar.
2. Verkrijg de .lengtheigendom van die array.

Als u dit meer dan eens moet doen, kunt u deze logica in een functie inpakken:

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

Hoe deze specifieke functie te gebruiken:

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

Zie ook deze viool voor een demo.

Antwoord 26

Hier is een andere versie van het antwoord van James Cogan. In plaats van een argument te passeren, proteert u gewoon de objectklasse en maak de codereiniger.

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 Voorbeeld: http://jsfiddle.net/qar4j/1/

Antwoord 27

U kunt eenvoudig Object.keys(obj).lengthop elk object om zijn lengte te krijgen. Object.Keys retourneert een array die al het object toetsen (eigenschappen) bevat dat van pas kan komen voor het vinden van de lengte van dat object met behulp van de lengte van de overeenkomstige array. U kunt zelfs een -functie hiervoor schrijven. Laten we Creative krijgen en schrijf een methode voor het ook (samen met een meer convienetent Getter Property):

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

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

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

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