我想这样做:)

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

我想这样做:)

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

不需要像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函数。

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

选择

另一种说法是:

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更适合这项工作。

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

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