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

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

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

再仔細(xì)看看第二點(diǎn)，結(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) {
        // 返回一個(gè)異步Promise
        return new Promise( (resolve, reject) => {
            setTimeout(() => {
                resolve(v*2);
            }, 1000);
        });
    })
    .then ( function(v) {
        // 前一步延遲1s后執(zhí)行
        console.log(v);
    })

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

幾種錯(cuò)誤處理方式：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

具體請(qǐng)看：

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

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

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

    let foo = Promise.resolve(21);

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

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

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

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

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

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

返回一個(gè)Promise:

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

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

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

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

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

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

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

如果傳入一個(gè)空數(shù)組，會(huì)導(dǎo)致該P(yáng)romise永遠(yuǎn)不會(huì)決議！千萬不要這么做

返回一個(gè)Promise:

和Promise.all([ ... ])不同，返回消息不是一個(gè)數(shù)組，因?yàn)橹荒芙邮找粋€(gè)promise的完成消息

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

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

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

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

書中還提到了一種觀察模式（基于同一個(gè)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會(huì)被默默忽略
    Promise.race( [
        foo, 
        timeout(300)
    ])
    .then( (res) => {
        console.log(`Promise.race: ${res}`);
    })
    .finally( (res) => {
        console.log(`Promise.race: ${res}`);    // finally回調(diào)是不會(huì)提供任何參數(shù)的，詳情可看 https://github.com/tc39/proposal-promise-finally
    })
    // 觀察者模式
    if(!Promise.observe){
        Promise.observe = function(pr, cb){
            // 觀察pr的決議
            pr.then( 
                function fulfilled (msg){
                    // 完成時(shí)
                    Promise.resolve(msg).then(cb);
                },
                function reject (msg){
                    // 拒絕時(shí) 傳遞錯(cuò)誤消息 但注意觀察者promise是resolve的
                    Promise.resolve(msg).then(cb);
                }
            );
            // 返回最初的promise
            return pr;
        }
    }
    // 還是上一個(gè)超時(shí)的例子
    Promise.race( [
        Promise.observe(
            foo,
            function cleanup (msg){
                console.log(`Promise.observe: ${msg}`); // foo即使沒有在超時(shí)之前完成 也可以獲取其決議情況
            }
        )
        .then 
    ])

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

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

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

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

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

這里也主要看栗子

   if(!Promise.map) {
        Promise.map = function(vals, cb) {
            // 等待所有map的promise決議的新的promise
            return Promise.all(
                // 對(duì)vals使用map將每個(gè)值轉(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ā)出拒絕信號(hào)，如果發(fā)出會(huì)導(dǎo)致Promise.map被拒絕，其他map結(jié)果也會(huì)被丟棄
        )
    })
    .then( (vals) => {
        console.log(vals);
    })

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