使用异步回调 function 迭代 Map 的条目

Question

I want to iterate the entries of a Map with an asynchronous callback function. The callback function should be started immediately for all elements.

I ended up with the following code, which works but looks too complicated:

async function test() {
  const map1 = new Map();

  map1.set('a', 1);
  map1.set('b', 2);
  map1.set('c', 3);

  await Promise.all(Array.from(map1.entries()).map(async([
    key,
    value
  ]) => {
    await doSomeThing(key, value);
    await doSomeOtherThing(key, value);
  }
}

Is there an easier way to achieve this?

Answer 1

According to MDN , Promise.all() takes an iterable of promises and waits for them to resolve. An iterable may be an array, as in your code, or a dedicated generator created by a generator function. I don't know if this meets your definition of "easier", but here's one way to do it:

function* processMap(map, callback) {
    for (const entry of map.entries())
        yield callback(entry);
}

async function test() {
    const map = new Map();
    map.set("a", 1);
    map.set("b", 2);
    map.set("c", 3);
    
    const processEntry = async (entry) => {
        await doSomeThing(entry);
        await doSomeOtherThing(entry);
    };
    
    await Promise.all(processMap(map, processEntry));
}

Answer 2

You could do something shorter

• Array.from(map1.entries()) could be rewritten to [...map1]
• from what I see, doSomeOtherThing does not depend on doSomeThing so we could call them two concurrently

await Promise.all(
  [...map1].flatMap(([key, val]) => [
    doSomeThing(key, val),
    doSomeOtherThing(key, val),
  ])
)

 const doSomeThing = (key, val) => new Promise(res => { console.log("doSomeThing start", key, val) setTimeout(() => { console.log("doSomeThing finish", key, val) res() }, 1000) }) const doSomeOtherThing = (key, val) => new Promise(res => { console.log("doSomeOtherThing start", key, val) setTimeout(() => { console.log("doSomeOtherThing finish", key, val) res() }, 2000) }) async function test() { const map1 = new Map() map1.set("a", 1) map1.set("b", 2) map1.set("c", 3) /* await Promise.all( Array.from(map1.entries()).map(async ([key, value]) => { await doSomeThing(key, value) await doSomeOtherThing(key, value) }) ) */ await Promise.all( [...map1].flatMap(([key, val]) => [ doSomeThing(key, val), doSomeOtherThing(key, val), ]) ) } test().then(() => { console.log("done") })

Answer 3

All the bloat comes from the fact that there is no built in equivalent to Array.map() to map over Iterables.

But you can write a little utility to do the job.

function* map(iterable, mapper) {
  for (const item of iterable)
    yield mapper(item)
}

async function test() {
  const map1 = new Map();

  map1.set('a', 1);
  map1.set('b', 2);
  map1.set('c', 3);

  await Promise.all(map(
    map1,
    async ([key, value]) => {
      await doSomeThing(key, value);
      await doSomeOtherThing(key, value);
    }
  ));
}

Answer 4

Personally, I would prefer to break the code using the simpler and readable for...of syntax with a few descriptive variables. In such cases, "easier" is all about making the code less error-prone, easier to read and understand and above all, maintain in the long run.

(async function(){

  const map1 = new Map();
  
  map1.set('a', 1);
  map1.set('b', 2);
  map1.set('c', 3);

  const asyncOperations = [];
  
  for (const [key, value] of map1) {

    asyncOperations.push(async ()=>{
      await DoSomeThing(key, value);
      await DoSomeOtherThing(key, value);
    });
    
  }

  await Promise.all( asyncOperations );

}());  

Answer 5

The solution below uses iter-ops library:

import {pipe, toAsync, map, wait} from 'iter-ops';

const i = pipe(toAsync(map1), map(async ([key, value]) => {
    await doSomeThing(key, value);
    await doSomeOtherThing(key, value);
    return [key, value]; // or something else (result)
}), wait());

// trigger processing + print result:
for await(let res of i) {
    console.log(res);
}