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

Question

我正在使用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 函数的第二个回调中的值。

Answer 1

相信反模式是一种反模式

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

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

Answer 2

我同意上面给出的答案，但有时在你的 Promise 中包含 async 会更整洁，特别是如果你想链接多个返回 Promise 的操作并避免 then().then() 地狱。我会考虑在这种情况下使用类似的东西：

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

1. 传递给 Promise 构造函数的函数不是异步的，因此 linter 不会显示错误。
2. 所有异步函数都可以使用await按顺序调用。
3. 可以添加自定义错误来验证异步操作的结果
4. 错误最终被很好地捕获。

一个缺点是您必须记住将try/catch 附加到reject。

Answer 3

static getPosts(){
    return new Promise( (resolve, reject) =>{
        try {
            const res =  axios.get(url);
            const data = res.data;
            resolve(
                data.map(post => ({
                    ...post,
                    createdAt: new Date(post.createdAt)
                }))
            )
        } catch (err) {
            reject(err);                
        }
    })
}

删除 await 和 async 将解决此问题。因为你已经应用了 Promise 对象，这就足够了。

Answer 4

您在 Promise 构造函数执行器函数中有效地使用了 Promise，所以这是 Promise constructor anti-pattern。

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

另外，使用async/await可以让同样的陷阱更加出人意料。比较：

let p = new Promise(resolve => {
  ""(); // TypeError
  resolve();
});

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

带有幼稚（错误）async 等效项：

let p = new Promise(async resolve => {
  ""(); // TypeError
  resolve();
});

(async () => {
  await p;
})().catch(e => console.log("Caught: " + e)); // Doesn't catch it!

在浏览器的 Web 控制台中查看最后一个。

第一个有效，因为 Promise 构造函数执行器函数中的任何 立即 异常都会方便地拒绝新构造的 Promise（但在任何 .then 中，您只能靠自己）。

第二个不起作用，因为 async 函数中的任何直接异常都会拒绝 async 函数本身返回的隐式承诺。

由于 promise 构造函数执行器函数的返回值未被使用，这是个坏消息！

您的代码

没有理由不能将myFunction 定义为async：

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

虽然有await，为什么还要使用过时的并发控制库？