详细解读JavaScript编程中的Promise使用

这篇文章主要介绍了详细解读JavaScript编程中的Promise使用,是JS入门学习中的基础知识,需要的朋友可以参考下

Promise核心说明

尽管Promise已经有自己的规范，但目前的各类Promise库，在Promise的实现细节上是有差异的，部分API甚至在意义上完全不同。但Promise的核心内容，是相通的，它就是then方法。在相关术语中，promise指的就是一个有then方法，且该方法能触发特定行为的对象或函数。

Promise可以有不同的实现方式，因此Promise核心说明并不会讨论任何具体的实现代码。

先阅读Promise核心说明的意思是：看，这就是需要写出来的结果，请参照这个结果想一想怎么用代码写出来吧。

起步：用这一种方式理解Promise

回想一下Promise解决的是什么问题?回调。例如，函数doMission1()代表第一件事情，现在，我们想要在这件事情完成后，再做下一件事情doMission2()，应该怎么做呢?

先看看我们常见的回调模式。doMission1()说：“你要这么做的话，就把doMission2()交给我，我在结束后帮你调用。”所以会是：

1. doMission1(doMission2); 

Promise模式又是如何呢?你对doMission1()说：“不行，控制权要在我这里。你应该改变一下，你先返回一个特别的东西给我，然后我来用这个东西安排下一件事。”这个特别的东西就是Promise，这会变成这样：

1. doMission1().then(doMission2); 

可以看出，Promise将回调模式的主从关系调换了一个位置(翻身做主人!)，多个事件的流程关系，就可以这样集中到主干道上(而不是分散在各个事件函数之内)。

好了，如何做这样一个转换呢?从最简单的情况来吧，假定doMission1()的代码是：

1. function doMission1(callback){ 
2. var value = 1; 
3. callback(value); 
4. } 

那么，它可以改变一下，变成这样：

1. function doMission1(){ 
2. return { 
3. then: function(callback){ 
4. var value = 1; 
5. callback(value); 
6. } 
7. }; 
8. } 

这就完成了转换。虽然并不是实际有用的转换，但到这里，其实已经触及了Promise最为重要的实现要点，即Promise将返回值转换为带then方法的对象。

进阶：Q的设计路程

从defer开始

design/q0.js是Q初步成型的第一步。它创建了一个名为defer的工具函数，用于创建Promise：

1. var defer = function () { 
2. var pending = [], value; 
3. return { 
4. resolve: function (_value) { 
5. value = _value; 
6. for (var i = 0, ii = pending.length; i < ii; i++) { 
7. var callback = pending[i]; 
8. callback(value); 
9. } 
10. pending = undefined; 
11. }, 
12. then: function (callback) { 
13. if (pending) { 
14. pending.push(callback); 
15. } else { 
16. callback(value); 
17. } 
18. } 
19. } 
20. }; 

这段源码可以看出，运行defer()将得到一个对象，该对象包含resolve和then两个方法。请回想一下jQuery的Deferred(同样有resolve和then)，这两个方法将会是近似的效果。then会参考pending的状态，如果是等待状态则将回调保存(push)，否则立即调用回调。resolve则将肯定这个Promise，更新值的同时运行完所有保存的回调。defer的使用示例如下：

1. var oneOneSecondLater = function () { 
2. var result = defer(); 
3. setTimeout(function () { 
4. result.resolve(1); 
5. }, 1000); 
6. return result; 
7. }; 

oneOneSecondLater().then(callback);

这里oneOneSecondLater()包含异步内容(setTimeout)，但这里让它立即返回了一个defer()生成的对象，然后将对象的resolve方法放在异步结束的位置调用(并附带上值，或者说结果)。

到此，以上代码存在一个问题：resolve可以被执行多次。因此，resolve中应该加入对状态的判断，保证resolve只有一次有效。这就是Q下一步的design/q1.js(仅差异部分)：

1. resolve: function (_value) { 
2. if (pending) { 
3. value = _value; 
4. for (var i = 0, ii = pending.length; i < ii; i++) { 
5. var callback = pending[i]; 
6. callback(value); 
7. } 
8. pending = undefined; 
9. } else { 
10. throw new Error("A promise can only be resolved once."); 
11. } 
12. } 

对第二次及更多的调用，可以这样抛出一个错误，也可以直接忽略掉。

分离defer和promise

在前面的实现中，defer生成的对象同时拥有then方法和resolve方法。按照定义，promise关心的是then方法，至于触发promise改变状态的resolve，是另一回事。所以，Q接下来将拥有then方法的promise，和拥有resolve的defer分离开来，各自独立使用。这样就好像划清了各自的职责，各自只留一定的权限，这会使代码逻辑更明晰，易于调整。请看design/q3.js：(q2在此跳过)

1. var isPromise = function (value) { 
2. return value && typeof value.then === "function"; 
3. }; 
4.  
5. var defer = function () { 
6. var pending = [], value; 
7. return { 
8. resolve: function (_value) { 
9. if (pending) { 
10. value = _value; 
11. for (var i = 0, ii = pending.length; i < ii; i++) { 
12. var callback = pending[i]; 
13. callback(value); 
14. } 
15. pending = undefined; 
16. } 
17. }, 
18. promise: { 
19. then: function (callback) { 
20. if (pending) { 
21. pending.push(callback); 
22. } else { 
23. callback(value); 
24. } 
25. } 
26. } 
27. }; 
28. }; 

如果你仔细对比一下q1，你会发现区别很小。一方面，不再抛出错误(改为直接忽略第二次及更多的resolve)，另一方面，将then方法移动到一个名为promise的对象内。到这里，运行defer()得到的对象(就称为defer吧)，将拥有resolve方法，和一个promise属性指向另一个对象。这另一个对象就是仅有then方法的promise。这就完成了分离。

前面还有一个isPromise()函数，它通过是否有then方法来判断对象是否是promise(duck-typing的判断方法)。为了正确使用和处理分离开的promise，会像这样需要将promise和其他值区分开来。

实现promise的级联

接下来会是相当重要的一步。到前面到q3为止，所实现的promise都是不能级联的。但你所熟知的promise应该支持这样的语法：

1. promise.then(step1).then(step2); 

以上过程可以理解为，promise将可以创造新的promise，且取自旧的promise的值(前面代码中的value)。要实现then的级联，需要做到一些事情：

then方法必须返回promise。

这个返回的promise必须用传递给then方法的回调运行后的返回结果，来设置自己的值。

传递给then方法的回调，必须返回一个promise或值。

design/q4.js中，为了实现这一点，新增了一个工具函数ref：

1. var ref = function (value) { 
2. if (value && typeof value.then === "function") 
3. return value; 
4. return { 
5. then: function (callback) { 
6. return ref(callback(value)); 
7. } 
8. }; 
9. }; 

这是在着手处理与promise关联的value。这个工具函数将对任一个value值做一次包装，如果是一个promise，则什么也不做，如果不是promise，则将它包装成一个promise。注意这里有一个递归，它确保包装成的promise可以使用then方法级联。为了帮助理解它，下面是一个使用的例子：

1. ref("step1").then(function(value){ 
2. console.log(value); // "step1" 
3. return 15; 
4. }).then(function(value){ 
5. console.log(value); // 15 
6. }); 

你可以看到value是怎样传递的，promise级联需要做到的也是如此。

design/q4.js通过结合使用这个ref函数，将原来的defer转变为可级联的形式：

1. var defer = function () { 
2. var pending = [], value; 
3. return { 
4. resolve: function (_value) { 
5. if (pending) { 
6. value = ref(_value); // values wrapped in a promise 
7. for (var i = 0, ii = pending.length; i < ii; i++) { 
8. var callback = pending[i]; 
9. value.then(callback); // then called instead 
10. } 
11. pending = undefined; 
12. } 
13. }, 
14. promise: { 
15. then: function (_callback) { 
16. var result = defer(); 
17. // callback is wrapped so that its return 
18. // value is captured and used to resolve the promise 
19. // that "then" returns 
20. var callback = function (value) { 
21. result.resolve(_callback(value)); 
22. }; 
23. if (pending) { 
24. pending.push(callback); 
25. } else { 
26. value.then(callback); 
27. } 
28. return result.promise; 
29. } 
30. } 
31. }; 
32. }; 

原来callback(value)的形式，都修改为value.then(callback)。这个修改后效果其实和原来相同，只是因为value变成了promise包装的类型，会需要这样调用。

then方法有了较多变动，会先新生成一个defer，并在结尾处返回这个defer的promise。请注意，callback不再是直接取用传递给then的那个，而是在此基础之上增加一层，并把新生成的defer的resolve方法放置在此。此处可以理解为，then方法将返回一个新生成的promise，因此需要把promise的resolve也预留好，在旧的promise的resolve运行后，新的promise的resolve也会随之运行。这样才能像管道一样，让事件按照then连接的内容，一层一层传递下去。

加入错误处理

promise的then方法应该可以包含两个参数，分别是肯定和否定状态的处理函数(onFulfilled与onRejected)。前面我们实现的promise还只能转变为肯定状态，所以，接下来应该加入否定状态部分。

请注意，promise的then方法的两个参数，都是可选参数。design/q6.js(q5也跳过)加入了工具函数reject来帮助实现promise的否定状态：

1. var reject = function (reason) { 
2. return { 
3. then: function (callback, errback) { 
4. return ref(errback(reason)); 
5. } 
6. }; 
7. }; 

它和ref的主要区别是，它返回的对象的then方法，只会取第二个参数的errback来运行。design/q6.js的其余部分是：

1. var defer = function () { 
2. var pending = [], value; 
3. return { 
4. resolve: function (_value) { 
5. if (pending) { 
6. value = ref(_value); 
7. for (var i = 0, ii = pending.length; i < ii; i++) { 
8. value.then.apply(value, pending[i]); 
9. } 
10. pending = undefined; 
11. } 
12. }, 
13. promise: { 
14. then: function (_callback, _errback) { 
15. var result = defer(); 
16. // provide default callbacks and errbacks 
17. _callback = _callback || function (value) { 
18. // by default, forward fulfillment 
19. return value; 
20. }; 
21. _errback = _errback || function (reason) { 
22. // by default, forward rejection 
23. return reject(reason); 
24. }; 
25. var callback = function (value) { 
26. result.resolve(_callback(value)); 
27. }; 
28. var errback = function (reason) { 
29. result.resolve(_errback(reason)); 
30. }; 
31. if (pending) { 
32. pending.push([callback, errback]); 
33. } else { 
34. value.then(callback, errback); 
35. } 
36. return result.promise; 
37. } 
38. } 
39. }; 
40. }; 

这里的主要改动是，将数组pending只保存单个回调的形式，改为同时保存肯定和否定的两种回调的形式。而且，在then中定义了默认的肯定和否定回调，使得then方法满足了promise的2个可选参数的要求。

你也许注意到defer中还是只有一个resolve方法，而没有类似jQuery的reject。那么，错误处理要如何触发呢?请看这个例子：

1. var defer1 = defer(), 
2. promise1 = defer1.promise; 
3. promise1.then(function(value){ 
4. console.log("1: value = ", value); 
5. return reject("error happens");  
6. }).then(function(value){ 
7. console.log("2: value = ", value); 
8. }).then(null, function(reason){ 
9. console.log("3: reason = ", reason); 
10. }); 
11. defer1.resolve(10); 
12.  
13. // Result: 
14. // 1: value = 10 
15. // 3: reason = error happens 

可以看出，每一个传递给then方法的返回值是很重要的，它将决定下一个then方法的调用结果。而如果像上面这样返回工具函数reject生成的对象，就会触发错误处理。

融入异步

终于到了最后的design/q7.js。直到前面的q6，还存在一个问题，就是then方法运行的时候，可能是同步的，也可能是异步的，这取决于传递给then的函数(例如直接返回一个值，就是同步，返回一个其他的promise，就可以是异步)。这种不确定性可能带来潜在的问题。因此，Q的后面这一步，是确保将所有then转变为异步。

design/q7.js定义了另一个工具函数enqueue：

1. var enqueue = function (callback) { 
2. //process.nextTick(callback); // NodeJS 
3. setTimeout(callback, 1); // Na?ve browser solution 
4. }; 

显然，这个工具函数会将任意函数推迟到下一个事件队列运行。

design/q7.js其他的修改点是(只显示修改部分)：

1. var ref = function (value) { 
2. // ... 
3. return { 
4. then: function (callback) { 
5. var result = defer(); 
6. // XXX 
7. enqueue(function () { 
8. result.resolve(callback(value)); 
9. }); 
10. return result.promise; 
11. } 
12. }; 
13. }; 
14.  
15. var reject = function (reason) { 
16. return { 
17. then: function (callback, errback) { 
18. var result = defer(); 
19. // XXX 
20. enqueue(function () { 
21. result.resolve(errback(reason)); 
22. }); 
23. return result.promise; 
24. } 
25. }; 
26. }; 
27.  
28. var defer = function () { 
29. var pending = [], value; 
30. return { 
31. resolve: function (_value) { 
32. // ... 
33. enqueue(function () { 
34. value.then.apply(value, pending[i]); 
35. }); 
36. // ... 
37. }, 
38. promise: { 
39. then: function (_callback, _errback) { 
40. // ... 
41. enqueue(function () { 
42. value.then(callback, errback); 
43. }); 
44. // ... 
45. } 
46. } 
47. }; 
48. }; 

即把原来的value.then的部分，都转变为异步。

到此，Q提供的Promise设计原理q0~q7，全部结束。

结语

即便本文已经是这么长的篇幅，但所讲述的也只到基础的Promise。大部分Promise库会有更多的API来应对更多和Promise有关的需求，例如all()、spread()，不过，读到这里，你已经了解了实现Promise的核心理念，这一定对你今后应用Promise有所帮助。

在我看来，Promise是精巧的设计，我花了相当一些时间才差不多理解它。Q作为一个典型Promise库，在思路上走得很明确。可以感受到，再复杂的库也是先从基本的要点开始的，如果我们自己要做类似的事，也应该保持这样的心态一点一点进步。