我正在使用该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 函数中有效地使用了Promise，因此这是Promise 构造函数反模式。
您的代码是主要风险的一个很好的例子：没有安全地传播所有错误。阅读为什么在那里。
此外，使用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 构造函数 executor 函数中的任何直接异常都方便地拒绝了新构造的 Promise（但在任何.then你自己的内部）。
第二个不起作用，因为async函数中的任何直接异常都会拒绝函数本身返回async的隐式Promise。
由于 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呢？
我同意上面给出的答案，但有时在你的Promise中使用异步会更简洁，特别是如果你想链接几个返回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));
Promise构造函数的函数不是异步的，因此 linter 不会显示错误。await.但一个缺点是您必须记住try/catch将其放置并附加到reject.
相信反模式就是反模式
异步Promise回调中的抛出很容易被捕获。
(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);
});
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 对象，这就足够了。