JavaScript 中的Promise 和async 迭代通過異步生成器簡化了異步操作管理。 Promise 表示異步操作的最終完成或失敗，通過resolve 和reject 處理成功或錯誤狀態(tài)。 1. Async 函數(shù)自動返回Promise，使用await 關(guān)鍵字可暫停執(zhí)行直至Promise 解決，從而簡化異步代碼。 2. 異步生成器通過yield 返回Promise，並可使用for await...of 異步迭代，適用於處理流式API 響應(yīng)、大文件分塊讀取和實時數(shù)據(jù)源。 3. 實際應(yīng)用中，如分頁API 數(shù)據(jù)拉取，可通過async 生成器實現(xiàn)低內(nèi)存消耗和清晰邏輯的數(shù)據(jù)處理流程。正確使用async function* 和for await...of 是關(guān)鍵，同時需妥善處理錯誤。

Promises and async iteration are two powerful features in modern JavaScript that help manage asynchronous operations more cleanly. When combined with async generators, they allow you to work with streams of asynchronous data in a more readable and maintainable way.

Understanding Promises

A Promise is an object representing the eventual completion or failure of an asynchronous operation. It's one of the foundational tools for handling async code in JavaScript.

Here's how a basic Promise looks:

 const myPromise = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve("Done!");
  }, 1000);
});

You can consume it like this:

 myPromise.then(result => console.log(result));

• Pending : Initial state, not fulfilled or rejected.
• Fulfilled : Operation completed successfully.
• Rejected : Operation failed.

Most developers encounter Promises when working with APIs, timers, or file reading — anything that doesn't complete immediately.

One thing to remember: chaining .then() and .catch() properly is key to avoiding unhandled rejections.

Async Functions Simplify Promise Handling

Async functions automatically return Promises, making it easier to write asynchronous code that looks synchronous.

For example:

 async function fetchData() {
  const response = await fetch('https://api.example.com/data');
  const data = await response.json();
  return data;
}

This is much cleaner than nested .then() calls. The await keyword pauses execution until the Promise resolves, which helps reduce callback complexity.

But what if you need to process multiple asynchronous results over time? That's where async iteration comes in.

Async Iteration and Async Generators

JavaScript introduced async iteration to handle sequences of asynchronous values. An async generator is a function that yields Promises and can be iterated asynchronously using for await...of .

Here's a basic async generator:

 async function* generateSequence() {
  yield Promise.resolve(1);
  yield new Promise(resolve => setTimeout(resolve, 1000, 2));
  yield Promise.resolve(3);
}

You can loop through its results like this:

 for await (const item of generateSequence()) {
  console.log(item);
}

This will log 1, wait a second, then log 2, then 3. This pattern is especially useful when dealing with:

• Streaming API responses
• Reading large files chunk by chunk
• Real-time data sources

An important detail: your generator must be declared with async function* , not just function* . Also, the consumer must use for await...of to correctly handle each yielded Promise.

Practical Use Cases

Let's say you're building a data processing pipeline that needs to pull records from a paginated API. Instead of manually managing page tokens and recursion, you can use an async generator:

 async function* fetchAllPages(url) {
  let hasNext = true;
  while (hasNext) {
    const res = await fetch(url); // Simplified for example
    const data = await res.json();
    yield* data.items;

    hasNext = data.hasNext;
    url = data.nextPageUrl;
  }
}

Then later:

 for await (const record of fetchAllPages('https://api.example.com/endpoint')) {
  console.log(record);
}

This keeps memory usage low and logic clean, even for very large datasets.

Of course, error handling still matters. Wrap your await and yield statements in try/catch blocks or handle them at the consumer level.

基本上就這些。 Async generators aren't used every day, but when you need to iterate over asynchronous values cleanly, they're incredibly handy.

以上是JavaScript承諾和異步發(fā)電機的異步迭代的詳細內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！