有没有办法将 await/async try/catch 块包装到每个函数？

Question

所以我正在使用 express.js 并考虑将 async/await 与节点 7 一起使用。有没有办法我仍然可以捕获错误但摆脱 try/catch 块？也许是函数包装器？我不确定这将如何实际执行函数的代码并调用 next(err).

exports.index = async function(req, res, next) {
  try {
    let user = await User.findOne().exec();

    res.status(200).json(user);
  } catch(err) {
    next(err);
  }
}

类似这样的...?

function example() {
   // Implements try/catch block and then handles error.
}

exports.index = async example(req, res, next) {
  let user = await User.findOne().exec();
  res.status(200).json(user);
}

编辑：

与此更相似的内容：

var wrapper = function(f) {
    return function() {
        try {
            f.apply(this, arguments);
        } catch(e) {
            customErrorHandler(e)
        }
    }
}

这会以某种方式处理 try/catch 块，但不起作用：

exports.index = wrapper(async example(req, res, next) {
  let user = await User.findOne().exec();
  res.status(200).json(user);
});

有关非异步示例，请参阅 Is there a way to add try-catch to every function in Javascript?。

Answer 1

是的，您也可以轻松地为异步函数编写这样的包装器 - 只需使用 async/await:

function wrapper(f) {
    return async function() {
//         ^^^^^
        try {
            return await f.apply(this, arguments);
//                 ^^^^^
        } catch(e) {
            customErrorHandler(e)
        }
    }
}

或者你直接使用promises，就像这个例子更适合表达（尤其是参数个数）：

function promiseWrapper(fn) {
    return (req, res, next) => {
         fn(req, res).catch(next);
    };
}

Answer 2

类似的回答希望能帮到你

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

Answer 3

如果有人更喜欢 async/await 和特定于 Express 的方法，下面的代码片段可能会有用

export function asyncWrap(fn) {
  return async function wrappedFn(req, res, next) {
    try {
      await fn(req, res);
    } catch (err) {
      next(err);
    }
  };
}

可以通过以下方式在路由器中使用

customRouter.get('/', asyncWrap(customController.getCustomListHandler));

Answer 4

所以，异步函数实际上是 promises，我想到了这个解决方案：

const asyncWrapper = async promise => {
    try {
        return [null, await promise];
    } catch (err) {
        return [err];
    }
};

const yourAsyncMethod = params => new Promise((resolve, reject) => {
    resolve(params);
});

(async () => {
  // Wrap the executed async method but use the await outside
  const [error, result] = await asyncWrapper(yourAsyncMethod(1));
  
  if (error) {
    // Handle error
  }
  console.log(result);
})();

有没有办法将 await/async try/catch 块包装到每个函数？

Is there a way to wrap an await/async try/catch block to every function?

javascript

express

async-await

ecmascript-2017