index - javascript foreach

Itérateur, Itérable et pour .. de la boucle dans ECMAScript 2015 / ES6

let tempArray = [1,2,3,4,5];

for(element of tempArray) {
  console.log(element);
}

// 1
// 2
// 3
// 4
// 5

Mais si nous faisons

let tempObj = {a:1, b:2, c:3};

for(element of tempObj) {
   console.log(element);
}
// error

Nous obtenons une erreur car for..of ne fonctionne que sur Iterables , c'est-à-dire l'objet qui possède un itérateur @@ qui respecte le protocole Iterator , ce qui signifie qu'il doit avoir un objet avec une méthode next . La méthode suivante ne prend aucun argument et devrait renvoyer un objet avec ces deux propriétés.

done : indique que la séquence est terminée quand true et false signifie qu'il peut y avoir plus de valeurs value : il s'agit de l'élément en cours dans la séquence

Donc, pour faire un objet itérable, c’est le faire fonctionner pour, on peut:

1. Créez un objet un Iterable en lui attribuant sa propriété mystique @@ iterator via la propriété Symbol.iterator . Voici comment:

let tempObj = {a:1, b:2, c:3};

tempObj[Symbol.iterator]= () => ({
next: function next () {
return {
    done: Object.keys(this).length === 0,
    value: Object.keys(this).shift()
     }
    }
  })

for(key in tempObj){
 console.log(key)
}
// a
// b
// c

2. Utilisez Object.entries , qui renvoie un Iterable :

let tempObj = {a:1, b:2, c:3};

for(let [key, value] of Object.entries(tempObj)) {
    console.log(key, value);
}
// a 1
// b 2
// c 3

3.Utilisez Object.keys , voici comment:

let tempObj = {a:1, b:2, c:3};
for (let key of Object.keys(tempObj)) {
    console.log(key);
}

// a
// b
// c

J'espère que cela t'aides!!!!!!

À l'aide de la destruction de forEach vous pouvez l'itérer comme suit en utilisant forEach

const obj = { a: 5, b: 7, c: 9 };

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

J'ai créé des objets itérables avec ce code:

Object.prototype[Symbol.iterator] = function*() {
 for(let key of Object.keys(this)) {
  yield([ key, this[key] ])
} }

Usage:

for(let [ key, value ] of {}) { }

Alternativement:

for(let [ key, value ] of Object.entries({})) { }

Je viens de faire ce qui suit pour consoler facilement mes affaires.

for (let key in obj) {
  if(obj.hasOwnProperty(key){
    console.log(`${key}: ${obj[key]}`);
  }
}

La réponse est non. Il n'est pas possible d'utiliser For..Of avec des littéraux d'objet.

Je suis d'accord avec Overv que For..Of est uniquement pour iterables. J'avais exactement la même question parce que j'utilise des objets pour parcourir des clés et des valeurs avec for..in. Mais je viens de me rendre compte que c’est à cela que servent ES6 MAPS et Set .

let test = new Map();
test.set('first', "one");
test.set('second', "two");

for(var item of test) {
  console.log(item); // "one" "two"
}

Par conséquent, l'objectif est de ne pas avoir à utiliser for..In (validation avec hasOwnProperty ) et de ne pas utiliser Object.keys ().

De plus, vos clés ne sont pas limitées à des chaînes. Vous pouvez utiliser des nombres, des objets ou d'autres littéraux.

Les littéraux d'objet ne possèdent pas d'itérateurs intégrés, qui sont nécessaires pour travailler avec for...of boucles. Toutefois, si vous ne souhaitez pas ajouter votre propre [Symbol.iterator] à votre objet, vous pouvez simplement utiliser la méthode Object.keys() . Cette méthode retourne un objet Array , qui a déjà un itérateur intégré, vous pouvez donc l'utiliser avec une boucle for...of comme ceci:

const myObject = {
    country: "Canada",
    province: "Quebec",
    city: "Montreal"
}

for (let i of Object.keys(myObject)) {
    console.log("Key:", i, "| Value:", myObject[i]);
}

//Key: country | Value: Canada
//Key: province | Value: Quebec
//Key: city | Value: Montreal

Pourquoi ne pas utiliser Object.keys pour obtenir un tableau de clés? Et ensuite pour Array ?

obj = { a: 1, b:2}
Object.keys(obj).forEach( key => console.log(`${key} => ${obj[key]}`))

Qu'en est-il d'utiliser

function* entries(obj) {
    for (let key of Object.keys(obj)) {
        yield [key, obj[key]];
    }
}

for ([key, value] of entries({a: "1", b: "2"})) {
    console.log(key + " " + value);
}

Vous pouvez utiliser cette syntaxe:

const foo = { a: 'foo', z: 'bar', m: 'baz' };
for (let value of Object.values(foo)) {
    console.log(value);
}

Cependant, Object.entries a un faible soutien en ce moment ne fonctionne pas dans IE ou iOS Safari . Vous allez Probablement pourrait avoir besoin d'un polyfill.

dans ES6, vous pouvez utiliser un générateur:

var obj = {1: 'a', 2: 'b'};

function* entries(obj) {
  for (let key of Object.keys(obj)) {
    yield [key, obj[key]];
  }
}

let generator = entries(obj);

let step1 = generator.next();
let step2 = generator.next();
let step3 = generator.next();

console.log(JSON.stringify(step1)); // {"value":["1","a"],"done":false}
console.log(JSON.stringify(step2)); // {"value":["2","b"],"done":false}
console.log(JSON.stringify(step3)); // {"done":true}

Voici le jsfiddle. Dans la sortie, vous obtiendrez un objet avec les touches "value" et "done" . "Value" contient tout ce que vous voulez et "done" est l'état actuel de l'itération en bool.