循环内出现意外的“等待”。 （无等待循环）

Question

我应该如何在循环内等待bot.sendMessage()？
也许我需要await Promise.all 但我不知道我应该如何添加到bot.sendMessage()

代码：

const promise = query.exec();
promise.then(async (doc) => {
    let count = 0;
    for (const val of Object.values(doc)) {
        ++count;
        await bot.sendMessage(msg.chat.id, `???? ${count} and ${val.text}`, opts);
    }
}).catch((err) => {
    if (err) {
        console.log(err);
    }
});

错误：

[eslint] Unexpected `await` inside a loop. (no-await-in-loop)

Answer 1

如果您需要一次发送一条消息，那么您所拥有的就可以了，according to the docs，您可以像这样忽略 eslint 错误：

const promise = query.exec();
promise.then(async doc => {
  /* eslint-disable no-await-in-loop */
  for (const [index, val] of Object.values(doc).entries()) {
    const count = index + 1;
    await bot.sendMessage(msg.chat.id, `? ${count} and ${val.text}`, opts);
  }
  /* eslint-enable no-await-in-loop */
}).catch(err => {
  console.log(err);
});

但是，如果发送消息没有要求的顺序，您应该改为这样做以最大限度地提高性能和吞吐量：

const promise = query.exec();
promise.then(async doc => {
  const promises = Object.values(doc).map((val, index) => {
    const count = index + 1;
    return bot.sendMessage(msg.chat.id, `? ${count} and ${val.text}`, opts);
  });

  await Promise.all(promises);
}).catch(err => {
  console.log(err);
});

Answer 2

在大多数情况下，一旦迭代没有依赖关系，就可以避免在循环内执行 await，这就是为什么 eslint 会警告它 here

您可以将代码重写为：

const promise = query.exec();
  promise.then(async (doc) => {
    await Promise.all(Object.values(doc).map((val, idx) => bot.sendMessage(msg.chat.id, `? ${idx + 1} and ${val.text}`, opts);)
  }).catch((err) => {
    if (err) {
      console.log(err);
    }
  });

如果你仍然发送一个接一个的消息，你的代码是好的，但是你一直抛出这个错误

Answer 3

我最近遇到了类似的问题，我在尝试以异步方式运行链中的一组函数时遇到了 linting 错误。

这对我有用...

const myChainFunction = async (myArrayOfFunctions) => {
  let result = Promise.resolve()
  myArrayOfFunctions.forEach((myFunct) => {
    result = result.then(() => myFunct()
  })
  return result
}

Answer 4

当我在 forEach 循环中使用 await 时，我遇到了同样的问题。但我尝试使用递归函数调用来迭代数组。

const putDelay = (ms) =>
    new Promise((resolve) => {
        setTimeout(resolve, ms);
    });

const myRecursiveFunction = async (events, index) => {
    if (index < 0) {
        return;
    }
    callAnotherFunction(events[index].activity, events[index].action, events[index].actionData);
    await putDelay(1);
    myRecursiveFunction(events, index - 1);
};