Promise不僅僅是一個單步執(zhí)行this-then-that的操作機制，這只是它的構(gòu)成部件，實際上Promise是可以連接到一起使用表示一系列異步步驟：

每次對Promise調(diào)用then(..)，它都會創(chuàng)建并返回一個新的Promise，我們可以將其鏈接起來；（并不局限于要求then中返回一個Promise）

不管從then(..)調(diào)用的完成回調(diào)（第一個參數(shù)）返回的值是什么，它都會被自動設(shè)置為被鏈接Promise（上一點中的）的完成(resolve)（一定要理解這句話）

再仔細(xì)看看第二點，結(jié)合上文 3.3.7 Promise.resolve(..)的能力，這是Promise鏈?zhǔn)搅髟诿恳徊蕉寄苡挟惒侥芰Φ年P(guān)鍵！

栗子：

// 返回立即值

    let p = Promise.resolve(21);
    p
    .then( function(v) {
        console.log(v);  // 21

        // 返回立即值
        return v * 2;
    })
    // 這里是鏈接的Promise
    .then ( function(v) {
        console.log(v);  // 42
    });

// 返回Promise并引入異步

    let p = Promise.resolve(21);
    p
    .then ( function(v) {
        // 返回一個異步Promise
        return new Promise( (resolve, reject) => {
            setTimeout(() => {
                resolve(v*2);
            }, 1000);
        });
    })
    .then ( function(v) {
        // 前一步延遲1s后執(zhí)行
        console.log(v);
    })

Promise鏈不僅僅是一個表達(dá)多步異步序列的流程控制，還可以從一個步驟到下一個步驟的消息通道

幾種錯誤處理方式：

try...catch結(jié)構(gòu)不能應(yīng)用于異步模式

    function foo() {
        setTimeout(() => {
            baz.bar();  // 錯誤代碼
        }, 100);
    }
    try{
        foo();  // 之后將拋出全局錯誤
    }
    catch (err) {
        // 不會走到這里
    }

foo()中有自己的異步完成函數(shù)，其中任何異步錯誤都無法捕捉到

node.js api或庫中常見的err-first模式

    function foo(cb) {
        setTimeout(() => {
            try {
                var x = baz.bar();  //  錯誤代碼
                cb(null, x);
            }
            catch (err) {
                cb(err);
            }
        }, 100);
    }

    foo( function(err, val) {
        if(err) {
            console.error(err);  //  報錯惹
        }
        else {
            console.log(val);
        }
    })

分離回調(diào)模式(split-callback)
一個回調(diào)用于完成情況，一個回調(diào)用于拒絕情況
Promise采用的就是這種方式

先參考 3.3.6 再進(jìn)行詳細(xì)討論：

Promise決議前、決議后產(chǎn)生的錯誤處理方式有所不同
錯誤的使用Promise API產(chǎn)生的錯誤會阻礙正常Promise對象的構(gòu)造，這種情況下會立即拋出異常（這種情況應(yīng)該死都不要出現(xiàn) 0 0）

由于Promise鏈?zhǔn)教攸c，其鏈上的最后一步，不管是什么，總是存在著在未被查看的Promise中出現(xiàn)未捕獲錯誤的可能性

即理論上來說：總有可能有錯誤未被捕獲，而出現(xiàn)全局報錯

P.S. 這也是個人認(rèn)為使用Promise最頭疼的一點

關(guān)于如何解決3.5.1提出問題的一些思路

增加done(..)作為鏈?zhǔn)秸{(diào)用的終點，在其中可以查看未捕獲的錯誤，并且不會創(chuàng)建和返回新的Promise

依靠瀏覽器 追蹤Promise對象在被垃圾回收時是否有拒絕（未捕獲的錯誤），獲得其報告 （什么功能？@TODO），可是如果Promise未被垃圾回收呢？

該小節(jié)討論的是從作者角度提出一種避免在使用Promise時在開發(fā)者未注意的情況下出現(xiàn)未捕獲錯誤而報出全局錯誤的方案

具體請看：

{
    let p = Promise.reject(21); // 將觸發(fā)全局報錯 Uncaught (in promise) 21

    let p1 = Promise.reject(21).then (  // 拒絕前，注冊了一個錯誤處理函數(shù)
        (res) => {
            // 不會走到這里 
        },
        (err) => {
            console.log(`注冊了一個錯誤處理函數(shù)：${err}`);
        }
    )
    Promise.prototype.defer = function (){
        // 作者提出的一個API  
        // 簡單實現(xiàn)就是單純的返回這個Promise本身 
        return this;
    }

    let p2 = Promise.reject(21).defer(); // p2的結(jié)果在將來會被查看，現(xiàn)在暫時不要報全局錯誤

    let foo = Promise.resolve(21);

    foo
    .then (function(v) {
        return p2; // 這里查看p2的結(jié)果
    }, function (err) {
        // 不會走到這里
    })
    .catch (function(v) {
        console.log(v); // p2的結(jié)果
    })
}

基于Promise構(gòu)建的異步抽象模式

類似門(gate)這種機制：需要等待兩個或更多并行/并發(fā)的任務(wù)都完成才能繼續(xù)，它們的完成順序并不重要，但必須都要完成，門才能打開并讓流程控制繼續(xù)

Promise.all([ .. ])的參數(shù)接收一個數(shù)組：

數(shù)組中的每個值都會交給Promise.resolve(..) 過濾以保證傳入值是一個真正的Promise （Promise.resolve(..)的作用參考 3.3.7 構(gòu)建可信任的Promise）

數(shù)組為空，主promise就會立即完成

返回一個Promise:

傳入的所有promise完成，該promise標(biāo)記完成，返回消息是一個由所有傳入promise的完成消息組成的數(shù)組，與調(diào)用API時傳入的順序一致（與完成順序無關(guān)）

如果傳入的promise中有任何一個被拒絕的話，該promise會立即被拒絕，并丟棄來自其他所有promise的全部結(jié)果（其他promise還是會執(zhí)行），返回錯誤消息是被拒絕的那個promise的錯誤消息（注意，promise一旦決議結(jié)果不會變更，故僅有第一個被拒絕的promise錯誤消息會被主promise返回）

每個promise都必須關(guān)聯(lián)一個拒絕/錯誤處理函數(shù)，特別是從Promise.all([ ... ])返回的那一個

類似門閂(shuan)，競態(tài)：一旦有任何一個Promise決議為完成，就標(biāo)記為完成；一旦有任何一個Promise決議為拒絕，它就會拒絕

Promise.race([ ... ])的參數(shù)接收一個數(shù)組：

被Promise.resolve(...)過濾那是當(dāng)然的

傳入立即值沒有任何意義，肯定是第一個立即值取勝

如果傳入一個空數(shù)組，會導(dǎo)致該Promise永遠(yuǎn)不會決議！千萬不要這么做

返回一個Promise:

和Promise.all([ ... ])不同，返回消息不是一個數(shù)組，因為只能接收一個promise的完成消息

關(guān)于這兩個API需要注意

在all和race中存在著被忽略或丟棄的promise，如果這些promise中保存著重要的數(shù)據(jù)或資源或者開發(fā)者需要記錄這些promise失敗的事實，又該怎么辦呢？

finally API就是基于這種情況提出的：Promise需要一個finally(...)回調(diào)注冊，這個回調(diào)在Promise決議后總是會被調(diào)用，并允許執(zhí)行任何必要的清理工作

注：書中提到finally還未被規(guī)范支持，而在18年1月已經(jīng)正式加入到提案中了，可參考 https://github.com/tc39/propo... 和 https://github.com/tc39/propo...

書中還提到了一種觀察模式（基于同一個Promise決議可以被多次查看），具體可以看栗子

    let foo = new Promise((resolve, reject) => {
        setTimeout(() => {
            resolve(21);
        }, 301);
    });
    let timeout = function(time) {
        return new Promise((resolve, reject) => {
            setTimeout(() => {
                resolve("timeout");
            }, time);
        })
    }
    // foo會被默默忽略
    Promise.race( [
        foo, 
        timeout(300)
    ])
    .then( (res) => {
        console.log(`Promise.race: ${res}`);
    })
    .finally( (res) => {
        console.log(`Promise.race: ${res}`);    // finally回調(diào)是不會提供任何參數(shù)的，詳情可看 https://github.com/tc39/proposal-promise-finally
    })
    // 觀察者模式
    if(!Promise.observe){
        Promise.observe = function(pr, cb){
            // 觀察pr的決議
            pr.then( 
                function fulfilled (msg){
                    // 完成時
                    Promise.resolve(msg).then(cb);
                },
                function reject (msg){
                    // 拒絕時 傳遞錯誤消息 但注意觀察者promise是resolve的
                    Promise.resolve(msg).then(cb);
                }
            );
            // 返回最初的promise
            return pr;
        }
    }
    // 還是上一個超時的例子
    Promise.race( [
        Promise.observe(
            foo,
            function cleanup (msg){
                console.log(`Promise.observe: ${msg}`); // foo即使沒有在超時之前完成 也可以獲取其決議情況
            }
        )
        .then 
    ])

略
@TODO 自行實現(xiàn) Promise.any finally map等擴展API

實現(xiàn)一個異步的map(..)工具

接收一個數(shù)組的值（可以是Promise或其他值）

接收一個在每個值上運行的一個函數(shù)

返回一個Promise，其完成值是一個數(shù)組，該數(shù)組保存任務(wù)執(zhí)行之后的異步完成值（保持映射順序）

這里也主要看栗子

   if(!Promise.map) {
        Promise.map = function(vals, cb) {
            // 等待所有map的promise決議的新的promise
            return Promise.all(
                // 對vals使用map將每個值轉(zhuǎn)出promise，值數(shù)組->Promise數(shù)組
                vals.map( function(val){
                    // 將val值替換成調(diào)用cb函數(shù)后決議的新的promise
                    return new Promise( function(resolve){
                        // resolve reject傳入到cb函數(shù)中
                        cb(val, resolve);
                    })
                })
            )
        }
    }
    // 使用Promise.map
    var p1 = Promise.resolve(21);
    var p2 = Promise.resolve(30);
    var p3 = Promise.reject("opps");

    Promise.map( [p1,p2,p3], function(pr, resolve){
        Promise.resolve(pr)
        .then( val => {
            resolve( val*2 );
        },
            resolve  // 注意：不能發(fā)出拒絕信號，如果發(fā)出會導(dǎo)致Promise.map被拒絕，其他map結(jié)果也會被丟棄
        )
    })
    .then( (vals) => {
        console.log(vals);
    })

TODO：
Promise API 概述詳解多帶帶成篇