如何在async/await语法中拒绝？

Question

如何拒绝async/await函数返回的promise？

例如,最初

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

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

Answer 1

最好的办法是到throw一个Error包装的价值,这将导致与被拒绝的承诺,Error包装的价值:

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

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

} catch (error) {
    throw 400;
}

或者,返回一个被拒绝的promise,其中包含Error值:

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

(或者只是return Promise.reject(400);,但是再一次,没有上下文信息.)

(在你的情况,因为你正在使用TypeScript和foo的retrn值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`.
}

Answer 2

还应该提到的是,您可以catch()在调用异步操作之后简单地链接一个函数,因为在引擎盖下仍然会返回一个promise.

await foo().catch(error => console.log(error));

这样,try/catch如果您不喜欢它,可以避免使用语法.

Answer 3

您可以创建一个包含promise的包装函数,如果没有错误则返回包含数据的数组,如果有错误则返回错误.

function safePromise(promise) {
  return promise.then(data => [ data ]).catch(error => [ null, error ]);
}

在ES7和异步函数中使用它:

async function checkItem() {
  const [ item, error ] = await safePromise(getItem(id));
  if (error) { return null; } // handle error and return
  return item; // no error so safe to use item
}

Answer 4

这不是对@TJ Crowder 的回答。只是对评论的评论“实际上，如果异常将被转换为拒绝，我不确定我是否真的为它感到困扰，如果它是一个错误。我只抛出错误的原因可能不适用。 ”

如果您的代码正在使用async/ await，那么使用Error代替来拒绝仍然是一个好习惯400：

try {
  await foo('a');
}
catch (e) {
  // you would still want `e` to be an `Error` instead of `400`
}

Answer 5

编写异步函数的一种更好的方法是从头开始返回一个未决的Promise，然后在Promise的回调中处理拒绝和解决方案，而不是随便吐出错误时被拒绝的Promise。例：

async foo(id: string): Promise<A> {
    return new Promise(function(resolve, reject) {
        // execute some code here
        if (success) { // let's say this is a boolean value from line above
            return resolve(success);
        } else {
            return reject(error); // this can be anything, preferably an Error object to catch the stacktrace from this function
        }
    });
}

然后，您只需在返回的Promise上链接方法：

async function bar () {
    try {
        var result = await foo("someID")
        // use the result here
    } catch (error) {
        // handle error here
    }
}

bar()

来源-本教程：

https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise

Answer 6

我有一个建议，以一种新颖的方法正确处理拒绝，而无需多个 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 。