Javascript 清理意大利面代码w/承诺

在我的beforeSave函数中，我需要在响应成功或错误之前检查一些条件

问题是，我的代码看起来非常混乱，有时不调用success/error：

Parse.Cloud.beforeSave("Entry", function(request, response) {
    var entry = request.object;
    var contest = request.object.get("contest");

    entry.get("user").fetch().then(function(fetchedUser) {
      contest.fetch().then(function(fetchedContest) {
            if ( fetchedUser.get("fundsAvailable") < fetchedContest.get("entryFee") ) {
              response.error('Insufficient Funds.');
            } else {
                fetchedContest.get("timeSlot").fetch().then(function(fetchedTimeSlot) {
                    var now = new Date();
                    if (fetchedTimeSlot.get("startDate") < now) {
                        response.error('This contest has already started.');
                    } else {
                        contest.increment("entriesCount");
                        contest.increment("entriesLimit", 0); //have to do this, otherwise entriesLimit is undefined in save callback (?)

                        contest.save().then(function(fetchedContest) {
                            if (contest.get("entriesCount") > contest.get("entriesLimit")) {
                                response.error('The contest is full.');
                            } else {
                                response.success();
                            }
                        });
                    }
                });
            }
        });
    });
});

Parse.Cloud.beforeSave（“条目”），函数（请求、响应）{
var entry=request.object；
var contest=request.object.get（“contest”）；
entry.get（“user”）.fetch（）.then（函数（fetchedUser）{
contest.fetch（）.then（函数（fetchedContest）{
if（fetchedUser.get（“fundsAvailable”）contest.get（“entriesLimit”））{
响应。错误（'比赛已满'）；
}否则{
回答：success（）；
}
});
}
});
}
});
});
});

我一直在努力学习如何整理这件事，以下是我（失败的）尝试：

Parse.Cloud.beforeSave（“条目”），函数（请求、响应）{
var entry=request.object；
var contest=request.object.get（“contest”）；
entry.get（“user”）.fetch（）.then（函数（fetchedUser）{
contest.fetch（）.then（函数（fetchedContest）{
if（fetchedUser.get（“fundsAvailable”）contest.get（“entriesLimit”））{
响应。错误（'比赛已满'）；
}
});
}).然后（函数（）{
回答：success（）；
}，函数（错误）{
响应。错误（error）；
});
});

---

任何关于如何使用承诺的帮助或例子都将不胜感激。很明显，我还不完全理解它们在语法上是如何工作的。

你犯了一个新手错误，没有在

中返回承诺。然后在链接它们时，

，除此之外，即使你调用

response.error，你的链接仍然会继续（..

，最简单的断链方法是抛出错误，您的代码可以展平为：

Parse.Cloud.beforeSave("Entry", (request, response) => {
  var entry = request.object,
   , contest = request.object.get("contest")
   , fetchedUser
   , fetchedContest;

  entry.get("user").fetch()
    .then(_fetchedUser => {
      fetchedUser = _fetchedUser;
      return contest.fetch();
    }).then(_fetchedContest => {
      fetchedContest = _fetchedContest;
      if ( fetchedUser.get("fundsAvailable") < fetchedContest.get("entryFee") ) 
        return Promise.reject('Insufficient Funds.');      
      return fetchedContest.get("timeSlot").fetch();
    }).then(fetchedTimeSlot => {
      var now = new Date();
      if (fetchedTimeSlot.get("startDate") < now) 
        return Promise.reject('This contest has already started.');      
      contest.increment("entriesCount");
      contest.increment("entriesLimit", 0); //have to do this, otherwise entriesLimit is undefined in save callback (?)
      return contest.save();
    }).then(fetchedContest => {
      if (contest.get("entriesCount") > contest.get("entriesLimit")) 
        return Promise.reject('The contest is full.');          
      response.success();          
    }).catch(response.error.bind(response));

});

Parse.Cloud.beforeSave（“条目”、（请求、响应）=>{
var entry=request.object，
，contest=request.object.get（“contest”）
，fetchedUser
，获取竞赛；
entry.get（“用户”）.fetch（）
。然后（_fetchedUser=>{
fetchedUser=\u fetchedUser；
return contest.fetch（）；
})。然后（_fetchedContest=>{
fetchedContest=_fetchedContest；
if（fetchedUser.get（“fundsAvailable”）{
var now=新日期（）；
if（fetchedTimeSlot.get（“startDate”）{
if（contest.get（“entriescont”）>contest.get（“entriesLimit”））
返回承诺。拒绝（'比赛已满'）；
回答：success（）；
}).catch（response.error.bind（response））；
});

你犯了一个新手错误，就是没有在

内回复承诺。然后在链接承诺时，

即使你调用

响应，你的链也会继续。错误（…

，最简单的断链方法是抛出一个错误，你的代码可以被展平为：

Parse.Cloud.beforeSave("Entry", (request, response) => {
  var entry = request.object,
   , contest = request.object.get("contest")
   , fetchedUser
   , fetchedContest;

  entry.get("user").fetch()
    .then(_fetchedUser => {
      fetchedUser = _fetchedUser;
      return contest.fetch();
    }).then(_fetchedContest => {
      fetchedContest = _fetchedContest;
      if ( fetchedUser.get("fundsAvailable") < fetchedContest.get("entryFee") ) 
        return Promise.reject('Insufficient Funds.');      
      return fetchedContest.get("timeSlot").fetch();
    }).then(fetchedTimeSlot => {
      var now = new Date();
      if (fetchedTimeSlot.get("startDate") < now) 
        return Promise.reject('This contest has already started.');      
      contest.increment("entriesCount");
      contest.increment("entriesLimit", 0); //have to do this, otherwise entriesLimit is undefined in save callback (?)
      return contest.save();
    }).then(fetchedContest => {
      if (contest.get("entriesCount") > contest.get("entriesLimit")) 
        return Promise.reject('The contest is full.');          
      response.success();          
    }).catch(response.error.bind(response));

});

Parse.Cloud.beforeSave（“条目”、（请求、响应）=>{
var entry=request.object，
，contest=request.object.get（“contest”）
，fetchedUser
，获取竞赛；
entry.get（“用户”）.fetch（）
。然后（_fetchedUser=>{
fetchedUser=\u fetchedUser；
return contest.fetch（）；
})。然后（_fetchedContest=>{
fetchedContest=_fetchedContest；
if（fetchedUser.get（“fundsAvailable”）{
var now=新日期（）；
if（fetchedTimeSlot.get（“startDate”）{
if（contest.get（“entriescont”）>contest.get（“entriesLimit”））
返回承诺。拒绝（'比赛已满'）；
Parse.Cloud.beforeSave("Entry", function(request, response) {
    var entry = request.object;
    var contest = request.object.get("contest");

    var fetchedUser, fetchedContest;
    var errorMessage;

    entry.get("user").fetch().then(function(result) {
        fetchedUser = result;
        return contest.fetch();
    }).then(function(result) {
        fetchedContest = result;
        return fetchedContest.get("timeSlot").fetch();
    }).then(function(fetchedTimeSlot) {
        // now we have all the variables we need to determine validity
        var now = new Date();
        var hasSufficientFunds = fetchedUser.get("fundsAvailable") >= fetchedContest.get("entryFee");
        var contestNotStarted = fetchedTimeSlot.get("startDate") >= now;
        if (hasSufficientFunds && contestNotStarted) {
            contest.increment("entriesCount");
            contest.increment("entriesLimit", 0); //have to do this, otherwise entriesLimit is undefined in save callback (?)
            return contest.save();
        } else {
            errorMessage = (hasSufficientFunds)? 'This contest has already started.' : 'Insufficient Funds.';
            return null;
        }
    }).then(function(result) {
        if (!result) {
            response.error(errorMessage);
        } else {
            if (contest.get("entriesCount") > contest.get("entriesLimit")) {
                response.error('The contest is full.');
            } else {
                response.success();
            }
        }
    }, function(error) {
        response.error(error);
    });
});