03 Promise

我们确定了通过回调表达程序异步和管理并发的两个主要缺陷：缺乏顺序性和可信任性。
首先解决控制反转问题。如果我们能把控制反转在反转回来呢？不把自己的continuation传给第三方，而是希望第三方给我们提供了解其何时结束的能力，然后我们自己的代码来决定下一步做什么。

这种范式就称为Promise

现在值与将来值

var x, y = 2;
console.log( x + y);   // NaN  <-- 因为x还没有定义

来看下Promise函数表达这个x + y的例子：

function add(xPromise, yPromise){
    // Promise.all([..])接受一个promise数组并返回一个新的promise
    // 这个新promise等待数组中的所有promise完成
    return Promise.all( [xPromise, yPromise] )

    //这个promise决议之后，我们取得收到的x和y值并加在一起
    .then( function(values){
        // values是来自于之前决议的promise的消息数组
        return values[0] + values[1];
    })
}


// fetchX() 和 fetchY()返回相应值的promise,可能已经就绪
// 也可能以后就绪
add(fetchX(), fetchY())

// 我们得到一个这两个数组的和的promise
// 现在链式调用 then() 来等待返回promise的决议
.then( function(sum){
        console.log( sum );  // 这更简单
})

这躲代码中有两层Promise
fetchX() 和 fetchY() 是直接调用的，它们返回值(promise)被传给add()。
第二层是add(..)（通过Promise.all([..])）创建并返回的promise。我们通过调用then(..)等待这个promise。

在add(..)内部，Promise.all([..])调用创建了一个promise(这个promise等待promiseX 和 promiseY的决议)。链式调用.then(..)创建了另外一个promise。这个promise由return values[0] + values[1]这一行立即决议（得到加运算的结果）。因此，链add(..)调用终止处的调用then(..)--在代码结尾处－－实际上操作的是返回的第二个promise，而不是由Promise.all([..])创建的第一个promise。还有，尽管第二个then(..)后面没有链接任何东西，但它实际上也创建了一个新的promise。

通过Promise，调用then(..)实际上可接受两个函数，第一个用于完成情况，第二个用于拒绝情况

add( fetchX(), fetchY() )
.then(
    // 完成处理函数
    function(sum){
        console.log( sum );
    },
    //拒绝处理函数
    function(err){
        console.error( err );  
    }
)

从外部看，由于Promise封装了依赖于时间的状态 － 等待底层值的完成或拒绝，所以Promise本身是与时间无关的。因此，Promise可按照预测的方式组成（组合），而不用关心时序或底层的结果。

另，一旦Promise决议，它就永远保持在这个状态。此时它就成为了不变值（immutable value），可根据需求多次查看。

Promise 是一种封装和组合未来值的易于复用的机制。

3.1.2 完成事件

假定要调用一个函数foo(..)。我们不知道也不关心它的任何细节。这个函数可能立即完成任务，也可能需要一段时间才能完成。

我们只需要知道foo(..)什么时候结束，这样就可进行下一个任务。

在典型的JS风格中，如果需要侦听某个通知，你可能会想到事件。因此，可把对通知的需求程序组织为对foo(..)发出的一个完成事件(completion event， 或 continuation 事件)的侦听。

使用回调的话，通知就是任务(foo(..))调用的回调。而使用Promise的话，我们把这个关系反转了过来，侦听来自foo(..)的事件，然后在得到通知的时候，根据情况继续。

考虑下伪代码

foo(x){
    // 开始做点可能耗时的工作
}
foo(42)

on( foo "completion" ){
    // 可进行下一步了
}
on( foo "error" ){
    // 啊，foo(..)出错了
}

从本质上讲，foo(..)并不需要了解调用代码订阅了这些事件，这样就很好地实现了关注点分离。

遗憾的是，JS并不存在这种环境。

以下是JS中更自然的表达方法：

function foo(x){
    // 开始做点什么耗时的工作
    // 构造一个listener事件通知处理对象来返回
    return listener;
}
var evt = foo(42);

evt.on("completion", function(){
    // 可进行下一步了
});
evt.on('failure', function(err){
    // 啊，foo(..)中出错了
});

foo(..)显式创建返回了一个事件订阅对象，调用代码得到这个对象，并在其上注册了两个事件处理函数。

相对面向回调的代码，这里的反转是显而易见的，而且这也是有意为之。这里没把回调传给foo(..)，而是返回一个名为evt的事件注册对象，由它来接受回调。

所以对回调模式的反转实际上是对反转的反转，或者称为反控制反转－把控制返还给调用代码，这也是我们最开始想要的效果。一个很重要的好处是，可把这个事件侦听对象提供给代码中多个独立的部分; 在foo(..)完成的时候，它们都可独立地得到通知，以执行下一步：

var evt = foo(42);
// 让 bar() 侦听 foo() 的完成
bar( evt );
// 并且让baz() 侦听foo() 的完成
baz( evt );

对控制的反转的恢复实现了更好的关注点分离，其中bar()和baz()不需要牵扯到foo()的调用细节。类似地，foo()不需要知道或关注bar()和baz()是否存在，或者是否在等待foo()的完成通知。

从本质上说，evt对象就是分离的关注点之间一个中立的第三方协商机制。事件侦听对象evt就是Promise的一个模拟。

function foo(x){
    // 做一些可能耗时的工作
    // 构造并返回一个Promise
    return new Promise( function(resolve, reject){
        // 最终调用resolve()  或者 reject()
        // 这是这个Promise的决议回调
    })
}

var p = foo(42)

bar( p );
baz( p );

new Promise( function(..){..} )模式通常称为revealing constructor 。传入的函数会立即执行，它有两个参数。这些是promise的决议函数。resolve(..)通常标识完成，而reject()则标识拒绝。

你可能会猜测bar(..) 和 baz(..) 的内部实现或许如下:

function bar(fooPromise){
    // 侦听foo(..)完成
    fooPromise.then(
        function(){
            // foo() 已经完毕，所以执行bar() 任务
        },
        function(){
            // 啊，foo(..) 中出错了!
        }
    )
}

另一种实现方式是：

function bar(){
    // foo(..) 肯定已经完成，所以执行bar()的任务
}
function oopsBar(){
    // 啊，foo()中出错了，所以bar()没有运行
}
// 对于baz()和oopsBaz()也是一样
var p = foo(42);
p.then(bar, oopsBar);
p.then(baz, oopsBaz);

最主要的区别在于错误处理部分。
在第一段里，不论foo()成功与否，bar()都会被调用。并且如果foo()失败的话，它会亲自处理自己的回退逻辑。

第二段里，bar()只有在foo()成功时才会被调用，否则就会调用oopsBar()。

这两种方法本身并谈不上对错，只是各自适用不同的情况。
不管哪种情况，都是从foo()返回的promise p 来控制接下来的步骤。
另外，两段代码都以使用promise p 调用then()两次结束。这个事实说明可前面的观点，就是promise一旦决议一直保持其决议结果不变，可多次查看。