可迭代对象是实现了[Symbol.iterator]()方法且返回符合迭代器协议对象的对象；判断方式是检查该方法是否存在并能返回有效迭代器。

迭代器就是带 next() 方法的对象，调用它返回 { value, done }；可迭代对象则是实现了 [Symbol.iterator]() 方法、能被 for...of、解构、Array.from() 等直接消费的对象。

怎么判断一个对象是不是可迭代对象？

最直接的办法：看它有没有 [Symbol.iterator] 方法，且调用后返回一个符合迭代器协议的对象。

• 数组、字符串、Map、Set、TypedArray、arguments、NodeList 都是原生可迭代对象
• 普通对象（如 { a: 1 }）默认不是——除非你手动加了 [Symbol.iterator]
• 函数本身不是可迭代对象，但函数的 arguments 是；箭头函数没有 arguments，所以它的 arguments 不可用

const arr = [1, 2, 3];
console.log(typeof arr[Symbol.iterator]); // "function"
const obj = { a: 1 };
console.log(obj[Symbol.iterator]); // undefined
// ✅ 手动让它可迭代
obj[Symbol.iterator] = function* () {
yield this.a;
};
for (const v of obj) console.log(v); // 1

为什么 next() 返回的 done: true 后还要继续返回？

这是协议硬性要求：一旦 done 变为 true，后续所有 next() 调用都必须返回 { done: true, value: undefined }（或自定义 value，但 done 必须为 true）。否则 for...of 或 Array.from() 可能无限循环或报错。

• 常见错误：忘记在越界后固定返回 done: true，导致 next() 一直返回 { done: false, value: undefined }
• value 在 done: true 时是可选的，但建议显式设为 undefined，避免误传残留值
• 不实现 return() 方法没关系，它是可选的，仅在 break / return 提前退出时被调用

const badIterator = {
  next() {
    return { done: true }; // ❌ 缺少 value，某些环境可能容忍，但不规范
  }
};
const goodIterator = {
next() {
return { done: true, value: undefined }; // ✅ 明确、安全
}
};

哪些内置类型是可迭代对象？哪些容易被误认为是？

ES6+ 规范明确列出的可迭代内置类型有：Array、String、Map、Set、TypedArray（如 Uint8Array）、arguments、NodeList。注意：

• Object（普通对象）不是可迭代对象，哪怕它有键值对——这是最常踩的坑
• JSON.parse('{ "a": 1 }') 返回的是普通对象，不可直接 for...of
• Promise 不是可迭代对象，Promise.all() 接收的是可迭代对象（如数组），不是 Promise 本身
• GeneratorFunction（如 function* f(){}）不是可迭代对象，但调用它返回的生成器对象（f()）是可迭代对象 + 迭代器（即“迭代器也是可迭代对象”）

自定义可迭代对象时，状态管理最容易出错在哪？

核心陷阱：迭代器对象和可迭代对象共享状态（比如闭包里的 index），但多个迭代器实例之间不能互相污染。如果你把 index 放在可迭代对象上，而不是每次调用 [Symbol.iterator] 时新建一个闭包，就会出问题。

• 错误写法：this.index 被所有迭代器共用 → 第二个 for...of 循环直接从中间开始
• 正确做法：每次 [Symbol.iterator] 返回**新创建的迭代器对象**，内部状态独立
• 生成器（function*）天然规避这个问题，因为每次调用都产生全新迭代器

const counter = {
  from: 1,
  to: 3,
  // ❌ 错误：index 是共享的
  index: 0,
  [Symbol.iterator]() {
    return {
      next: () => {
        if (this.index < this.to) {
          return { value: this.from + this.index++, done: false };
        }
        return { done: true };
      }
    };
  }
};
// ✅ 正确：状态隔离
const safeCounter = {
from: 1,
to: 3,
[Symbol.iterator]() {
let i = 0; // 每次调用都新建
return {
next: () => {
if (i < this.to) {
return { value: this.from + i++, done: false };
}
return { done: true, value: undefined };
}
};
}
};

别只盯着“能不能遍历”，先想清楚“谁持有状态、谁负责重置”。可迭代对象是工厂，迭代器是流水线上的单次工位——工位不能记住上一批货的位置。