09.Promises

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