Javascript 在新的Promise（）构造函数中使用async/await是一种反模式吗？

我正在使用

async.eachLimit

函数来控制一次操作的最大数量

const { eachLimit } = require("async");

function myFunction() {
 return new Promise(async (resolve, reject) => {
   eachLimit((await getAsyncArray), 500, (item, callback) => {
     // do other things that use native promises.
   }, (error) => {
     if (error) return reject(error);
     // resolve here passing the next value.
   });
 });
}

---

如您所见，我不能将

myFunction

函数声明为异步函数，因为我无权访问

eachLimit

函数的第二个回调函数中的值。

您在promise构造函数executor函数中有效地使用了promission，因此这是

您的代码是主要风险的一个很好的例子：不能安全地传播所有错误。读一读为什么

此外，使用

async

/

await

会让同样的陷阱更加令人惊讶。比较：

let p=新承诺（解析=>{
“”（）；//类型错误
解决（）；
});
（异步（）=>{
等待p；
})（）.catch（e=>console.log（“catch:+e”）；//抓住它。

---

删除等待和异步将解决此问题。因为您已经应用了Promise对象，这就足够了。

我同意上面给出的答案，但有时在Promise中使用async更为整洁，特别是如果您希望链接多个返回Promise的操作并避免使用

then（）.then（）

hell。在这种情况下，我会考虑使用类似的东西：

const operation1 = Promise.resolve(5)
const operation2 = Promise.resolve(15)
const publishResult = () => Promise.reject(`Can't publish`)

let p = new Promise((resolve, reject) => {
  (async () => {
    try {
      const op1 = await operation1;
      const op2 = await operation2;

      if (op2 == null) {
         throw new Error('Validation error');
      }

      const res = op1 + op2;
      const result = await publishResult(res);
      resolve(result)
    } catch (err) {
      reject(err)
    }
  })()
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e));

传递给

Promise

构造函数的函数不是异步的，因此linter不会显示错误

可以使用

wait

按顺序调用所有异步函数

可以添加自定义错误以验证异步操作的结果

这个错误最终被很好地抓住了

---

但缺点是，您必须记住将

try/catch

放在

reject

上，然后将其附加到

reject
相信反模式就是反模式

异步承诺回调中的抛出很容易被捕获

(async () => {
    try {
        await new Promise (async (FULFILL, BREAK) => {
            try {
                throw null;
            }
            catch (BALL) {
                BREAK (BALL);
            }
        });
    }
    catch (BALL) {
        console.log ("(A) BALL CAUGHT", BALL);
        throw BALL;
    }
}) ().
catch (BALL => {
    console.log ("(B) BALL CAUGHT", BALL);
});

或者更简单地说

(async () => {
    await new Promise (async (FULFILL, BREAK) => {
        try {
            throw null;
        }
        catch (BALL) {
            BREAK (BALL);
        }
    });
}) ().
catch (BALL => {
    console.log ("(B) BALL CAUGHT", BALL);
});

“如您所见，我不能将myFunction声明为async”-您能详细说明一下吗？哦，好的。。。很抱歉我需要构造函数，因为我需要async.eachLimit来避免一次超过500个异步操作。我正在从文本文件下载和提取数据，我希望避免很多异步操作，在提取数据后，我必须返回数据的承诺，并且我将无法从async.eachLimit.1的回调中返回它。你为什么需要等待？异步已经是一种控制流机制。2.如果您想在node.js内部使用带有承诺的async.js，请查看async QT以避免回调地狱，如果有东西抛出，则外部承诺将被捕获。您不需要
return wait
：
return new promise
就足够了。我正式批准这个答案，我会说完全相同的：-）@celoxxx看一看。您确实不应该将async.js用于promises@celoxxx只要删除类型，它就会变成纯js。你不应该使用async.js，因为不同的接口-节点风格的回调和承诺-会造成太多的摩擦，并导致不必要的复杂和容易出错的代码。我同意你的看法。。。但是这段代码很旧，我正在重构以使用events+async.js（来控制异步的限制。如果你知道更好的方法，请说）。因此在你的示例中，will
axios.get（url）
函数就好像它被称为
wait axios.get（url）
？不，
res
将包含一个承诺，其余代码将失败，因为
res.data
将未定义。
(async () => {
    await new Promise (async (FULFILL, BREAK) => {
        try {
            throw null;
        }
        catch (BALL) {
            BREAK (BALL);
        }
    });
}) ().
catch (BALL => {
    console.log ("(B) BALL CAUGHT", BALL);
});