JavaScript中异步迭代的实现方式

async function* createDelayedNumbers() {
    console.log('开始生成数字...');
    for (let i = 0; i < 3; i++) {
        await new Promise(resolve => setTimeout(resolve, 1000)); // 模拟异步操作，等待1秒
        yield i; // 异步地“产出”一个值
        console.log(`生成了数字: ${i}`);
    }
    console.log('数字生成完毕。');
}

async function processNumbers() {
    console.log('准备开始遍历异步数字...');
    for await (const num of createDelayedNumbers()) {
        console.log(`在循环中接收到: ${num}`);
    }
    console.log('所有数字都处理完了。');
}

// 调用示例
// processNumbers();
/*
输出大概是这样：
准备开始遍历异步数字...
开始生成数字...
(等待1秒)
生成了数字: 0
在循环中接收到: 0
(等待1秒)
生成了数字: 1
在循环中接收到: 1
(等待1秒)
生成了数字: 2
在循环中接收到: 2
数字生成完毕。
所有数字都处理完了。
*/

const manualAsyncIterable = {
    data: ['Apple', 'Banana', 'Cherry'],
    currentIndex: 0,
    async next() {
        if (this.currentIndex < this.data.length) {
            await new Promise(resolve => setTimeout(resolve, 500)); // 模拟延迟
            return { value: this.data[this.currentIndex++], done: false };
        } else {
            return { value: undefined, done: true };
        }
    },
    // 关键：实现Symbol.asyncIterator方法，返回自身（因为自身就是迭代器）
    [Symbol.asyncIterator]() {
        return this;
    }
};

async function testManualAsyncIterable() {
    console.log('开始手动异步迭代...');
    for await (const item of manualAsyncIterable) {
        console.log(`手动接收到: ${item}`);
    }
    console.log('手动异步迭代完成。');
}

// testManualAsyncIterable();

async function fetchUsers(page = 1) {
    console.log(`Fetching users from page ${page}...`);
    await new Promise(resolve => setTimeout(resolve, 500)); // Simulate network delay
    if (page > 3) {
        return { users: [], hasNext: false };
    }
    const users = Array.from({ length: 2 }, (_, i) => `User-${(page - 1) * 2 + i + 1}`);
    return { users, hasNext: page < 3 };
}

async function* getAllUsers() {
    let currentPage = 1;
    let hasNextPage = true;
    while (hasNextPage) {
        const { users, hasNext } = await fetchUsers(currentPage);
        for (const user of users) {
            yield user; // 产出每个用户
        }
        hasNextPage = hasNext;
        currentPage++;
    }
}

async function processAllUsers() {
    console.log('开始获取所有用户...');
    for await (const user of getAllUsers()) {
        console.log(`处理用户: ${user}`);
        if (user === 'User-4') {
            console.log('找到User-4，提前停止！');
            break; // 即使还有数据，也会停止并清理
        }
    }
    console.log('用户处理完成。');
}

// processAllUsers();

async function* unreliableDataStream() {
    yield 1;
    await new Promise(resolve => setTimeout(resolve, 500));
    if (Math.random() > 0.5) { // 模拟50%的几率出错
        throw new Error('模拟数据流中断错误！');
    }
    yield 2;
    await new Promise(resolve => setTimeout(resolve, 500));
    yield 3;
}

async function consumeUnreliableStream() {
    console.log('开始消费不可靠数据流...');
    try {
        for await (const data of unreliableDataStream()) {
            console.log(`接收到数据: ${data}`);
        }
        console.log('数据流消费完毕。');
    } catch (error) {
        console.error(`在消费过程中捕获到错误: ${error.message}`);
    }
    console.log('流处理流程结束。');
}

// consumeUnreliableStream();

async function* resourceIntensiveGenerator() {
    let resource = null;
    try {
        console.log('生成器：尝试打开资源...');
        resource = 'Opened_DB_Connection'; // 模拟打开资源
        await new Promise(r => setTimeout(r, 300));
        yield 'DataChunk A';
        await new Promise(r => setTimeout(r, 300));
        yield 'DataChunk B';
        await new Promise(r => setTimeout(r, 300));
        yield 'DataChunk C';
    } finally {
        if (resource) {
            console.log(`生成器：正在关闭资源: ${resource}`);
            // 模拟异步关闭资源
            await new Promise(r => setTimeout(r, 200));
            console.log('生成器：资源已关闭。');
        }
    }
}

async function testEarlyExit() {
    console.log('测试提前退出...');
    for await (const chunk of resourceIntensiveGenerator()) {
        console.log(`处理数据块: ${chunk}`);
        if (chunk === 'DataChunk B') {
            console.log('发现特定数据块，提前中断循环！');
            break; // 触发生成器的finally块
        }
    }
    console.log('循环已中断，流程继续。');
}

// testEarlyExit();