Question

所以我使用express.js并研究如何在节点7中使用async / await。有没有办法让我仍能捕获错误但摆脱了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

如果有人更喜欢异步/等待和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 3

类似的答案here希望可以帮助你

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 4

因此，异步功能实际上是一个承诺，我想出了以下解决方案：

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块包装到每个函数中？

4 个答案: