Promise是一種處理異步編程的形式汛骂，其是以"上帝"的視角來組織代碼的邦马。

這種視角用代碼具體體現(xiàn)出來就是Promise的鏈式調用,Promise.prototype.then(fuc1,fuc2)方法返回的是一個新的Promise對象年碘。這樣的鏈式寫法比起嵌套的回調函數(shù)寫法更符合人的閱讀規(guī)范澈缺。其本質是沒有改變的伐厌，then里面的函數(shù)還是需要某個結果返回之后改變Promise的狀態(tài)才會被調用旗国。

一個具體的例子：

根據(jù)某個名字查出這個人的其他具體信息《ㄉぃ現(xiàn)在假設有這樣的數(shù)據(jù)接口蜕琴，根據(jù)名字只能查出為該名的人的身份證號碼，然后根據(jù)身份證號碼能查出這個人的其他具體信息宵溅。

let promise = new Promise((resolve, reject) => {
    //根據(jù)name取id
    $.ajax({
        url : 'xxx?name=xxx',
        success : (res) => {
          if(res.statusCode === 200){
              resolve(res.id);   //將id傳入回調函數(shù)
          }else{
              reject(New Error('error'));
          }  
        },
    });
}).then((id) => {
    //當上一個promise狀態(tài)變?yōu)閞esolved之后,調用該函數(shù)凌简，根據(jù)id獲取信息
    $.ajax({
        url : 'xxx?id='+id,
        success : (red) => {
            if(res.statusCode === 200){
                console.log(res.data);
            }else{
                throw new Error('error');
            }
        }
    });
},(err) => {
    throw err;
}).catch((err) => {
    console.log(err);
});

上面的代碼每一個then中的函數(shù)，就相當處理已知的一種結果恃逻，這樣看上去是一步一步雏搂，而不用嵌套寫回調函數(shù)。

用嵌套回調函數(shù)的寫法：

$.ajax({
    url : 'xxx?name=xxx',
    success : (res) => {
        if(res.statusCode === 200){
            $.ajax({
                url : 'xxx?id='+res.data.id,
                success : (res) => {
                  if(res.statusCode === 200){
                      console.log(res.data);
                  }  
                },
            });
        }
    },
});

對Promise感性的認識可以參考張鑫旭的博文

Promise對象的特點

• 對象的狀態(tài)不受外界影響寇损。Promise對象代表一個異步操作凸郑，有三種狀態(tài)：pending（進行中）、fulfilled（已成功）和rejected（已失斆小）线椰。只有異步操作的結果，可以決定當前是哪一種狀態(tài)，任何其他操作都無法改變這個狀態(tài)憨愉。這也是Promise這個名字的由來烦绳，它的英語意思就是“承諾”，表示其他手段無法改變配紫。
• 一旦狀態(tài)改變径密，就不會再變，任何時候都可以得到這個結果躺孝。Promise對象的狀態(tài)改變享扔，只有兩種可能：從pending變?yōu)閒ulfilled和從pending變?yōu)閞ejected。只要這兩種情況發(fā)生植袍，狀態(tài)就凝固了惧眠，不會再變了，會一直保持這個結果于个，這時就稱為 resolved（已定型）氛魁。如果改變已經(jīng)發(fā)生了，你再對Promise對象添加回調函數(shù)厅篓，也會立即得到這個結果秀存。這與事件（Event）完全不同，事件的特點是羽氮，如果你錯過了它或链，再去監(jiān)聽，是得不到結果的档押。

有了Promise對象澳盐，就可以將異步操作以同步操作的流程表達出來，避免了層層嵌套的回調函數(shù)令宿。此外叼耙，Promise對象提供統(tǒng)一的接口，使得控制異步操作更加容易掀淘。

Promise也有一些缺點。首先油昂，無法取消Promise革娄，一旦新建它就會立即執(zhí)行，無法中途取消冕碟。其次拦惋，如果不設置回調函數(shù)，Promise內部拋出的錯誤安寺，不會反應到外部厕妖。第三，當處于pending狀態(tài)時挑庶，無法得知目前進展到哪一個階段（剛剛開始還是即將完成）言秸。

基本用法

const promise = new Promise(function(resolve, reject){
    // TODO
    if(<!--異步操作成功-->){
        resolve(value);
    }else{
        reject(error);
    }
});

Promise構造函數(shù)接受一個函數(shù)作為參數(shù)软能，該函數(shù)的兩個參數(shù)分別是resolve和reject。它們是兩個函數(shù)举畸，由 JavaScript 引擎提供查排，不用自己部署。

resolve函數(shù)的作用是抄沮，將Promise對象的狀態(tài)從“未完成”變?yōu)椤俺晒Α保磸?pending 變?yōu)?resolved）跋核，在異步操作成功時調用，并將異步操作的結果叛买，作為參數(shù)傳遞出去砂代；reject函數(shù)的作用是，將Promise對象的狀態(tài)從“未完成”變?yōu)椤笆　保磸?pending 變?yōu)?rejected）率挣，在異步操作失敗時調用刻伊，并將異步操作報出的錯誤，作為參數(shù)傳遞出去难礼。

Promise實例生成以后娃圆，可以用then方法分別指定resolved狀態(tài)和rejected狀態(tài)的回調函數(shù)。

promise.then(function(value){
    //do something
},function(error){
    //failure
});

第二個函數(shù)是可選的蛾茉，不一定要提供讼呢。這兩個函數(shù)都接受Promise對象傳出的值作為參數(shù)。

let promise = new Promise(function(resolve, reject){
    console.log('Promise');
    resolve();
    console.log('continue');
})

promise.then(function(value){
    console.log('resolved.')
});

console.log('Hi');
//輸出順序
//Promise
//continue
//Hi
//resolved

**注意**
Promise新建后就會立即執(zhí)行谦炬，在改變Promise之后悦屏，就是調用resolve(),reject()之后，在其之后的代碼還是會繼續(xù)執(zhí)行完

Promise狀態(tài)改變觸發(fā)回調函數(shù)是在本輪事件輪循結束之前键思，而不是在下輪輪循開始之后

上面代碼中础爬，Promise 新建后立即執(zhí)行，所以首先輸出的是Promise吼鳞。然后看蚜，then方法指定的回調函數(shù)，將在當前腳本所有同步任務執(zhí)行完才會執(zhí)行赔桌，所以resolved最后輸出供炎。

下面是一個用Promise對象實現(xiàn)的 Ajax 操作的例子。

const getJSON = function(url){
    const promise =  new Promise(function(resolve, reject){
        const handler = function(){
            if(this.readyState !== 4){
                return;
            }
            if(this.status === 200){
                resolve(this.response);
            }else{
                reject(new Error(this.statusText));
            }
        };
        const client = new XMLHttpRequest();
        client.open("GET", url);
        client.onreadystatechange = handle;
        client.responseType = "json";
        client.setRequestHeader("Accept", "application/json");
        client.send();
    };
    
    return promise;
}

getJSON("/posts.json").then(function(json){
    console.log('Contents:'+json);
},function(error){
   console.log('error:'+error); 
});

reject函數(shù)的參數(shù)通常是Error對象的實例疾党，表示拋出錯誤音诫，resolve函數(shù)的參數(shù)除了正常的值之外，還可以是另一個Promise實例雪位。

const p1 = new Promise(function(resolve, reject){
    // TODO
});

const p2 = new Promise(fucntion(resolve, reject){
    //TODO
    resolve(p1);
})

這時p1的狀態(tài)就會傳遞給p2竭钝，也就是說，p1的狀態(tài)決定了p2的狀態(tài)。如果p1的狀態(tài)是pending香罐，那么p2的回調函數(shù)就會等待p1的狀態(tài)改變卧波；如果p1的狀態(tài)已經(jīng)是resolved或者rejected，那么p2的回調函數(shù)將會立刻執(zhí)行穴吹。

const p1 = new Promise(function(resolve, reject){
    setTimeOut(() => reject(new Error('fail')),3000);
});

const p2 = new Promise(function(resolve, reject){
    setTimeOut(() => resolve(p1), 1000);
});

p2
.then(result => console.log(result))
.catch(error => console.log(error));

// Error: fail

上面代碼中幽勒，p1是一個 Promise，3 秒之后變?yōu)閞ejected港令。p2的狀態(tài)在 1 秒之后改變啥容，resolve方法返回的是p1。由于p2返回的是另一個 Promise顷霹，導致p2自己的狀態(tài)無效了咪惠，由p1的狀態(tài)決定p2的狀態(tài)。所以淋淀，后面的then語句都變成針對后者（p1）遥昧。又過了 2 秒，p1變?yōu)閞ejected朵纷，導致觸發(fā)catch方法指定的回調函數(shù)炭臭。

注意，調用resolve或reject并不會終結 Promise 的參數(shù)函數(shù)的執(zhí)行鞋仍。

new Promise((resolve, reject) => {
  resolve(1);
  console.log(2);
}).then(r => {
  console.log(r);
});
// 2
// 1

上面代碼中搅吁，調用resolve(1)以后威创，后面的console.log(2)還是會執(zhí)行谎懦，并且會首先打印出來肚豺。這是因為立即 resolved 的 Promise 是在本輪事件循環(huán)的末尾執(zhí)行吸申，總是晚于本輪循環(huán)的同步任務隐岛。

一般來說对妄，調用resolve或reject以后湘今，Promise 的使命就完成了构灸，后繼操作應該放到then方法里面隔披，而不應該直接寫在resolve或reject的后面痢士。所以，最好在它們前面加上return語句嫌佑，這樣就不會有意外。

new Promise((resolve, reject) => {
  return resolve(1);
  // 后面的語句不會執(zhí)行
  console.log(2);
})

Promise.prototype.then()

Promise 實例具有then方法，也就是說担巩，then方法是定義在原型對象Promise.prototype上的妒峦。它的作用是為 Promise 實例添加狀態(tài)改變時的回調函數(shù)。前面說過兵睛，then方法的第一個參數(shù)是resolved狀態(tài)的回調函數(shù)肯骇，第二個參數(shù)（可選）是rejected狀態(tài)的回調函數(shù)。

then方法返回的是一個新的Promise實例（注意祖很，不是原來那個Promise實例）笛丙。因此可以采用鏈式寫法，即then方法后面再調用另一個then方法假颇。

getJSON('/utl').then(function(json){
    return json.post;
}).then(function(post){
    console.log(post);
});

上面的代碼使用then方法胚鸯，依次指定了兩個回調函數(shù)。第一個回調函數(shù)完成以后笨鸡，會將返回結果作為參數(shù)姜钳，傳入第二個回調函數(shù)。

采用鏈式的then形耗，可以指定一組按照次序調用的回調函數(shù)哥桥。這時，前一個回調函數(shù)激涤，有可能返回的還是一個Promise對象（即有異步操作）拟糕，這時后一個回調函數(shù)，就會等待該Promise對象的狀態(tài)發(fā)生變化倦踢，才會被調用送滞。

getJSON('url').then(function(post){
    return getJSON(post.commentURL);
}).then(function func1(comments){
    console.log('resolved', comments);
},function func2(err){
    console.log('rejected', err);
});

上面代碼中，第一個then方法指定的回調函數(shù)辱挥，返回的是另一個Promise對象犁嗅。這時，第二個then方法指定的回調函數(shù)晤碘，就會等待這個新的Promise對象狀態(tài)發(fā)生變化褂微。如果變?yōu)閞esolved奥吩，就調用funcA，如果狀態(tài)變?yōu)閞ejected蕊梧，就調用funcB。

Promise.prototype.catch()

Promise.prototype.catch(rejectFunc)是.then(null, rejectFunc)的別名腮介，用于指定發(fā)生錯誤時的回調肥矢。

以下兩種寫法等價。

const promise = new Promise((resolve, reject) => {
  try{
    throw new Error('error');
  }catch(e){
    reject(e);
  }  
});
promise.catch(error => console.log(error));

//寫法二
const promise = new Promise((resolve, reject) => {
    reject(new Error('error'));
});
promise.catch(error => console.log(error));

如果 Promise 狀態(tài)已經(jīng)變成resolved叠洗，再拋出錯誤是無效的甘改。

const promise = new Promise(function(resolve, reject) {
  resolve('ok');
  throw new Error('test');
});
promise
  .then(function(value) { console.log(value) })
  .catch(function(error) { console.log(error) });
// ok

上面代碼中，Promise 在resolve語句后面灭抑，再拋出錯誤十艾，不會被捕獲，等于沒有拋出腾节。因為 Promise 的狀態(tài)一旦改變忘嫉，就永久保持該狀態(tài)，不會再變了案腺。

Promise 對象的錯誤具有“冒泡”性質庆冕，會一直向后傳遞，直到被捕獲為止劈榨。也就是說访递，錯誤總是會被下一個catch語句捕獲。

好的寫法：

//good
promise
    .then(data => {
        // TODO
    })
    .catch(error => {
        // error
    });

//bad
promise
    .then(data => {
        //TODO
    }, error => {
        //error
    });

跟傳統(tǒng)的try/catch代碼塊不同的是同辣，如果沒有使用catch方法指定錯誤處理的回調函數(shù)拷姿，Promise 對象拋出的錯誤不會傳遞到外層代碼，即不會有任何反應旱函。

Promise.resolve()

Promise.resolve()用于將現(xiàn)有的對象轉為Promise對象响巢。

const jsPromise = Promise.resolve($.ajax('url'));


//Promise.reslove()的等價寫法。
Promise.resolve('foo');
//等價于
new Promise(resolve => resolve('foo'))

• 參數(shù)為一個Promise實例
  如果參數(shù)是一個Promise實例棒妨，那么Promise.resolve將不做任何修改抵乓，返回原對象。
• 參數(shù)是一個thenadle對象
  thenable對象是指都具有then方法的對象靶衍，比如下面這個對象

let thenable = {
    then : function(resolve, reject){
        resolve(42);
    })
}

Promise.resolve方法會將這個對象轉為 Promise 對象灾炭，然后就立即執(zhí)行thenable對象的then方法。

let thenable = {
    then : function(resolve, reject){
        resolve(42);  //如果在此then函數(shù)中不改變Promise狀態(tài)颅眶，則回調函數(shù)不會被執(zhí)行蜈出。
    }
};

let p1 = Promise.resolve(thenable);
p1.then(function(value){
    console.log(value); //42
})

上面代碼中，thenable對象的then方法執(zhí)行后涛酗，對象p1的狀態(tài)就變?yōu)閞esolved铡原，從而立即執(zhí)行最后那個then方法指定的回調函數(shù)偷厦，輸出 42。

• 參數(shù)不是具有then方法的對象燕刻，或根本就不是對象

如果參數(shù)是一個原始值只泼，或者是一個不具有then方法的對象，則Promise.resolve方法返回一個新的 Promise 對象卵洗，狀態(tài)為resolved请唱。

const p = Promise.resolve('Hello');

p.then(function (s){
  console.log(s)
});
// Hello

上面代碼生成一個新的 Promise 對象的實例p。由于字符串Hello不屬于異步操作（判斷方法是字符串對象不具有 then 方法）过蹂，返回 Promise 實例的狀態(tài)從一生成就是resolved十绑，所以回調函數(shù)會立即執(zhí)行。Promise.resolve方法的參數(shù)酷勺，會同時傳給回調函數(shù)本橙。

• 不帶有任何參數(shù)

Promise.resolve方法允許調用時不帶參數(shù)，直接返回一個resolved狀態(tài)的 Promise 對象脆诉。

需要注意的是甚亭，立即resolve的 Promise 對象，是在本輪“事件循環(huán)”（event loop）的結束時击胜，而不是在下一輪“事件循環(huán)”的開始時狂鞋。

setTimeOut(() => {console.log('3');}, 0);

Promise.resolve().then(() => {
    console.log('2');
});

console.log('1');

//1
//2
//3

上面代碼中，setTimeout(fn, 0)在下一輪“事件循環(huán)”開始時執(zhí)行潜的，Promise.resolve()在本輪“事件循環(huán)”結束時執(zhí)行骚揍，console.log('one')則是立即執(zhí)行，因此最先輸出啰挪。

Promise.all()

Promise.all方法用于將多個 Promise 實例信不，包裝成一個新的 Promise 實例。

const p1 = Promise.all([p1, p2, p3]);

Promise.all方法接受一個數(shù)組作為參數(shù)亡呵，p1抽活、p2、p3都是 Promise 實例锰什，如果不是下硕，就會先調用下面講到的Promise.resolve方法，將參數(shù)轉為 Promise 實例汁胆，再進一步處理梭姓。（Promise.all方法的參數(shù)可以不是數(shù)組，但必須具有 Iterator 接口嫩码，且返回的每個成員都是 Promise 實例誉尖。）

p的狀態(tài)由p1、p2铸题、p3決定铡恕，分成兩種情況琢感。

（1）只有p1、p2探熔、p3的狀態(tài)都變成fulfilled驹针，p的狀態(tài)才會變成fulfilled，此時p1诀艰、p2柬甥、p3的返回值組成一個數(shù)組，傳遞給p的回調函數(shù)涡驮。

（2）只要p1、p2喜滨、p3之中有一個被rejected捉捅，p的狀態(tài)就變成rejected，此時第一個被reject的實例的返回值虽风，會傳遞給p的回調函數(shù)棒口。

// 生成一個Promise對象的數(shù)組
const promises = [2, 3, 5, 7, 11, 13].map(function (id) {
  return getJSON('/post/' + id + ".json");
});

Promise.all(promises).then(function (posts) {
  // ...
}).catch(function(reason){
  // ...
});

Promise.race()

Promise.race方法同樣是將多個 Promise 實例，包裝成一個新的 Promise 實例辜膝。

const p = Promise.race([p1, p2, p3]);

上面代碼中无牵，只要p1、p2厂抖、p3之中有一個實例率先改變狀態(tài)茎毁，p的狀態(tài)就跟著改變。那個率先改變的 Promise 實例的返回值忱辅，就傳遞給p的回調函數(shù)七蜘。

Promise.race方法的參數(shù)與Promise.all方法一樣褒繁，如果不是 Promise 實例翰蠢，就會先調用下面講到的Promise.resolve方法，將參數(shù)轉為 Promise 實例榜跌，再進一步處理损搬。

• Promise.reject()

Promise.reject(reason)方法也會返回一個新的 Promise 實例碧库，該實例的狀態(tài)為rejected。

const p = Promise.reject('出錯了');
// 等同于
const p = new Promise((resolve, reject) => reject('出錯了'))

p.then(null, function (s) {
  console.log(s)
});
// 出錯了

注意巧勤，Promise.reject()方法的參數(shù)嵌灰，會原封不動地作為reject的理由，變成后續(xù)方法的參數(shù)颅悉。這一點與Promise.resolve方法不一致伞鲫。

參考