// 用 function* 定义生成器函数
function* stepGenerator() {
  yield '第一步：准备';
  yield '第二步：执行';
  return '第三步：完成'; // return 的值会作为最后一次 next() 的 value
}

// 调用生成器函数：不会立即执行，而是返回一个“生成器对象”（类似控制器）
const generator = stepGenerator();

// 调用 next() 恢复执行，直到遇到下一个 yield 或 return
console.log(generator.next().value); // 输出“第一步：准备”（执行到第一个 yield 暂停）
console.log(generator.next().value); // 输出“第二步：执行”（恢复后到第二个 yield 暂停）
console.log(generator.next().value); // 输出“第三步：完成”（恢复后执行到 return，生成器结束）

function* fruitGenerator() {
  yield '苹果'; // 暂停时，向外传“苹果”
  yield '香蕉'; // 再次暂停时，向外传“香蕉”
}

const gen = fruitGenerator();
console.log(gen.next().value); // 拿到“苹果”
console.log(gen.next().value); // 拿到“香蕉”

function* chatGenerator() {
  // 第一个 yield：向外传“你叫什么名字？”，暂停后等待外部传值
  const name = yield '你叫什么名字？';
  // 外部传值后，恢复执行：用收到的 name 拼接新内容，再向外传
  yield `你好，${name}！`;
}

const chat = chatGenerator();
// 第一次 next()：执行到第一个 yield，拿到“你叫什么名字？”
console.log(chat.next().value);
// 第二次 next('小明')：把“小明”传给上一个 yield，作为 name 的值，执行到第二个 yield
console.log(chat.next('小明').value); // 输出“你好，小明！”

function* wrongGenerator(items) {
  items.forEach(item => {
    // 错误：yield 不能在 forEach 的回调里用（超出了生成器函数的直接作用域）
    yield item + 1;
  });
}

// 生成 从 start 到 end、步长为 step 的数字
function* range(start, end, step = 1) {
  for (let i = start; i <= end; i += step) {
    yield i; // 每次迭代返回一个数字
  }
}

// 用 for...of 遍历生成器（生成器对象默认是可迭代的）
for (const num of range(1, 5, 2)) {
  console.log(num); // 输出 1、3、5
}

// 也可以用 [...gen] 转成数组
const numArray = [...range(2, 6)];
console.log(numArray); // 输出 [2, 3, 4, 5, 6]

// 生成无限的斐波那契数列
function* fibonacci() {
  let [prev, curr] = [0, 1];
  while (true) {
    // 无限循环，但不会卡，因为每次 yield 都会暂停
    yield curr; // 产出当前项
    [prev, curr] = [curr, prev + curr]; // 更新下一项
  }
}

const fib = fibonacci();
// 想要几项就调用几次 next()
console.log(fib.next().value); // 1
console.log(fib.next().value); // 1
console.log(fib.next().value); // 2
console.log(fib.next().value); // 3
console.log(fib.next().value); // 5
// 什么时候停，完全由外部控制

// 模拟两个异步请求
function fetchUser() {
  return new Promise((resolve) => setTimeout(() => resolve({ id: 1, name: '小明' }), 1000));
}
function fetchUserOrders(userId) {
  return new Promise((resolve) => setTimeout(() => resolve([{ id: 101, goods: '手机' }]), 1000));
}

// 用生成器管理异步流程
function* asyncFlow() {
  // 等待 fetchUser 完成，拿到用户数据
  const user = yield fetchUser();
  // 用用户 id 发起第二个请求，等待完成
  const orders = yield fetchUserOrders(user.id);
  // 返回最终结果
  return { user, orders };
}

// 自动执行器：帮我们调用 next()，不用手动处理异步
function runAsync(gen) {
  const generator = gen();

  // 递归处理异步结果
  function handleResult(result) {
    if (result.done) {
      // 生成器结束，返回最终结果
      return Promise.resolve(result.value);
    }
    // 结果是 Promise，等待完成后把数据传给下一个 next()
    return result.value.then((data) => handleResult(generator.next(data)));
  }

  return handleResult(generator.next());
}

// 执行异步流程
runAsync(asyncFlow).then((result) => {
  console.log('最终结果：', result);
  // 2秒后输出：{ user: { id:1, name:'小明' }, orders: [{ id:101, goods:'手机' }] }
});

// 交通灯状态机
function* trafficLight() {
  while (true) {
    yield '红灯：等待3秒';
    yield '绿灯：通行5秒';
    yield '黄灯：准备2秒';
  }
}

const light = trafficLight();
// 每次调用 next()，切换一次状态
console.log(light.next().value); // 红灯：等待3秒
console.log(light.next().value); // 绿灯：通行5秒
console.log(light.next().value); // 黄灯：准备2秒
console.log(light.next().value); // 红灯：等待3秒（循环）

// 生成器 A
function* generatorA() {
  yield 'A1';
  yield 'A2';
}

// 生成器 B：委托 generatorA 执行
function* generatorB() {
  yield 'B1';
  yield* generatorA(); // 委托：先把 generatorA 执行完
  yield 'B2';
}

// 遍历 generatorB，看看顺序
const result = [...generatorB()];
console.log(result); // 输出 ["B1", "A1", "A2", "B2"]

// 遍历树形结构（比如 DOM 树）
function* traverseTree(node) {
  yield node; // 先产出当前节点

  // 如果有子节点，递归委托遍历子节点
  if (node.children) {
    for (const child of node.children) {
      yield* traverseTree(child);
    }
  }
}

// 遍历 body 下的所有 DOM 节点
const bodyTree = document.body;
for (const node of traverseTree(bodyTree)) {
  console.log(node.tagName); // 依次输出 body、div、p、span 等标签名
}

function* resourceGenerator() {
  // 模拟获取资源（比如打开文件）
  const resource = openResource();

  try {
    yield '使用资源处理数据';
    yield '继续使用资源';
  } finally {
    // 无论生成器正常结束还是提前终止，都会执行这里
    closeResource(resource); // 释放资源
  }
}

const gen = resourceGenerator();
gen.next(); // 执行到第一个 yield
gen.return('提前结束'); // 提前终止，会触发 finally 里的 closeResource

// 安全的生成器：最多生成 100 个值
function* limitedGenerator() {
  let count = 0;
  while (count < 100) {
    // 终止条件：count 到 100 就停
    yield count++;
  }
}

function* errorHandleGenerator() {
  try {
    yield '正常执行中';
    yield '这一步可能出错';
  } catch (err) {
    // 捕获外部抛入的错误
    yield `捕获到错误：${err.message}`;
  }
}

const gen = errorHandleGenerator();
console.log(gen.next().value); // 输出“正常执行中”
// 向生成器抛错
console.log(gen.throw(new Error('测试错误')).value); // 输出“捕获到错误：测试错误”