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

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

下面是我写的一个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()
);

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

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

下面是我写的一个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()
);

我想这样做:)

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调用函数时向函数添加捕获

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。

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

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