1. Web
  2. JavaScript
  3. 参考
  4. 表达式和运算符
  5. yield*

yield*

Baseline 已广泛支持

此特性已非常成熟，可在多种设备和浏览器版本上使用。自 ⁨2016 年 9 月⁩以来，它已在各大浏览器中可用。

yield* 运算符可以在生成器（同步或异步）函数中使用，以将控制权委托给另一个可迭代对象，例如Generator。在异步生成器函数内部，它还可以用于将控制权委托给另一个异步可迭代对象，例如AsyncGenerator。

试一试

function* func1() {
  yield 42;
}

function* func2() {
  yield* func1();
}

const iterator = func2();

console.log(iterator.next().value);
// Expected output: 42

语法

js
yield* expression

参数

expression 可选

一个可迭代对象。

返回值

当迭代器关闭时（当 done 为 true 时），返回该迭代器返回的值。

描述

yield* 表达式会迭代操作数并生成它返回的每个值。它将当前生成器的迭代委托给底层迭代器——我们分别将其称为“生成器”和“迭代器”。yield* 首先通过调用操作数的 [Symbol.iterator]() 方法从操作数中获取迭代器。然后，每次调用生成器的 next() 方法时，yield* 都会调用迭代器的 next() 方法，传递生成器的 next() 方法接收到的参数（第一次调用始终为 undefined），并生成与迭代器的 next() 方法返回的结果对象相同的结果对象。如果迭代器结果的 done: true，则 yield* 表达式停止执行并返回该结果的 value。

yield* 运算符还将当前生成器的 throw() 和 return() 方法转发到底层迭代器。如果当前生成器通过这些方法之一提前关闭，底层迭代器将收到通知。如果调用生成器的 throw()/return() 方法，则以相同的参数调用底层迭代器的 throw()/return() 方法。throw()/return() 的返回值像 next() 方法的结果一样处理，如果该方法抛出异常，则异常从 yield* 表达式传播。

如果底层迭代器没有 return() 方法，yield* 表达式将变成一个 return 语句，就像在挂起的 yield 表达式上调用 return() 一样。

如果底层迭代器没有 throw() 方法，这将导致 yield* 抛出 TypeError —— 但在抛出错误之前，如果存在底层迭代器的 return() 方法，则会调用它。

示例

委托给另一个生成器

在以下代码中，g1() 生成的值从 next() 调用中返回，就像 g2() 生成的值一样。

js
function* g1() {
  yield 2;
  yield 3;
  yield 4;
}

function* g2() {
  yield 1;
  yield* g1();
  yield 5;
}

const gen = g2();

console.log(gen.next()); // {value: 1, done: false}
console.log(gen.next()); // {value: 2, done: false}
console.log(gen.next()); // {value: 3, done: false}
console.log(gen.next()); // {value: 4, done: false}
console.log(gen.next()); // {value: 5, done: false}
console.log(gen.next()); // {value: undefined, done: true}

其他可迭代对象

除了生成器对象，yield* 还可以 yield 其他类型的可迭代对象（例如，数组、字符串或 arguments 对象）。

js
function* g3(...args) {
  yield* [1, 2];
  yield* "34";
  yield* args;
}

const gen = g3(5, 6);

console.log(gen.next()); // {value: 1, done: false}
console.log(gen.next()); // {value: 2, done: false}
console.log(gen.next()); // {value: "3", done: false}
console.log(gen.next()); // {value: "4", done: false}
console.log(gen.next()); // {value: 5, done: false}
console.log(gen.next()); // {value: 6, done: false}
console.log(gen.next()); // {value: undefined, done: true}

yield* 表达式本身的值

yield* 是一个表达式，而不是一个语句，所以它会评估为一个值。

js
function* g4() {
  yield* [1, 2, 3];
  return "foo";
}

function* g5() {
  const g4ReturnValue = yield* g4();
  console.log(g4ReturnValue); // 'foo'
  return g4ReturnValue;
}

const gen = g5();

console.log(gen.next()); // {value: 1, done: false}
console.log(gen.next()); // {value: 2, done: false}
console.log(gen.next()); // {value: 3, done: false} done is false because g5 generator isn't finished, only g4
console.log(gen.next()); // {value: 'foo', done: true}

与异步生成器一起使用

js
async function* g1() {
  await Promise.resolve(0);
  yield "foo";
}

function* g2() {
  yield "bar";
}

async function* g3() {
  // Can use yield* on both async and sync iterators
  yield* g1();
  yield* g2();
}

const gen = g3();

console.log(await gen.next()); // {value: "foo", done: false}
console.log(await gen.next()); // {value: "bar", done: false}
console.log(await gen.next()); // {done: true}

方法转发

当前生成器的 next()、throw() 和 return() 方法都转发到底层迭代器。

js
const iterable = {
  [Symbol.iterator]() {
    let count = 0;
    return {
      next(v) {
        console.log("next called with", v);
        count++;
        return { value: count, done: false };
      },
      return(v) {
        console.log("return called with", v);
        return { value: "iterable return value", done: true };
      },
      throw(v) {
        console.log("throw called with", v);
        return { value: "iterable thrown value", done: true };
      },
    };
  },
};

function* gf() {
  yield* iterable;
  return "gf return value";
}

const gen = gf();
console.log(gen.next(10));
// next called with undefined; the argument of the first next() call is always ignored
// { value: 1, done: false }
console.log(gen.next(20));
// next called with 20
// { value: 2, done: false }
console.log(gen.return(30));
// return called with 30
// { value: 'iterable return value', done: true }
console.log(gen.next(40));
// { value: undefined, done: true }; gen is already closed

const gen2 = gf();
console.log(gen2.next(10));
// next called with undefined
// { value: 1, done: false }
console.log(gen2.throw(50));
// throw called with 50
// { value: 'gf return value', done: true }
console.log(gen.next(60));
// { value: undefined, done: true }; gen is already closed

如果底层迭代器的 return()/throw() 方法返回 done: false，则当前生成器继续执行，并且 yield* 继续委托给底层迭代器。

js
const iterable = {
  [Symbol.iterator]() {
    let count = 0;
    return {
      next(v) {
        console.log("next called with", v);
        count++;
        return { value: count, done: false };
      },
      return(v) {
        console.log("return called with", v);
        return { value: "iterable return value", done: false };
      },
    };
  },
};

function* gf() {
  yield* iterable;
  return "gf return value";
}

const gen = gf();
console.log(gen.next(10));
// next called with undefined
// { value: 1, done: false }
console.log(gen.return(20));
// return called with 20
// { value: 'iterable return value', done: false }
console.log(gen.next(30));
// { value: 2, done: false }; gen is not closed

如果底层迭代器没有 throw() 方法，并且调用了生成器的 throw()，则 yield* 会抛出错误。

js
const iterable = {
  [Symbol.iterator]() {
    let count = 0;
    return {
      next(v) {
        count++;
        return { value: count, done: false };
      },
    };
  },
};

function* gf() {
  yield* iterable;
  return "gf return value";
}

const gen = gf();
gen.next(); // First next() starts the yield* expression
gen.throw(20); // TypeError: The iterator does not provide a 'throw' method.

规范

规范
ECMAScript® 2026 语言规范
# sec-generator-function-definitions-runtime-semantics-evaluation

浏览器兼容性

另见

帮助改进 MDN

了解如何贡献

此页面最后由 MDN 贡献者 在 修改。

在 GitHub 上查看此页面 • 报告此内容的问题
© . Content available under a Creative Commons license.