如何拒绝异步/等待语法？

Question

如何拒绝由 async / await 函数返回的承诺？

例如原来：

 foo(id: string): Promise<A> {
  return new Promise((resolve, reject) => {
    someAsyncPromise().then((value)=>resolve(200)).catch((err)=>reject(400))
  });
}

翻译成 async / await ：

 async foo(id: string): Promise<A> {
  try{
    await someAsyncPromise();
    return 200;
  } catch(error) {//here goes if someAsyncPromise() rejected}
    return 400; //this will result in a resolved promise.
  });
}

那么，在这种情况下，我怎么能正确拒绝这个承诺呢？

原文由 Phoenix 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

您最好的选择是 throw 一个 Error 包装该值，这会导致一个被拒绝的承诺 Error 包装该值：

 } catch (error) {
    throw new Error(400);
}

您也可以只 throw 值，但是没有堆栈跟踪信息：

 } catch (error) {
    throw 400;
}

或者，使用 Error 包装值返回一个被拒绝的承诺，但这不是惯用的：

 } catch (error) {
    return Promise.reject(new Error(400));
}

（或者只是 return Promise.reject(400); ，但同样，没有上下文信息。）

在您的情况下，当您使用 TypeScript 和 foo 的返回值是 Promise<A> 时，您将使用这个：

 return Promise.reject<A>(400 /*or Error*/ );

在 async / await 情况下，最后一个可能有点语义不匹配，但它确实有效。

如果你抛出一个 Error ，那么它与任何消耗你的 foo 的结果的东西都很好 await 语法：

 try {
    await foo();
} catch (error) {
    // Here, `error` would be an `Error` (with stack trace, etc.).
    // Whereas if you used `throw 400`, it would just be `400`.
}

原文由 T.J. Crowder 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

我建议以一种新颖的方法正确 处理拒绝，而无需使用多个 try-catch 块。

 import to from './to';

async foo(id: string): Promise<A> {
    let err, result;
    [err, result] = await to(someAsyncPromise()); // notice the to() here
    if (err) {
        return 400;
    }
    return 200;
}

应该从哪里导入 to.ts 函数：

 export default function to(promise: Promise<any>): Promise<any> {
    return promise.then(data => {
        return [null, data];
    }).catch(err => [err]);
}

学分转到以下 链接 中的 Dima Grossman。

原文由 Pedro Lourenço 发布，翻译遵循 CC BY-SA 4.0 许可协议