Question

我有一个函数存在，它检查某些东西并返回一个promise，一个函数isAuthorized调用它。我可以通过两种方式使用它：

// Way A: resolve() or reject()

export const existsA = (id) => {
    return getSomethingById(id)
        .then((result) => {
            if (!result ) {
                return Promise.reject(new Error(''));
            }

            return Promise.resolve();
        })
        .catch(error => Promise.reject(new Error(error)));
};

exports.isAuthorizedA = (req, res, next) => {
    existsA(req.user.id)
        .then(next)
        .catch(next(Boom.forbidden()));
};

// Way B: resolve(true) or resolve(false)

export const existsB = (id) => {
    return getSomethingById(id)
        .then((result) => {
            if (!result ) {
                return Promise.resolve(false);
            }

            return Promise.resolve(true);
        })
        .catch(error => Promise.reject(new Error(error)));
};

exports.isAuthorizedB = (req, res, next) => {
    existsB(req.user.id)
        .then((result) => (result ? next() : next(Boom.forbidden())))
        .catch(next(Boom.forbidden()));
};

哪种方式正确？提前谢谢。

Answer 1

最佳做法是拒绝任何错误发生的承诺（未捕获的异常），以便更好地

const existsA = (id) => getSomethingById(id);

const isAuthorizedA = (req, res, next) => {
    existsA(req.user.id)
        .then(next)
        .catch(next(Boom.forbidden()));
};

在getSomethingById（）中处理所有失败案例并从那里拒绝错误。如果你想要null或任何有价值的值作为错误，那么写

getSomethingById(id) => {
  new Promise(function(resolve, reject) {
  // your operations    
  if(!value)
    reject(new Error('your code'))
  else
    resolve(123)
});

至于你的用例，你不希望结果是假的，我的意思是有时在你的承诺中，你会期望一个假的，如下面的积极结果

checkIfPostIsLiked(userId, postId)
.then(isLiked => {
    if (isLiked) return unLikePost(userId, postId)
    return likePost(userId, postId)
})
.catch(next(Boom.forbidden()));

如果您将false视为错误，则可能无效。

因此，无论何时想要抛出错误或将该情况标记为失败案例，最佳做法都是拒绝承诺并在catch块中处理它。

Answer 2

无需拒绝错误或解决结果，这就足够了：

export const existsA = (id) => {
  return getSomethingById(id)
    .then(result => result != null);
};

任何未捕获的异常都会拒绝。

承诺最佳实践：Promise.resolve（false）或Promise.reject（）？

2 个答案: