try/catch 个块 async/await

Question

我正在深入研究节点 7 async/await 功能，并不断遇到这样的代码

function getQuote() {
  let quote = "Lorem ipsum dolor sit amet, consectetur adipiscing elit laborum.";
  return quote;
}

async function main() {
  try {
    var quote = await getQuote();
    console.log(quote);
  } catch (error) {
    console.error(error);
  }
}

main();

这似乎是 resolve/reject 或 return/throw 与 async/await 的唯一可能性，但是，v8 没有优化 try/catch 块内的代码？！

有其他选择吗？

Answer 1

备选方案

替代方案：

async function main() {
  try {
    var quote = await getQuote();
    console.log(quote);
  } catch (error) {
    console.error(error);
  }
}

会是这样的，明确使用承诺：

function main() {
  getQuote().then((quote) => {
    console.log(quote);
  }).catch((error) => {
    console.error(error);
  });
}

或类似这样的东西，使用连续传递样式：

function main() {
  getQuote((error, quote) => {
    if (error) {
      console.error(error);
    } else {
      console.log(quote);
    }
  });
}

原始示例

您的原始代码所做的是暂停执行并等待由 getQuote() 编辑的承诺 return 完成。然后它继续执行并将 returned 值写入 var quote，然后如果承诺已解决则打印它，或者抛出异常并运行 catch 块以在承诺被拒绝时打印错误。

您可以像第二个示例一样直接使用 Promise API 做同样的事情。

性能

现在，为了表演。让我们测试一下！

我刚刚写了这段代码 - f1() 将 1 作为 return 值，f2() 抛出 1 作为异常：

function f1() {
  return 1;
}

function f2() {
  throw 1;
}

现在让我们调用相同的代码一百万次，首先是 f1():

var sum = 0;
for (var i = 0; i < 1e6; i++) {
  try {
    sum += f1();
  } catch (e) {
    sum += e;
  }
}
console.log(sum);

然后让我们将 f1() 更改为 f2():

var sum = 0;
for (var i = 0; i < 1e6; i++) {
  try {
    sum += f2();
  } catch (e) {
    sum += e;
  }
}
console.log(sum);

这是我 f1:

得到的结果

$ time node throw-test.js 
1000000

real    0m0.073s
user    0m0.070s
sys     0m0.004s

这是我得到的 f2:

$ time node throw-test.js 
1000000

real    0m0.632s
user    0m0.629s
sys     0m0.004s

看来你可以在一个单线程进程中每秒执行 200 万次抛出。如果你做的不止于此，那么你可能需要担心它。

总结

我不会担心 Node.js 中的那些事情。如果这样的东西被大量使用，那么它最终会被 V8 或 SpiderMonkey 或 Chakra 团队优化，并且每个人都会遵循 - 这并不是说它没有作为原则进行优化，这不是问题。

即使它没有优化，我仍然认为如果你在 Node 中最大化你的 CPU 那么你应该用 C 编写你的数字运算 - 这就是本机插件的内容对于，除其他事项外。或者 node.native 之类的东西可能比 Node.js.

更适合这份工作

我想知道需要抛出这么多异常的用例是什么。通常抛出异常而不是 returning 值是异常。

Answer 2

try-catch 块的替代方法是 await-to-js 库。我经常使用它。例如：

import to from 'await-to-js';

async function main(callback) {
    const [err,quote] = await to(getQuote());
    
    if(err || !quote) return callback(new Error('No Quote found'));

    callback(null,quote);

}

与 try-catch 相比，此语法更简洁。

Answer 3

async function main() {
  var getQuoteError
  var quote = await getQuote().catch(err => { getQuoteError = err }

  if (getQuoteError) return console.error(err)

  console.log(quote)
}

或者，您可以这样做，而不是声明一个可能的 var 来在顶部保存错误

if (quote instanceof Error) {
  // ...
}

虽然如果抛出类似 TypeError 或 Reference 错误的东西，那将不起作用。您可以使用

确保这是一个常规错误

async function main() {
  var quote = await getQuote().catch(err => {
    console.error(err)      

    return new Error('Error getting quote')
  })

  if (quote instanceOf Error) return quote // get out of here or do whatever

  console.log(quote)
}

我对此的偏好是将所有内容包装在一个大的 try-catch 块中，其中创建了多个承诺，这使得专门针对创建它的承诺处理错误变得很麻烦。替代方案是多个 try-catch 块，我发现这同样很麻烦

Answer 4

我想这样做:)

const sthError = () => Promise.reject('sth error');

const test = opts => {
  return (async () => {

    // do sth
    await sthError();
    return 'ok';

  })().catch(err => {
    console.error(err); // error will be catched there 
  });
};

test().then(ret => {
  console.log(ret);
});

这类似于 co

的错误处理

const test = opts => {
  return co(function*() {

    // do sth
    yield sthError();
    return 'ok';

  }).catch(err => {
    console.error(err);
  });
};

Answer 5

类似于 Golang 中的错误处理的替代方案

因为 async/await 在底层使用了 promises，你可以像这样写一个小实用函数：

export function catchEm(promise) {
  return promise.then(data => [null, data])
    .catch(err => [err]);
}

然后在您需要捕获一些错误时导入它，并包装您的异步函数，returns 一个承诺。

import catchEm from 'utility';

async performAsyncWork() {
  const [err, data] = await catchEm(asyncFunction(arg1, arg2));
  if (err) {
    // handle errors
  } else {
    // use data
  }
}

Answer 6

更简洁的替代方案如下：

由于每个异步函数在技术上都是一个承诺

您可以在使用 await

调用函数时向函数添加捕获

async function a(){
    let error;

    // log the error on the parent
    await b().catch((err)=>console.log('b.failed'))

    // change an error variable
    await c().catch((err)=>{error=true; console.log(err)})

    // return whatever you want
    return error ? d() : null;
}
a().catch(()=>console.log('main program failed'))

不需要try catch，因为所有的promises错误都被处理了，而且你没有代码错误，你可以在parent中省略！！

假设您正在使用 mongodb，如果出现错误，您可能更愿意在调用它的函数中处理它，而不是制作包装器或使用 try catches。

Answer 7

catch根据我的经验，以这种方式进行操作很危险。整个堆栈中抛出的任何错误都将被捕获，而不仅仅是这个承诺的错误（这可能不是你想要的）。

promise 的第二个参数已经是 rejection/failure 回调。改用它更好更安全。

这是一个打字稿类型安全 one-liner 我写来处理这个问题：

function wait<R, E>(promise: Promise<R>): [R | null, E | null] {
  return (promise.then((data: R) => [data, null], (err: E) => [null, err]) as any) as [R, E];
}

// Usage
const [currUser, currUserError] = await wait<GetCurrentUser_user, GetCurrentUser_errors>(
  apiClient.getCurrentUser()
);

Answer 8

不需要像 await-to-js 这样的库，to-函数的一个简单的一行（也显示在其他答案中）就可以了：

const to = promise => promise.then(res => [null, res]).catch(err => [err || true, null]);

用法：

async function main()
{
    var [err, quote] = await to(getQuote());
    if(err)
    {
        console.log('warn: Could not get quote.');
    }
    else
    {
        console.log(quote);
    }
}

但是，如果错误导致函数或程序终止，例如：

async function main()
{
    var [err, quote] = await to(getQuote());
    if(err) return console.error(err);
    console.log(quote);
}

那么你不妨简单地让 main() 中的错误 return 自动发生，这无论如何都是异常的预期目的：

async function main()
{
    var quote = await getQuote();
    console.log(quote);
}

main().catch(err => console.error('error in main():', err));

抛出错误与 return 抛出错误

如果您希望处理预期会发生的错误，那么使用 throw 或 reject 是不好的做法。相反，让 getQuote() 函数始终使用以下任何一个解析：

resolve([err, result])
resolve(null)
resolve(new Error(...))
resolve({error: new Error(), result: null})
等等

抛出错误（或异步中的等价物：拒绝承诺）必须保持异常。由于异常只会在事情进展顺利时发生，而在正常使用期间不应发生，因此优化不是优先事项。因此，异常的唯一结果可能是函数终止，如果无论如何都没有被捕获，这是默认行为。

除非您处理设计不佳的第 3 方库，或者您正在将第 3 方库函数用于意外用例，否则您应该不使用to-函数。

Answer 9

如果是Express框架，我一般采用以下方法。我们可以创建一个解决承诺的函数。像 catchAsync 函数：

const catchAsync = (fn) => (req, res, next) =>{
    Promise.resolve(fn(req, res, next)).catch((err) => next(err));
});

这个函数可以在我们需要的任何地方调用try/catch。它接收我们调用的函数，并根据所携带的动作来解析或拒绝它。我们可以这样称呼它

const sampleFunction = catchAsync(async (req, res) => {
           const awaitedResponse = await getResponse();
           res.send(awaitedResponse);
});

Answer 10

我认为，一个简单且解释清楚的例子来自How to use promises of MDN DOCS。

例如，他们使用 API Fetch 然后是 2 种类型，一种是普通类型，另一种是 hybrid，其中异步和Promise混在一起。

简单示例

async function myFetch() {
  let response = await fetch("coffee.jpg");
  // Added manually a validation and throws an error
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }

  let myBlob = await response.blob();

  let objectURL = URL.createObjectURL(myBlob);
  let image = document.createElement("img");
  image.src = objectURL;
  document.body.appendChild(image);
}

myFetch().catch((e) => {
  // Catches the errors...
  console.log("There has been a problem with your fetch operation: " + e.message);
});

混合方法

Since an async keyword turns a function into a promise, you could refactor your code to use a hybrid approach of promises and await, bringing the second half of the function out into a new block to make it more flexible:

async function myFetch() {
  // Uses async
  let response = await fetch("coffee.jpg");
  // Added manually a validation and throws an error
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  return await response.blob();
}

myFetch()
  .then((blob) => {
    // uses plain promise
    let objectURL = URL.createObjectURL(blob);
    let image = document.createElement("img");
    image.src = objectURL;
    document.body.appendChild(image);
  })
  .catch((e) => console.log(e));

Adding error handling

正常

async function myFetch() {
  try {
    let response = await fetch("coffee.jpg");

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    let myBlob = await response.blob();
    let objectURL = URL.createObjectURL(myBlob);
    let image = document.createElement("img");
    image.src = objectURL;
    document.body.appendChild(image);
  } catch (e) {
    console.log(e);
  }
}

myFetch();

混合 （最佳）

async function myFetch() {
  let response = await fetch("coffee.jpg");
  if (!response.ok) {
    throw new Error(`HTTP error! status: ${response.status}`);
  }
  return await response.blob();
}

myFetch()
  .then((blob) => {
    let objectURL = URL.createObjectURL(blob);
    let image = document.createElement("img");
    image.src = objectURL;
    document.body.appendChild(image);
  })
  .catch(
    (
      e // Not need a try catch. This will catch it all already!
    ) => console.log(e)
  );

最佳解决方案

给出的最佳解决方案遵循这些原则但更加清晰，是这个答案 --> Whosebug：try/catch 块 async/await 我相信。这里

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

async function asyncFunc(param1, param2) {
  const [err, data] = await promiseHandle(expensiveFunction(param1, param2));
  // This just to show, that in this way we can control what is going on..
  if (err || !data) {
    if (err) return Promise.reject(`Error but not data..`);
    return Promise.reject(`Error but not data..`);
  }
  return Promise.resolve(data);
}

try/catch 个块 async/await

try/catch blocks with async/await

node.js

async-await

ecmascript-2017

备选方案

原始示例

性能

总结

类似于 Golang 中的错误处理的替代方案

Adding error handling

最佳解决方案