javascript异步：按照调用顺序记录每个操作的响应

我正在努力学习JS异步，并且正在努力解决下面的面试实践问题，你们中的一些人可能会对此有所了解

鉴于以下提供的功能（我们不允许更改）：

编写函数

triggerations（count）

（必须调用

proccessAction

）和

回调（message）

函数，以便

triggerations（3）

记录以下内容：

已处理行动1
已处理行动2
已处理的操作3

在不更改

processAction

函数的情况下，我无法弄清楚如何让我的操作按启动顺序登录。我也不确定如何实现一个功能，使我可以这样做的任意数量的行动。我最接近正确的功能如下所示：

const printString = (x) => {
  return new Promise((resolve, reject) => {
    let time = Math.floor(Math.random()*1000);
    setTimeout(() => {
      console.log(`${x} is resolved after ${time}.`);
      resolve();
    }, time);
  });
}
async function printAsync() {
  await printString('a');
  await printString('b');
  await printString('c');
};

产生：

a is resolved after 431.
b is resolved after 149.
c is resolved after 798.

迄今为止咨询的资源：

--

--

（我们不允许更改）：

然后您可以做的是创建一个包装函数

例如

函数processAction（i，回调）{
setTimeout（函数（）{
回调（“已处理动作”+i）；
}，Math.floor（Math.random（）*1000））；
}
函数processActionWrap（i）{
返回新承诺（（解决、拒绝）=>{
processAction（i，函数（str）{
console.log（str）；
决心（str）；
});
});
}
异步函数测试（）{
等待处理动作包装（1）；
等待处理动作包装（2）；
等待处理动作包装（3）；
}
test（）
（我们不允许更改）：

然后您可以做的是创建一个包装函数

例如


函数processAction（i，回调）{
setTimeout（函数（）{
回调（“已处理动作”+i）；
}，Math.floor（Math.random（）*1000））；
}
函数processActionWrap（i）{
返回新承诺（（解决、拒绝）=>{
processAction（i，函数（str）{
console.log（str）；
决心（str）；
});
});
}
异步函数测试（）{
等待处理动作包装（1）；
等待处理动作包装（2）；
等待处理动作包装（3）；
}
test（）您可以使用一些咖喱：

const trigger = (fn, max, count = 1) => () => max <= count && fn(count, trigger(fn, count + 1));

const triggerActions = max => trigger(cb => processAction(res => (console.log(res), cb()), 3)();

因此，您可以轻松地等待，即使是在循环中……
您可以使用一些咖喱：

const trigger = (fn, max, count = 1) => () => max <= count && fn(count, trigger(fn, count + 1));

const triggerActions = max => trigger(cb => processAction(res => (console.log(res), cb()), 3)();

因此，您可以轻松地等待
，即使是在循环中……
Keith的回答让我实现了以下功能，似乎功能正常：

async function triggerActions(count) {
  let i = 1;
  for (i; i <= count; i++) {
    await processActionWrap(i);
  }  
}

function processAction(i, callback) {
  let time = Math.floor(Math.random()*1000);
  setTimeout(function() {
    callback(`Processed Action ${i} in ${time}`);
  }, time);
}

function processActionWrap(i) {
  return new Promise((resolve, reject) => {
    processAction(i, (str) => {
      console.log(str);
      resolve(str);
    });
  });
}

triggerActions(5);

再次感谢
 Keith的回答让我实现了以下功能：

async function triggerActions(count) {
  let i = 1;
  for (i; i <= count; i++) {
    await processActionWrap(i);
  }  
}

function processAction(i, callback) {
  let time = Math.floor(Math.random()*1000);
  setTimeout(function() {
    callback(`Processed Action ${i} in ${time}`);
  }, time);
}

function processActionWrap(i) {
  return new Promise((resolve, reject) => {
    processAction(i, (str) => {
      console.log(str);
      resolve(str);
    });
  });
}

triggerActions(5);

再次感谢

Processed Action 1 in 841
Processed Action 2 in 15
Processed Action 3 in 346
Processed Action 4 in 331
Processed Action 5 in 314