如何拒绝 async/await 语法？

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

那么，在这种情况下，我该如何正确地拒绝这个承诺呢？

Answer 1

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

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

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

} catch (error) {
    throw 400;
}

或者，return 一个被拒绝的 promise 带有一个 Error 包装值，但它不是惯用的：

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

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

在你的例子中，当你使用 TypeScript 和 foo 的 return 值是 Promise<A> 时，你会使用这个：

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

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

如果你抛出一个 Error，它可以很好地处理任何使用 await 语法消耗你的 foo 结果的东西：

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

这不是对@T.J 的回答。克劳德的。只是回应评论 "And actually, if the exception is going to be converted to a rejection, I'm not sure whether I am actually bothered if it's an Error. My reasons for throwing only Error probably don't apply."

的评论

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

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

Answer 3

可能还应该提到的是，您可以在调用异步操作后简单地链接一个 catch() 函数，因为在后台仍然返回一个 promise。

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

如果您不喜欢 try/catch 语法，您可以通过这种方式避免使用它。

Answer 4

编写异步函数的更好方法是从一开始就返回一个挂起的 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
        }
    });
}

然后你只需在返回的承诺上链接方法：

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

bar()

来源 - 本教程：

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise

Answer 5

您可以创建一个 包装函数，如果没有错误，它接受一个 promise 和 returns 一个包含数据的数组，并且如果有错误，则为错误。

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

在 ES7 和 async 函数中这样使用：

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 6

我知道这是一个老问题，但我只是偶然发现了这个话题，这里似乎将错误和拒绝混为一谈，这与经常重复的建议不一致（至少在许多情况下是这样）使用异常处理来处理预期的情况。举例说明：如果异步方法尝试对用户进行身份验证但身份验证失败，则这是拒绝（两种预期情况之一）而不是错误（例如，如果身份验证 API 不可用。）

为了确保我不是胡说八道，我运行使用以下代码对三种不同的方法进行了性能测试：

const iterations = 100000;

function getSwitch() {
  return Math.round(Math.random()) === 1;
}

function doSomething(value) {
  return 'something done to ' + value.toString();
}

let processWithThrow = function () {
  if (getSwitch()) {
    throw new Error('foo');
  }
};

let processWithReturn = function () {
  if (getSwitch()) {
    return new Error('bar');
  } else {
    return {}
  }
};

let processWithCustomObject = function () {
  if (getSwitch()) {
    return {type: 'rejection', message: 'quux'};
  } else {
    return {type: 'usable response', value: 'fnord'};
  }
};

function testTryCatch(limit) {
  for (let i = 0; i < limit; i++) {
    try {
      processWithThrow();
    } catch (e) {
      const dummyValue = doSomething(e);
    }
  }
}

function testReturnError(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithReturn();
    if (returnValue instanceof Error) {
      const dummyValue = doSomething(returnValue);
    }
  }
}

function testCustomObject(limit) {
  for (let i = 0; i < limit; i++) {
    const returnValue = processWithCustomObject();
    if (returnValue.type === 'rejection') {
      const dummyValue = doSomething(returnValue);
    }
  }
}

let start, end;
start = new Date();
testTryCatch(iterations);
end = new Date();
const interval_1 = end - start;
start = new Date();
testReturnError(iterations);
end = new Date();
const interval_2 = end - start;
start = new Date();
testCustomObject(iterations);
end = new Date();
const interval_3 = end - start;

console.log(`with try/catch: ${interval_1}ms; with returned Error: ${interval_2}ms; with custom object: ${interval_3}ms`);

由于我对 Javascript 解释器的不确定性，其中的一些内容被包括在内（我一次只喜欢钻进一个兔子洞）；例如，我包含了 doSomething 函数并将其 return 分配给 dummyValue 以确保条件块不会被优化。

我的结果是：

with try/catch: 507ms; with returned Error: 260ms; with custom object: 5ms

我知道在很多情况下，寻找小的优化是不值得的，但在更大规模的系统中，这些事情会产生很大的累积差异，这是一个非常明显的比较。

所以……虽然我认为在您期望必须在异步函数中处理不可预测的错误的情况下，接受的答案的方法是合理的，但在拒绝仅仅意味着 "you're going to have to go with Plan B (or C, or D…)" 的情况下，我认为我的偏好将拒绝使用自定义响应对象。

Answer 7

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

如何拒绝 async/await 语法？

How to reject in async/await syntax?

asynchronous

typescript

es6-promise

ecmascript-2017