Javascript 同时等待2个（或更多）异步发电机

我已经为此挣扎了一段时间

如何编写一个异步生成器，给定n个异步生成器，按照它们到达的顺序从n个生成器生成值

方法应采用以下格式：

const merged=merge（[gen1，gen2，…]）

例如：

gen1 and gen2 are async generators.
gen1() yields 2 values: 1 in 100ms, 3 in 300ms  
gen2() yields 2 values: 2 in 200ms, 4 in 400ms

merge([gen1, gen2]) will yield 1, 2, 3, 4 (in that order, every 100ms)

---

所以。。。经过几天的努力解决这个问题。 这是可行的（只需将粘贴复制到最新的chrome中，并打开实验标志即可）

功能计时器（时间=500）{
返回新承诺（resolve=>setTimeout（（）=>resolve（），time））；
}
异步函数*gen1（）{
等待定时器（100）；
产量1；
等待定时器（300）；
产量4；
}
异步函数*gen2（）{
等待定时器（200）；
产量2；
等待定时器（100）；
产量3；
}
功能竞赛（承诺）{
返回新承诺（解决=>
forEach（（p，索引）=>{
p、 然后（值=>{
解析（{index，value}）；
});
})
);
}
异步函数*mergen（…gens）{
让承诺=gens.map（（gen，index）=>
gen.next（）.then（p=>（{…p，gen}））
);
while（0.length>0）{
产量竞赛（承诺）
。然后（{index，value:{value，done，gen}}）=>{
1.拼接（索引1）；
如果（！完成）
承诺，推动(
gen.next（）.then（{value:newVal，done:newDone}）=>({
值：newVal，
完成：新完成，
消息
}))
);
返回值；
});
}
}
异步函数printGen（gen）{
设max=10；
等待（第x代）{
if（x）console.log（'Next up:'，x）；
如果（--max Hard！感觉像是
Promise.race
可能是正确的工具？我试过了！这太难了：）我已经试了好几天了
function timer(time = 500) {
  return new Promise(resolve => setTimeout(() => resolve(), time));
}

async function* gen1() {
  await timer(100);
  yield 1;
  await timer(300);
  yield 4;
}

async function* gen2() {
  await timer(200);
  yield 2;
  await timer(100);
  yield 3;
}

function race(promises) {
  return new Promise(resolve =>
    promises.forEach((p, index) => {
      p.then(value => {
        resolve({index, value});
      });
    })
  );
}
async function* mergen(...gens) {
  let promises = gens.map((gen, index) =>
    gen.next().then(p => ({...p, gen}))
  );

  while (promises.length > 0) {
    yield race(promises)
    .then(({index, value: {value, done, gen}}) => {
      promises.splice(index, 1);
      if (!done)
        promises.push(
          gen.next().then(({value: newVal, done: newDone}) => ({
            value: newVal,
            done: newDone,
            gen
          }))
        );
      return value;
    });
  }
}

async function printGen(gen) {
  let max = 10;
  for await (x of gen) {
    if (x) console.log('Next up:', x);
    if (--max <= 0) break;
  }
}

printGen(mergen(gen1(), gen2())); // 1, 2, 3, 4