Promises

除回調以外，Parse JavaScript SDK中的所有異步方法都返回一個Promise。有了Promises，您的代碼會比使用回調的嵌套代碼更簡潔。

1.Promises介紹

Promises代表了JavaScript編程中的下一個偉大典范。但是了解他們為什么這么偉大是不容易的事情。其核心是一個Promise代表了任務的結果，可能已經完成也可能沒有完成。Promise的唯一接口規定就是有一個then函數，當Promises成功或失敗時，可以給予回調。這在CommonJS Promises/A proposal 中有相關的概述。例如，考慮保存一個Parse.Object，這是一個異步操作。在舊的回調范例中，您的代碼如下所示：

object.save({ key: value }, {
  success: function(object) {
    // the object was saved.
  },
  error: function(object, error) {
    // saving the object failed.
  }
});

在新的Promise范例中，同樣的代碼如下所示：

object.save({ key: value }).then(
  function(object) {
    // the object was saved.
  },
  function(error) {
    // saving the object failed.
  });

沒有太大的不同，對吧？有什么大不了呢？其實，Promises的真正強大之處在于可以把它們多個鏈在一起使用。調用promise.then(func)返回一個新的Promises，直到func完成后滿足要求。但是func的使用方式有一個非常特別的地方。如果提供給then的回調返回一個新的Promises，那么then返回的這個Promises將不會被滿足，直到回調所返回的Promises得到滿足為止。以上行為的細節在Promises/A+ Proposal中有詳細說明。這是一個復雜的話題，但也許一個例子會更清楚。

想象你正在編寫代碼來登錄，找到一個對象，然后更新它。在舊的回調范式中，你最終會得到我們所說的金字塔代碼：

Parse.User.logIn("user", "pass", {
  success: function(user) {
    query.find({
      success: function(results) {
        results[0].save({ key: value }, {
          success: function(result) {
            // the object was saved.
          }
        });
      }
    });
  }
});

這看起來很愚蠢，因為它甚至還沒有任何錯誤處理代碼。但是由于Promises鏈工作的方式，代碼可以更加扁平化：

Parse.User.logIn("user", "pass").then(function(user) {
  return query.find();
}).then(function(results) {
  return results[0].save({ key: value });
}).then(function(result) {
  // the object was saved.
});

啊! 好多了！

2.then方法

每個Promise都有一個帶有一對回調的then方法。如果Promises得到解決（resolved），則調用第一個回調，而如果Promises被拒絕（rejected），則調用第二個回調。

obj.save().then(function(obj) {
  // the object was saved successfully.
}, function(error) {
  // the save failed.
});

3.鏈式Promises

Promises有點神奇，因為他們通過鏈接而避免了嵌套。如果一個Promises的回調返回一個新的Promises，那么第一個回調將不會被解決，直到第二個被解決。這可以讓您執行多個操作，而不會像使用回調一樣導致金字塔代碼。

var query = new Parse.Query("Student");
query.descending("gpa");
query.find().then(function(students) {
  students[0].set("valedictorian", true);
  return students[0].save();

}).then(function(valedictorian) {
  return query.find();

}).then(function(students) {
  students[1].set("salutatorian", true);
  return students[1].save();

}).then(function(salutatorian) {
  // Everything is done!

});

4.Promises錯誤處理

上面的代碼示例為了簡單起見，沒有出現錯誤處理，但是把它們添加回來會使舊回調代碼再現一次混亂：

Parse.User.logIn("user", "pass", {
  success: function(user) {
    query.find({
      success: function(results) {
        results[0].save({ key: value }, {
          success: function(result) {
            // the object was saved.
          },
          error: function(result, error) {
            // An error occurred.
          }
        });
      },
      error: function(error) {
        // An error occurred.
      }
    });
  },
  error: function(user, error) {
    // An error occurred.
  }
});

由于Promises知道它們是否已經完成或失敗，它們可以傳播錯誤，而不會在遇到錯誤處理程序之前調用任何回調函數。例如，上面的代碼可以簡單地寫成：

Parse.User.logIn("user", "pass").then(function(user) {
  return query.find();
}).then(function(results) {
  return results[0].save({ key: value });
}).then(function(result) {
  // the object was saved.
}, function(error) {
  // there was some error.
});

一般來說，開發人員認為一個失敗的Promises等效于異步拋出異常。實際上，如果傳遞給then的回調拋出一個錯誤，那么返回的帶有該錯誤的promise將會失敗。如果鏈中的任何Promise返回一個錯誤，之后所有的成功回調將被跳過，直到遇到一個錯誤回調。錯誤回調可以轉換錯誤，或者可以通過返回未被拒絕的新Promise來處理該錯誤。你可以把被拒絕的Promises視為拋出異常。錯誤回調就像一個可以處理錯誤或重新拋出錯誤的catch代碼塊。

var query = new Parse.Query("Student");
query.descending("gpa");
query.find().then(function(students) {
  students[0].set("valedictorian", true);
  // Force this callback to fail.
  return Parse.Promise.error("There was an error.");

}).then(function(valedictorian) {
  // Now this will be skipped.
  return query.find();

}).then(function(students) {
  // This will also be skipped.
  students[1].set("salutatorian", true);
  return students[1].save();
}, function(error) {
  // This error handler WILL be called. error will be "There was an error.".
  // Let's handle the error by returning a new promise.
  return Parse.Promise.as("Hello!");

}).then(function(hello) {
  // Everything is done!
}, function(error) {
  // This isn't called because the error was already handled.
});

擁有一個長的成功回調鏈、最后只有一個錯誤處理程序的寫法通常很方便。

5.創建Promises

當您開始使用時，只需在類似find或save方法返回時使用Promises。但是，對于更高級的場景，您可能希望自己寫一個Promises。創建Promise后，您需要調用resolve或reject以觸發其回調。

var successful = new Parse.Promise();
successful.resolve("The good result.");

var failed = new Parse.Promise();
failed.reject("An error message.");

如果您在創建Promises的同時就知道其結果，則可以使用更方便的方法：

var successful = Parse.Promise.as("The good result.");

var failed = Parse.Promise.error("An error message.");

6.串行任務中的Promises

當你想連續做一連串的任務、每一個任務都等待上一個完成后再開始，Promises很方便。例如，假設您想刪除博客上的所有評論。

var query = new Parse.Query("Comments");
query.equalTo("post", post);

query.find().then(function(results) {
  // Create a trivial resolved promise as a base case.
  var promise = Parse.Promise.as();
  _.each(results, function(result) {
    // For each item, extend the promise with a function to delete it.
    promise = promise.then(function() {
      // Return a promise that will be resolved when the delete is finished.
      return result.destroy();
    });
  });
  return promise;

}).then(function() {
  // Every comment was deleted.
});

7.并行任務中的Promises

通過when方法，您還可以使用Promises來并行執行多個任務。您可以一次啟動多個操作，并用Parse.Promise.when創建一個新的Promises，當所有的輸入Promises得到解決時，它將被解決。如果傳入的Promises沒有一個失敗，則這個新的Promises將會成功; 否則，它會隨著最后的錯誤而失敗。并行執行操作將比串行執行更快，但可能會消耗更多的系統資源和帶寬。

var query = new Parse.Query("Comments");
query.equalTo("post", post);

query.find().then(function(results) {
  // Collect one promise for each delete into an array.
  var promises = [];
  _.each(results, function(result) {
    // Start this delete immediately and add its promise to the list.
    promises.push(result.destroy());
  });
  // Return a new promise that is resolved when all of the deletes are finished.
  return Parse.Promise.when(promises);

}).then(function() {
  // Every comment was deleted.
});

8.創建異步方法

使用這些工具，可以很容易實現一個返回Promises的異步函數。例如，你可以實現一個Promises版本的setTimeout。

var delay = function(millis) {
  var promise = new Parse.Promise();
  setTimeout(function() {
    promise.resolve();
  }, millis);
  return promise;
};

delay(100).then(function() {
  // This ran after 100ms!
});