Wie man über ein JavaScript-Objekt iteriert?

Ich habe ein Objekt in JavaScript:

{
    abc: '...',
    bca: '...',
    zzz: '...',
    xxx: '...',
    ccc: '...',
    //...
}

Ich möchte an einem for - Schleife, um seine Eigenschaften. Und ich will zu Durchlaufen, die es in teilen (nicht alle Objekt-Eigenschaften auf einmal).

Mit einer einfachen Reihe, ich kann es tun, mit einem standard - for Schleife:

for (i = 0; i < 100; i++) { ... } //first part
for (i = 100; i < 300; i++) { ... } //second
for (i = 300; i < arr.length; i++) { ... } //last

Aber wie man es mit Objekten?

InformationsquelleAutor der Frage nkuhta | 2013-01-17

450

Bei den meisten Objekten verwenden Sie for .. in :
```
for (var key in yourobject) {
  console.log(key, yourobject[key]);
}
```
Um keine Protokollierung vererbten Eigenschaften, überprüfen Sie mit hasOwnProperty :
```
for (var key in yourobject) {
   if (yourobject.hasOwnProperty(key)) {
      console.log(key, yourobject[key]);
   }
}
```
Das MDN-Dokumentation erklärt allgemein, wie man mit Objekten und deren Eigenschaften.

Wenn Sie wollen, es zu tun "in Blöcken", die beste ist, um zu extrahieren die Schlüssel in einem array. Wie, die Reihenfolge ist nicht garantiert, das ist der richtige Weg. In modernen Browsern, die Sie verwenden können,
```
var keys = Object.keys(yourobject);
```
Mehr kompatibel ist, solltest du besser so machen :
```
 var keys = [];
 for (var key in yourobject) {      
     if (yourobject.hasOwnProperty(key)) keys.push(key);
 }
```
Dann können Sie iterativ auf Ihre Eigenschaften index: yourobject[keys[i]] :
```
for (var i=300; i<keys.length && i<600; i++) { 
   console.log(keys[i], yourobject[keys[i]]);
}
```
InformationsquelleAutor der Antwort Denys Séguret

Hier ist eine weitere iteration Lösung für moderne Browser:

Object.keys(obj).filter(function(k, i) {
    return i >= 100 && i < 300;
}).forEach(function(k) {
    console.log(obj[k]);
});

Oder noch kürzer:

Object.keys(obj).forEach(function(k, i) {
    if (i >= 100 && i < 300) {
        console.log(obj[k]);
    }
});

Allerdings muss man Bedenken, dass die Eigenschaften in JavaScript-Objekt sind nicht sortiert, d.h. Sie haben auch keine Ordnung.

InformationsquelleAutor der Antwort VisioN

Mit der neuen ES6/ES2015 Funktionen, die Sie nicht haben, um mit einem Objekt nicht mehr zur Iteration über einen hash. Sie können eine Anzeigen. Javascript-Maps-halten Sie Schlüssel in der insertion order, d.h. man kann Durchlaufen, ohne zu prüfen, die hasOwnProperty, das war immer wirklich ein hack.

Durchlaufen einer Karte:

var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "one");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
//Will show 2 logs; first with "0 = zero" and second with "1 = one"

for (var key of myMap.keys()) {
  console.log(key);
}
//Will show 2 logs; first with "0" and second with "1"

for (var value of myMap.values()) {
  console.log(value);
}
//Will show 2 logs; first with "zero" and second with "one"

for (var [key, value] of myMap.entries()) {
  console.log(key + " = " + value);
}
//Will show 2 logs; first with "0 = zero" and second with "1 = one"

oder verwenden Sie forEach:

myMap.forEach(function(value, key) {
  console.log(key + " = " + value);
}, myMap)
//Will show 2 logs; first with "0 = zero" and second with "1 = one"

InformationsquelleAutor der Antwort Paul

Die einzig zuverlässige Weg dies zu tun wäre, zu dem das Objekt gespeichert werden die Daten auf 2 arrays, ein-Tasten und eine für die Daten:

var keys = [];
var data = [];
for (var key in obj) {
    if (obj.hasOwnProperty(key)) {
        keys.push(key);
        data.push(obj[key]); //Not necessary, but cleaner, in my opinion. See the example below.
    }
}

Können Sie dann Durchlaufen der arrays, wie Sie normalerweise würden:

for(var i = 0; i < 100; i++){
    console.log(keys[i], data[i]);
    //or
    console.log(keys[i], obj[keys[i]]); //harder to read, I think.
}
for(var i = 100; i < 300; i++){
    console.log(keys[i], data[i]);
}

Ich bin nicht mit Object.keys(obj)weil IE 9+.

InformationsquelleAutor der Antwort Cerbrus

Mit Object.entries Sie so etwas tun.

 //array like object with random key ordering
 const anObj = { 100: 'a', 2: 'b', 7: 'c' };
 console.log(Object.entries(anObj)); //[ ['2', 'b'],['7', 'c'],['100', 'a'] ]

Objekt.Einträge () - Methode gibt ein array mit einem Objekt der eigenen enumerable-Eigenschaft [key, value]

So können Sie iterieren über das Objekt und haben key und value für jedes Objekt und bekommen so etwas wie dieses.

const anObj = { 100: 'a', 2: 'b', 7: 'c' };
Object.entries(anObj).map(obj => {
   const key   = obj[0];
   const value = obj[1];

   //do whatever you want with those values.
});

oder so

//Or, using array extras
Object.entries(obj).forEach(([key, value]) => {
  console.log(`${key} ${value}`); //"a 5", "b 7", "c 9"
});

Für eine Referenz haben Sie einen Blick auf die MDN docs für Objekt-Einträge

InformationsquelleAutor der Antwort Adeel Imran

1

Wollten Sie Durchlaufen das gesamte Objekt auf einmal könnten Sie for in Schleife:
```
for (var i in obj) {
  ...
}
```
Aber wenn Sie teilen möchten, das Objekt in Teile, in der Tat Sie nicht. Es gibt keine Garantie dafür, dass Eigenschaften im Objekt-sind in keiner bestimmten Reihenfolge. Daher, kann ich mir zwei Lösungen.

Erste von Ihnen ist die "entfernen" - schon gelesen-Eigenschaften:
```
var i = 0;
for (var key in obj) {
    console.log(obj[key]);
    delete obj[key];
    if ( ++i > 300) break;
}
```
Andere Lösung, die ich denken kann, ist die Verwendung von Arrays von Arrays anstelle des Objekts:
```
var obj = [['key1', 'value1'], ['key2', 'value2']];
```
Dann standard for - Schleife arbeiten.

InformationsquelleAutor der Antwort Michał Miszczyszyn
1

->wenn wir iterieren über ein JavaScript-Objekt mit und finden Sie Schlüssel eines Arrays von
objects
```
Object.keys(Array).forEach(key => {

 console.log('key',key)

})
```
InformationsquelleAutor der Antwort ashishdudhat

Wirklich ein PITA ist dies nicht Teil von standard-Javascript.

/**
 * Iterates the keys and values of an object.  Object.keys is used to extract the keys.
 * @param object The object to iterate
 * @param fn (value,key)=>{}
 */
function objectForEach(object, fn) {
    Object.keys(object).forEach(key => {
        fn(object[key],key, object)
    })
}

Hinweis: ich wechselte die callback-Parameter (value,key) und fügte ein drittes Objekt, um die API konsistente anderen APIs.

Verwenden Sie es wie diese

const o = {a:1, b:true};
objectForEach(o, (value, key, obj)=>{
    //do something
});

InformationsquelleAutor der Antwort Steven Spungin

var Dictionary = {
  If: {
    you: {
      can: '',
      make: ''
    },
    sense: ''
  },
  of: {
    the: {
      sentence: {
        it: '',
        worked: ''
      }
    }
  }
};

function Iterate(obj) {
  for (prop in obj) {
    if (obj.hasOwnProperty(prop) && isNaN(prop)) {
      console.log(prop + ': ' + obj[prop]);
      Iterate(obj[prop]);
    }
  }
}
Iterate(Dictionary);

InformationsquelleAutor der Antwort HovyTech

0

Kam ich endlich mit ein handliches Dienstprogramm-Funktion, mit der eine einheitliche Schnittstelle zum Durchlaufen der Objekte, Strings, Arrays, TypedArrays, Karten, Sets, (alle Iterables).
```
const iterate = require('@a-z/iterate-it');
const obj = { a: 1, b: 2, c: 3 };

iterate(obj, (value, key) => console.log(key, value)); 
//a 1
//b 2
//c 3
```
https://github.com/alrik/iterate-javascript

InformationsquelleAutor der Antwort Alrik Zachert

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.