嵌套 Promise.all 异步/等待 map

Question

I encountered a nested for loop with await operations inside them like below:

    async handleProjects (projects) {
        for (let i = 0; i < projects.rows.length; i++) {
            projects.rows[i].owner = await this.userProvider.serialize(projects.rows[i].owner);
            for (let j = 0; j < projects.rows[i].collaborators.length; j++) {
                const collaborator = await this.userProvider.serialize(projects.rows[i].collaborators[j].email);
                if (collaborator) {
                    projects.rows[i].collaborators[j].name = collaborator.name;
                    delete projects.rows[i].collaborators[j].role;
                }
            }
        }
        return projects;
    }

1. the code above is run in sequence correct?

2. to improve the performance I want to use promise.all like below, but some how the run time its about the same and some times the promise.all is even longer. Where is my mistake on this?

    async handleProject (projects) {
        await Promise.all(projects.rows.map(async (row) => {
            console.log(row);
            row.owner = await this.userProvider.serialize(row.owner);
            return await Promise.all(row.collaborators.map(async (collaborator) => {
                const collaboratorObj = await this.userProvider.serialize(collaborator.email);
                if (collaboratorObj) {
                    collaborator.name = collaboratorObj.name;
                    delete collaborator.role;
                }
            }));
        }));
        return projects;
    }

Answer 1

Let's take a look using timeouts to simulate your asynchronous calls.

This code is equivalent to your first example, before you made your optimizations. Notice how there's only ever a single promise pending at any given moment:

 let serializeAndCache = owner => { console.log(`Starting: ${owner}`); let prm = new Promise(r => setTimeout(r, 2000)); prm.then(() => console.log(`Finished: ${owner}`)); return prm; }; let project = { rows: [ { owner: 'owner1', collaborators: [ { name: null, email: 'collab1@row1.com' }, { name: null, email: 'collab2@row1.com' }, { name: null, email: 'collab3@row1.com' }, { name: null, email: 'collab4@row1.com' } ] }, { owner: 'owner2', collaborators: [ { name: null, email: 'collab1@row2.com' }, { name: null, email: 'collab2@row2.com' }, { name: null, email: 'collab3@row2.com' }, { name: null, email: 'collab4@row2.com' } ] }, { owner: 'owner3', collaborators: [ { name: null, email: 'collab1@row3.com' }, { name: null, email: 'collab2@row3.com' }, { name: null, email: 'collab3@row3.com' }, { name: null, email: 'collab4@row3.com' } ] } ] }; (async () => { for (let row of project.rows) { row.owner = await serializeAndCache(row.owner); for (let collaborator of row.collaborators) { let c = await serializeAndCache(collaborator.email); if (;c) continue. collaborator.name = c;name. delete collaborator;role; } } })();

And this code is equivalent to your optimized version:

 let serializeAndCache = owner => { console.log(`Starting: ${owner}`); let prm = new Promise(r => setTimeout(r, 2000)); prm.then(() => console.log(`Finished: ${owner}`)); return prm; }; let project = { rows: [ { owner: 'owner1', collaborators: [ { name: null, email: 'collab1@row1.com' }, { name: null, email: 'collab2@row1.com' }, { name: null, email: 'collab3@row1.com' }, { name: null, email: 'collab4@row1.com' } ] }, { owner: 'owner2', collaborators: [ { name: null, email: 'collab1@row2.com' }, { name: null, email: 'collab2@row2.com' }, { name: null, email: 'collab3@row2.com' }, { name: null, email: 'collab4@row2.com' } ] }, { owner: 'owner3', collaborators: [ { name: null, email: 'collab1@row3.com' }, { name: null, email: 'collab2@row3.com' }, { name: null, email: 'collab3@row3.com' }, { name: null, email: 'collab4@row3.com' } ] } ] }; (async () => { await Promise.all(project.rows.map(async row => { row.owner = await serializeAndCache(row.owner); return Promise.all(row.collaborators.map(async collab => { let c = await serializeAndCache(collab.email); if (c) { collab.name = c.name; delete collab.role; } })); })); })();

As you can see, many promises are pending all at once (and overall the code finishes more quickly). Your optimization seems like it's working! I can only assume that whatever logic lies behind serializeAndCache behaves poorly when it is flooded by many calls all at once. This seems to be the only explanation for poor performance.