本文實例講述了ES6 Promise對象概念及用法。分享給大家供大家參考，具體如下：

參考文章：ECMAScript 6 入門

一、 Promise是什么

Promise是異步編程的一種解決方案，它是一個容器，里面保存著某個未來才會結束的事件的結果。它有三種狀態(tài)，只有異步操作的結果才能決定當前的狀態(tài)，不受外界因素的影響。而一旦狀態(tài)改變，就不會再變，也就是狀態(tài)凝固了（resolved），任何時候都可以得到這個結果。

Promise的缺點：
1. 無法取消Promise，一旦新建它就會立即執(zhí)行，無法中途取消。
2. 如果不設置回調函數(shù)，Promise內部拋出的錯誤，不會反應到外部。
3. 當處于pending狀態(tài)時，無法得知目前進展到哪一個階段（剛剛開始還是即將完成）。

二、Promise的用法

/**
 * 創(chuàng)建Promise實例
 * @type {Promise}
 * @param resolve 在異步操作成功時調用
 * @param reject 在異步操作失敗時調用
 */
const promise = new Promise(function(resolve, reject) {
  // ... some code
  if (/* 異步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});
//調用Promise
promise.then(function(value) {
 // success
}, function(error) {
 // failure
});

Promise 新建后就會立即執(zhí)行。

let promise = new Promise(function(resolve, reject) {
 console.log('Promise');
 resolve();
});
promise.then(function() {
 console.log('resolved.');
});
console.log('Hi!');
// Promise （Promise 新建后立即執(zhí)行，所以首先輸出的是Promise）
// Hi!
// resolved （then方法指定的回調函數(shù)，將在當前腳本所有同步任務執(zhí)行完才會執(zhí)行，所以resolved最后輸出）

如果調用resolve函數(shù)和reject函數(shù)時帶有參數(shù)，那么它們的參數(shù)會被傳遞給回調函數(shù)。reject函數(shù)的參數(shù)通常是Error對象的實例，表示拋出的錯誤；resolve函數(shù)的參數(shù)除了正常的值以外，還可能是另一個 Promise 實例。

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ù)。

三、Promise原型上的方法

Promise.prototype.then()

1. then方法的第一個參數(shù)是resolved狀態(tài)的回調函數(shù)，第二個參數(shù)（可選）是rejected狀態(tài)的回調函數(shù)。
2. then方法返回的是一個新的Promise實例，但不是原來那個Promise實例。因此可以采用鏈式寫法，即then方法后面再調用另一個then方法。

getJSON("/post/1.json").then(
 post => getJSON(post.commentURL)
).then(
 comments => console.log("resolved: ", comments),
 err => console.log("rejected: ", err)
);

Promise.prototype.catch()

1. Promise.prototype.catch方法是.then(null, rejection)的別名，用于指定發(fā)生錯誤時的回調函數(shù)。
2. Promise 對象的錯誤具有“冒泡”性質，會一直向后傳遞，直到被捕獲為止。也就是說，錯誤總是會被下一個catch語句捕獲。

getJSON('/post/1.json').then(function(post) {
 return getJSON(post.commentURL);
}).then(function(comments) {
 // some code
}).catch(function(error) {
 // 處理前面三個Promise產生的錯誤
});
//上面代碼中，一共有三個 Promise 對象：一個由getJSON產生，兩個由then產生。它們之中任何一個拋出的錯誤，都會被最后一個catch捕獲。

Promise.prototype.finally()

• finally方法用于指定不管 Promise 對象最后狀態(tài)如何，都會執(zhí)行的操作。該方法是 ES2018 引入標準的。
• finally方法的回調函數(shù)不接受任何參數(shù)，這意味著沒有辦法知道，前面的 Promise 狀態(tài)到底是fulfilled還是rejected。這表明，finally方法里面的操作，應該是與狀態(tài)無關的，不依賴于 Promise 的執(zhí)行結果。

四、Promise的方法

Promise.all()

1. Promise.all方法用于將多個 Promise 實例，包裝成一個新的 Promise 實例。
2. const p = Promise.all([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ù)。
3. 如果p1、p2、p3有自己的catch方法，則不會觸發(fā)p的catch方法，如果沒有，才會調用Promise.all()的catch方法。

const p1 = new Promise((resolve, reject) => {
 resolve('hello');
})
.then(result => result)
.catch(e => e);
const p2 = new Promise((resolve, reject) => {
 throw new Error('報錯了');
})
.then(result => result)
.catch(e => e);
Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// ["hello", Error: 報錯了]
-------------------------------------------------------------------
const p1 = new Promise((resolve, reject) => {
 resolve('hello');
})
.then(result => result);
const p2 = new Promise((resolve, reject) => {
 throw new Error('報錯了');
})
.then(result => result);
Promise.all([p1, p2])
.then(result => console.log(result))
.catch(e => console.log(e));
// Error: 報錯了

Promise.race()

1. Promise.race方法同樣是將多個 Promise 實例，包裝成一個新的 Promise 實例。
2. race內部的一個實例率先改變狀態(tài)，Promise.race()的狀態(tài)就跟著改變。那個率先改變的Promise實例的返回值，就傳遞給Promise.race()的回調函數(shù)。

Promise.resolve()

1. 有時需要將現(xiàn)有對象轉為 Promise 對象，Promise.resolve方法就起到這個作用。
2. Promise.resolve方法的參數(shù)分成四種情況。
   1. 參數(shù)是一個 Promise 實例：如果參數(shù)是 Promise 實例，那么Promise.resolve將不做任何修改、原封不動地返回這個實例。
   2. 參數(shù)是一個thenable對象：thenable對象指的是具有then方法的對象，Promise.resolve方法會將這個對象轉為 Promise 對象，然后就立即執(zhí)行thenable對象的then方法。
   3. 參數(shù)不是具有then方法的對象，或根本就不是對象：如果參數(shù)是一個原始值，或者是一個不具有then方法的對象，則Promise.resolve方法返回一個新的 Promise 對象，狀態(tài)為resolved。
   4. 不帶有任何參數(shù)：Promise.resolve方法允許調用時不帶參數(shù)，直接返回一個resolved狀態(tài)的 Promise 對象。

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

setTimeout(function () {
 console.log('three');
}, 0);
Promise.resolve().then(function () {
 console.log('two');
});
console.log('one');
// one
// two
// three

Promise.reject()

1. Promise.reject(reason)方法也會返回一個新的 Promise 實例，該實例的狀態(tài)為rejected。
2. 注意，Promise.reject()方法的參數(shù)，會原封不動地作為reject的理由，變成后續(xù)方法的參數(shù)。這一點與Promise.resolve方法不一致。

const thenable = {
 then(resolve, reject) {
  reject('出錯了');
 }
};
Promise.reject(thenable)
.catch(e => {
 console.log(e === thenable)
})
// true

五、Promise的應用

包裝http請求

在使用vue的過程中，我們用Promise對Axios進行了包裝。

newAxios.post = function (url, params) {
 params = qs.stringify(params);
 return new Promise((resolve, reject) => {
  Axios.post(url, params)
   .then(res => {
    if (res.headers.warning === "redirect") {
     window.location.href = "/"
    } else {
     resolve(res);
    }
   })
   .catch(err => {
    reject(err);
   })
 })
};

處理異步請求

使用Promise.all()方法可以處理異步請求，比如某些請求需要在前面幾個請求完成之后才觸發(fā)。

后續(xù)待補充。

附：ECMAScript 6 入門本站下載地址：http://www.fzitv.net/books/551561.html

更多關于JavaScript相關內容可查看本站專題：《javascript面向對象入門教程》、《JavaScript錯誤與調試技巧總結》、《JavaScript數(shù)據(jù)結構與算法技巧總結》、《JavaScript遍歷算法與技巧總結》及《JavaScript數(shù)學運算用法總結》

希望本文所述對大家JavaScript程序設計有所幫助。

最新評論