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块中，在这个块中创建了多个promise，这会使处理特定于创建它的promise的错误变得非常麻烦。另一种方法是多个try-catch块，我认为这同样很麻烦

选择

另一种说法是:

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()返回的承诺完成。然后，它继续执行，并将返回值写入var quote，如果承诺已解决，则打印该值;如果承诺被拒绝，则抛出异常并运行catch块，打印错误。

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

性能

现在来看表演。让我们来测试一下!

我刚刚写了这段代码- f1()给出1作为返回值，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中，我不会担心这样的事情。如果像这样的东西被大量使用，那么它最终会被V8或SpiderMonkey或Chakra团队优化，每个人都会遵循-这并不是说它没有作为一个原则进行优化，这不是一个问题。

即使它没有优化，我仍然认为，如果你在Node中耗尽了你的CPU，那么你可能应该用C来编写你的数字运算——这就是本地插件的用途。或者像节点这样的东西。native会比Node.js更适合这项工作。

我想知道什么用例需要抛出这么多异常。通常抛出一个异常而不是返回一个值，嗯，是一个异常。

以我的经验，用这种方式抓是很危险的。在整个堆栈中抛出的任何错误都将被捕获，而不仅仅是来自这个承诺的错误(这可能不是您想要的)。

承诺的第二个参数已经是一个拒绝/失败回调。使用它会更好更安全。

下面是我写的一个typescript类型安全的一行程序来处理这个问题:

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()
);

更清洁的替代方法如下:

因为事实上，每个异步函数在技术上都是一个承诺

您可以在使用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，因为所有的承诺错误都被处理了，并且你没有代码错误，你可以在父类中省略它!!

假设你正在使用mongodb，如果有一个错误，你可能更喜欢在调用它的函数中处理它，而不是制作包装器，或使用try catch。

我认为，一个简单的例子是如何使用MDN DOCS的承诺。

作为一个例子，他们使用API Fetch，然后是两种类型，一种是正常的，另一种是混合的，其中async和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);
});

混合方法

由于async关键字将一个函数转换为一个promise，你可以重构你的代码，使用promise和await的混合方法，将函数的后半部分引入一个新块，使其更加灵活:

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

添加错误处理

正常的

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

最好的解决方案

给出的最佳解决方案遵循这些原则，但增加了更清晰的答案是:> StackOverflow: try/catch block with 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);
}

我想这样做:)

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