Il est intéressant que les personnes dans ces réponses aient abordé les deux Object.keys()
et for...of
ne les aient jamais combinées:
var map = {well:'hello', there:'!'};
for (let key of Object.keys(map))
console.log(key + ':' + map[key]);
Vous ne pouvez pas juste for...of
un Object
parce que ce n'est pas un itérateur, et for...index
ou .forEach()
ing Object.keys()
est laid / inefficace.
Je suis content que la plupart des gens s'abstiennent for...in
(avec ou sans vérification .hasOwnProperty()
) car c'est aussi un peu compliqué, donc à part ma réponse ci-dessus, je suis ici pour dire ...
Vous pouvez faire itérer les associations d'objets ordinaires! Se Map
comporter comme des s avec une utilisation directe du for...of
DEMO sophistiqué fonctionnant dans Chrome et FF (je suppose que ES6 uniquement)
var ordinaryObject = {well:'hello', there:'!'};
for (let pair of ordinaryObject)
//key:value
console.log(pair[0] + ':' + pair[1]);
//or
for (let [key, value] of ordinaryObject)
console.log(key + ':' + value);
Tant que vous incluez ma cale ci-dessous:
//makes all objects iterable just like Maps!!! YAY
//iterates over Object.keys() (which already ignores prototype chain for us)
Object.prototype[Symbol.iterator] = function() {
var keys = Object.keys(this)[Symbol.iterator]();
var obj = this;
var output;
return {next:function() {
if (!(output = keys.next()).done)
output.value = [output.value, obj[output.value]];
return output;
}};
};
Sans avoir à créer un véritable objet Map qui n'a pas le bon sucre syntaxique.
var trueMap = new Map([['well', 'hello'], ['there', '!']]);
for (let pair of trueMap)
console.log(pair[0] + ':' + pair[1]);
En fait, avec ce shim, si vous vouliez toujours profiter des autres fonctionnalités de Map (sans les caler toutes), mais vouliez toujours utiliser la notation d'objet soignée, puisque les objets sont maintenant itérables, vous pouvez maintenant simplement en faire une Map!
//shown in demo
var realMap = new Map({well:'hello', there:'!'});
Pour ceux qui n'aiment pas faire de shim, ou jouer avec prototype
en général, n'hésitez pas à faire la fonction sur la fenêtre à la place, en l'appelant quelque chose comme ça getObjIterator()
;
//no prototype manipulation
function getObjIterator(obj) {
//create a dummy object instead of adding functionality to all objects
var iterator = new Object();
//give it what the shim does but as its own local property
iterator[Symbol.iterator] = function() {
var keys = Object.keys(obj)[Symbol.iterator]();
var output;
return {next:function() {
if (!(output = keys.next()).done)
output.value = [output.value, obj[output.value]];
return output;
}};
};
return iterator;
}
Maintenant, vous pouvez simplement l'appeler comme une fonction ordinaire, rien d'autre n'est affecté
var realMap = new Map(getObjIterator({well:'hello', there:'!'}))
ou
for (let pair of getObjIterator(ordinaryObject))
Il n'y a aucune raison pour que cela ne fonctionne pas.
Bienvenue dans le futur.