Firestore嵌套集合遍历中Promise.all/async/await无法等待异步完成

你的核心问题在于没有正确等待嵌套的异步操作完成，不管是Promise.all版本还是async/await版本，都因为遍历方式的问题导致函数提前结束。

原版本错误原因 #

1. Promise.all版本的问题 #

• 你定义了let promises = []，但内部却错误地使用了writePromises.push(write)（变量名不匹配）；即使修正变量名，外层的Promise.all(promises)也会在所有get()异步操作完成前执行——因为database.collection("users").get()是异步的，它的then回调要等到后续才会执行，此时外层的Promise.all拿到的还是空数组，直接resolve，导致提前输出"finished"。
• 嵌套的then回调中的Promise根本没被收集到外层的promises数组里，因为这些回调的执行时机晚于外层Promise.all的调用。

2. async/await版本的问题 #

• forEach不支持异步函数的等待：当你用users.forEach(async (user) => { ... })时，forEach会同步遍历所有用户，立即调用每个async回调，但它不会等待这些async函数执行完成，所以外层的console.log("finished")会直接运行，而内部的await操作还在后台处理。
• 内层的projects.forEach、subProjects.forEach也存在同样的问题，async回调的执行不会被等待。

正确的解决方案 #

我们需要用支持异步等待的遍历方式（比如for...of），或者通过map生成Promise数组后用Promise.all等待所有并行操作完成。下面是两种可行的优化方案：

方案一：并行处理所有写入操作（效率更高） #

这种方式会把所有写入操作的Promise收集起来，最后统一等待完成，适合不需要严格串行处理用户/项目的场景：

async function test() {
    console.log("prepare() called ...");
    const database = admin.firestore();
    const allWritePromises = [];

    // 获取所有用户
    const usersSnapshot = await database.collection("users").get();
    
    // 遍历每个用户
    for (const userDoc of usersSnapshot.docs) {
        const userId = userDoc.data().userId;
        // 获取当前用户的所有项目
        const projectsSnapshot = await database
            .collection("users")
            .doc(userId)
            .collection("projects")
            .get();
        
        // 遍历每个项目
        for (const projectDoc of projectsSnapshot.docs) {
            const projectId = projectDoc.data().projectId;
            // 获取当前项目的所有子项目
            const subProjectsSnapshot = await database
                .collection("users")
                .doc(userId)
                .collection("projects")
                .doc(projectId)
                .collection("subProjects")
                .get();
            
            // 遍历每个子项目的关键词，收集写入Promise
            for (const subProjectDoc of subProjectsSnapshot.docs) {
                const keywords = subProjectDoc.data().keywords;
                keywords.forEach(keyword => {
                    const unreadyJob = { keyword };
                    allWritePromises.push(writeJobsToBackLog(unreadyJob));
                });
            }
        }
    }

    // 等待所有写入操作完成
    await Promise.all(allWritePromises);
    console.log("finished");
}

function writeJobsToBackLog(unreadyJob) {
    console.log("writing job to Backlog ...");
    const database = admin.firestore();
    return database
        .collection("backLog")
        .doc()
        .set(unreadyJob);
}

方案二：按层级并行处理（更可控） #

如果你需要确保每个用户/项目的操作完成后再处理下一个，可以用map生成各层级的Promise数组，再用Promise.all等待：

async function test() {
    console.log("prepare() called ...");
    const database = admin.firestore();

    // 获取所有用户
    const usersSnapshot = await database.collection("users").get();
    
    // 收集所有用户处理的Promise
    const userPromises = usersSnapshot.docs.map(async (userDoc) => {
        const userId = userDoc.data().userId;
        // 获取当前用户的所有项目
        const projectsSnapshot = await database
            .collection("users")
            .doc(userId)
            .collection("projects")
            .get();
        
        // 收集所有项目处理的Promise
        const projectPromises = projectsSnapshot.docs.map(async (projectDoc) => {
            const projectId = projectDoc.data().projectId;
            // 获取当前项目的所有子项目
            const subProjectsSnapshot = await database
                .collection("users")
                .doc(userId)
                .collection("projects")
                .doc(projectId)
                .collection("subProjects")
                .get();
            
            // 收集所有关键词写入的Promise
            const keywordPromises = [];
            for (const subProjectDoc of subProjectsSnapshot.docs) {
                const keywords = subProjectDoc.data().keywords;
                keywords.forEach(keyword => {
                    const unreadyJob = { keyword };
                    keywordPromises.push(writeJobsToBackLog(unreadyJob));
                });
            }
            // 等待当前项目下所有写入完成
            await Promise.all(keywordPromises);
        });
        
        // 等待当前用户下所有项目处理完成
        await Promise.all(projectPromises);
    });

    // 等待所有用户处理完成
    await Promise.all(userPromises);
    console.log("finished");
}

function writeJobsToBackLog(unreadyJob) {
    console.log("writing job to Backlog ...");
    const database = admin.firestore();
    return database
        .collection("backLog")
        .doc()
        .set(unreadyJob);
}

这两种方案都能确保所有查询和写入操作完成后，才会输出"finished"，解决你遇到的顺序问题。

内容的提问来源于stack exchange，提问作者felixmp