为什么不能在 for of 循环中使用对象？或者这是一个浏览器错误？这段代码在 Chrome 42 中不起作用，说 undefined is not a function：
test = { first: "one"}
for(var item of test) {
console.log(item)
}
【问题讨论】：
标签： javascript for-loop ecmascript-6 iterable
【讨论】：
.iterable 成员函数，当您尝试在一个对象（没有它）上使用它时，就会出现错误。 developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
if (test.hasOwnProperty(key)){ ... }？还是不需要？
您可以使用以下语法：
const myObject = {
first: "one",
second: "two",
};
for (const [key, value] of Object.entries(myObject)) {
console.log(key, value); // first one, second two
}但是，Object.entries 目前的支持很差 在 IE 或 iOS Safari 中不起作用。您可能可能需要一个 polyfill。最新消息见https://caniuse.com/mdn-javascript_builtins_object_entries。
另请参见 Object.keys 仅迭代键，或 Object.values 仅迭代值。
【讨论】：
如果您将数据存储在键值存储中，please use Map 专门为此目的而设计。
如果你必须使用一个对象，ES2017 (ES8) 允许你使用Object.values:
const foo = { a: 'foo', z: 'bar', m: 'baz' };
for (let value of Object.values(foo)) {
console.log(value);
}
如果还不支持，请使用 polyfill：Alternative version for Object.values()
最后，如果您支持不支持此语法的旧环境，您将不得不使用forEach 和Object.keys：
var obj = { a: 'foo', z: 'bar', m: 'baz' };
Object.keys(obj).forEach(function (prop) {
var value = obj[prop];
console.log(value);
});
【讨论】：
Object.entries 可以在不接触原型的情况下进行填充。
for-in 有什么好处吗？
ECMAScript 2015/ES6 中的迭代器、可迭代和 for..of 循环
let tempArray = [1,2,3,4,5];
for(element of tempArray) {
console.log(element);
}
// 1
// 2
// 3
// 4
// 5
但如果我们这样做
let tempObj = {a:1, b:2, c:3};
for(element of tempObj) {
console.log(element);
}
// error
我们得到错误是因为 for..of 循环仅适用于 Iterables，即具有 @@iterator 的对象遵守 Iterator 协议，这意味着它必须有一个带有 next 方法的对象。下一个方法不带参数，它应该返回一个具有这两个属性的对象。
done：当为真时表示序列已经结束，假表示可能有更多的值 值：这是序列中的当前项
因此，要使对象 Iterable 与 for..of 一起工作，我们可以：
1 . 通过 Symbol.iterator 属性为对象分配神秘的 @@iterator 属性，使对象成为 Iterable。以下是如何：
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.使用Object.entries，返回一个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.使用Object.keys，方法如下：
let tempObj = {a:1, b:2, c:3};
for (let key of Object.keys(tempObj)) {
console.log(key);
}
// a
// b
// c
希望对你有帮助！！！！！！
【讨论】：
我用这段代码使对象可迭代：
Object.prototype[Symbol.iterator] = function*() {
for(let key of Object.keys(this)) {
yield([ key, this[key] ])
} }
用法：
for(let [ key, value ] of {}) { }
或者：
for(let [ key, value ] of Object.entries({})) { }
【讨论】：
答案是否定的。不可能将 For..Of 与 Object 字面量一起使用。
我同意 Overv 的观点，即 For..Of 仅适用于可迭代对象。 我有完全相同的问题，因为我使用对象通过 for..in 迭代键和值。但我刚刚意识到这就是 ES6 MAPS 和 SETS 的用途。
let test = new Map();
test.set('first', "one");
test.set('second', "two");
for(var item of test) {
console.log(item); // "one" "two"
}
因此它实现了不必使用 for..In（通过 hasOwnProperty 验证）和不必使用 Object.keys() 的目标。
此外，您的键不限于字符串。您可以使用数字、对象或其他文字。
【讨论】：
对象字面量没有内置的迭代器，这是使用for...of 循环所必需的。但是，如果您不想麻烦地将自己的[Symbol.iterator] 添加到您的对象中，您可以简单地使用Object.keys() 方法。此方法返回一个 Array 对象，该对象已经具有内置迭代器，因此您可以将其与 for...of 循环一起使用，如下所示：
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
【讨论】：
可以在任何给定对象上定义迭代器，这样您就可以为每个对象放置不同的逻辑
var x = { a: 1, b: 2, c: 3 }
x[Symbol.iterator] = function* (){
yield 1;
yield 'foo';
yield 'last'
}
那就直接迭代x
for (let i in x){
console.log(i);
}
//1
//foo
//last
可以在Object.prototype 对象上做同样的事情，并为所有对象提供一个通用迭代器
Object.prototype[Symbol.iterator] = function*() {
for(let key of Object.keys(this)) {
yield key
}
}
然后像这样迭代你的对象
var t = {a :'foo', b : 'bar'}
for(let i of t){
console.log(t[i]);
}
或者这样
var it = t[Symbol.iterator](), p;
while(p = it.next().value){
console.log(t[p])
}
【讨论】：
我只是做了以下事情来轻松解决我的问题。
for (let key in obj) {
if(obj.hasOwnProperty(key){
console.log(`${key}: ${obj[key]}`);
}
}
【讨论】：
使用Object.keys 来获取键数组怎么样？然后forEach on the Array?
obj = { a: 1, b:2}
Object.keys(obj).forEach( key => console.log(`${key} => ${obj[key]}`))
【讨论】：
如何使用
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);
}
【讨论】：
在 ES6 中你可以使用生成器：
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}
Here is the jsfiddle.
在输出中，您将获得一个带有 "value" 和 "done" 键的对象。 "Value" 包含您想要它拥有的所有内容，"done" 是布尔迭代的当前状态。
【讨论】：
使用 Array Destruction 您可以使用 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"
});
【讨论】：