在以后的某个时间捕获拒绝promise[副本]

Question

我以后如何检索promise的结果？在一次测试中，我在发送进一步请求之前检索了一封电子邮件：

const email = await get_email();
assert.equal(email.subject, 'foobar');
await send_request1();
await send_request2();

如何在缓慢的电子邮件检索过程中发送请求？

起初，我考虑过以后再发邮件：

// This code is wrong - do not copy!
const email_promise = get_email();
await send_request1();
await send_request2();
const email = await email_promise;
assert.equal(email.subject, 'foobar');

如果get_-email（）成功，则此操作有效，但如果get_-email（）在相应的等待之前失败，并且出现完全正确的未处理PromisejectionWarning，则此操作失败。

当然，我可以用promise。全部，如下所示：

await Promise.all([
    async () => {
        const email = await get_email();
        assert.equal(email.subject, 'foobar');
    },
    async () => {
        await send_request1();
        await send_request2();
    },
]);

然而，这使得代码更难阅读（它看起来更像基于回调的编程），特别是如果以后的请求实际上依赖于电子邮件，或者有一些嵌套正在进行。有没有可能存储promise的结果/异常，并在以后等待它？

如果需要的话，这里有一个模拟的测试用例，有时失败，有时工作，随机计时。它绝不能输出未经处理的PromiserEjectionWarning。

Answer 1

所以，我想解释一下为什么我们在节点中会这样做。js:

// Your "incorrect code" from before
const email_promise = get_email(); // we acquire the promise here
await send_request1(); // if this throws - we're left with a mess
await send_request2(); // if this throws - we're left with a mess
const email = await email_promise;
assert.equal(email.subject, 'foobar');

也就是说，我们这样做的原因是不处理“多次拒绝，可能没有清理”的场景。我不知道你是如何得到Promise.all的长代码的，但是：

await Promise.all([
    async () => {
        const email = await get_email();
        assert.equal(email.subject, 'foobar');
    },
    async () => {
        await send_request1();
        await send_request2();
    },
]);

实际上可以是这样的：

let [email, requestData] = await Promise.all([
  get_email(),
  send_request1().then(send_request2)
]);
// do whatever with email here

我可能会这么做。

Answer 2

如果保证稍后会处理promise拒绝，则可以使用dummycatch链接promise，以抑制未处理拒绝的检测：

try {
    const email_promise = get_email();
    email_promise.catch(() => {}); // a hack
    await send_request1();
    await send_request2();
    const email = await email_promise;
    assert.equal(email.subject, 'foobar');
} catch (err) {...}

这种方法的问题是，有两个并发例程，但代码没有表达这一点，这是一种解决方法，通常使用Promise来完成。全部。这种变通方法之所以可行，唯一的原因是只有两个例程，其中一个（get_email）需要与链接，然后/wait，只有一次，所以其中的一部分（assert）可以推迟。如果有3个或3个以上的例程，或者例程涉及多个，那么/等待，问题就会更加明显。

以防promise。所有都引入了不需要的lambda嵌套级别，这可以通过将例程编写为命名函数来避免，即使它们没有在其他地方重用：

async function assertEmail() {
    const email = await get_email();
    assert.equal(email.subject, 'foobar');
}

async function sendRequests() {
    await send_request1();
    await send_request2();
}

...

try {
    await Promise.all([assertEmail(), sendRequests()]);
} catch (err) {...}

这会产生干净的控制流和冗长但更易于理解和测试的代码。

Answer 3

const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
const send_request1 = () => wait(300), send_request2 = () => wait(200);
async function get_email() {
    await wait(Math.random() * 1000);
    if (Math.random() > 0.5) throw new Error('failure');
    return {subject: 'foobar'};
}

const assert = require('assert');
async function main() {
    // catch possible error
    const email_promise = get_email().catch(e => e);
    await send_request1();
    await send_request2();
    // wait for result
    const email = await email_promise;
    // rethrow eventual error or do whatever you want with it
    if(email instanceof Error) {
      throw email;
    }
    assert.equal(email.subject, 'foobar');
};

(async () => {
    try {
        await main();
    } catch(e) {
        console.log('main error: ' + e.stack);
    }
})();