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.