Iterate over the entries of a Map with an asynchronous callback function

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));
}

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")
})

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);
    }
  ));
}

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 );

}());