JavaScript 编程学习的异步迭代器与生成器

xiaoshi 05-30 11 抢沙发

默认

摘要： ...

JavaScript异步迭代器与生成器：掌握现代异步编程的核心

为什么需要异步迭代器？

在JavaScript的世界里，处理异步操作一直是开发者面临的挑战。传统的回调函数虽然简单，但容易导致"回调地狱"；Promise改善了代码结构，但对于处理异步数据流仍显不足；async/await让异步代码看起来像同步代码，提高了可读性。而异步迭代器和生成器则是这一演进的下一步，它们为处理异步数据流提供了更优雅的解决方案。

想象一下，你需要从远程API分页获取数据，或者逐行读取一个大文件，又或者监听WebSocket的实时消息。这些场景都涉及到异步数据流，而异步迭代器正是为此而生。

异步迭代器基础

异步迭代器是一种特殊对象，它实现了异步迭代协议。简单来说，它提供了一个next()方法，这个方法返回一个Promise，该Promise解析为一个包含value和done属性的对象。

const asyncIterable = {
  [Symbol.asyncIterator]() {
    let i = 0;
    return {
      next() {
        if (i < 3) {
          return Promise.resolve({ value: i++, done: false });
        }
        return Promise.resolve({ done: true });
      }
    };
  }
};

使用for await...of循环可以方便地消费异步迭代器：

(async function() {
  for await (const item of asyncIterable) {
    console.log(item); // 依次输出0, 1, 2
  }
})();

异步生成器函数

异步生成器函数是创建异步迭代器的更简洁方式。通过在普通函数前加上async function*关键字，我们可以定义一个异步生成器函数。

async function* asyncGenerator() {
  let i = 0;
  while (i < 3) {
    // 可以在这里await其他Promise
    await new Promise(resolve => setTimeout(resolve, 100));
    yield i++;
  }
}

使用示例：

(async function() {
  for await (const num of asyncGenerator()) {
    console.log(num); // 依次输出0, 1, 2，每次间隔100ms
  }
})();

实际应用场景

分页API调用

处理分页API是异步迭代器的典型用例：

async function* fetchPaginatedData(url) {
  let nextUrl = url;
  while (nextUrl) {
    const response = await fetch(nextUrl);
    const data = await response.json();
    yield data.items;
    nextUrl = data.nextPage;
  }
}

大文件逐行处理

Node.js中的readline模块利用异步迭代器处理大文件：

const fs = require('fs');
const readline = require('readline');

async function processFile(filePath) {
  const fileStream = fs.createReadStream(filePath);
  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    console.log(`Line: ${line}`);
    // 处理每一行
  }
}

WebSocket消息监听

async function* listenWebSocket(url) {
  const ws = new WebSocket(url);
  try {
    while (true) {
      const message = await new Promise(resolve => {
        ws.onmessage = event => resolve(event.data);
      });
      yield message;
    }
  } finally {
    ws.close();
  }
}

高级技巧与最佳实践

错误处理

异步迭代器的错误处理需要特别注意：

async function* safeAsyncGenerator() {
  try {
    yield 1;
    yield 2;
    throw new Error('Something went wrong');
    yield 3; // 不会执行
  } catch (error) {
    console.error('Generator caught:', error);
    yield 'recovery value';
  } finally {
    console.log('Generator cleaning up');
  }
}

(async () => {
  try {
    for await (const val of safeAsyncGenerator()) {
      console.log(val);
    }
  } catch (err) {
    console.error('Loop caught:', err);
  }
})();

组合异步迭代器

你可以创建实用函数来组合多个异步迭代器：

async function* mergeAsyncIterables(...iterables) {
  const asyncIterators = iterables.map(iterable => iterable[Symbol.asyncIterator]());
  const results = [];

  while (asyncIterators.length > 0) {
    for (let i = 0; i < asyncIterators.length; i++) {
      const result = await asyncIterators[i].next();
      if (result.done) {
        asyncIterators.splice(i, 1);
        i--;
      } else {
        yield result.value;
      }
    }
  }
}