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

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相比，此语法要干净得多。

不需要像await-to-js这样的库，简单的to-function一行代码(也在其他答案中显示)就可以了:

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()自动返回，这是异常的预期目的:

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

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

抛出错误vs返回错误

如果您希望处理一个预期会发生的错误，那么使用throw或reject是一种糟糕的实践。相反，让getQuote()函数总是使用以下任何一种方法来解析:

解决([犯错,结果]) 解决(空) 解决(新的错误(…)) 解析({错误:新的错误()，结果:null}) 等。

抛出错误(或在async:拒绝承诺中的等效)必须仍然是异常。由于异常只在出现问题时发生，而不应该在正常使用期间发生，因此优化不是优先考虑的事项。因此，异常的唯一结果可能是函数的终止，如果没有被捕获，这是默认的行为。

除非您处理的是设计糟糕的第三方库，或者您正在为意想不到的用例使用第三方库函数，否则您可能不应该使用to函数。

与Golang中的错误处理类似

因为async/await在底层使用承诺，你可以写一个像这样的小实用函数:

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

然后在需要捕捉一些错误时导入它，并包装返回承诺的async函数。

import catchEm from 'utility';

async performAsyncWork() {
  const [err, data] = await catchEm(asyncFunction(arg1, arg2));
  if (err) {
    // handle errors
  } else {
    // use 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);
  });
};

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块，我认为这同样很麻烦

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

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相比，此语法要干净得多。