一、概念
Promise是非同步程式設計的一種解決方案（解決回撥地獄的問題），是一個能夠獲取非同步操作資訊的物件。Promise的內部儲存著某個未來才會結束的事件（通常是一個非同步操作）
二、特點
1.Promise物件的狀態不受外界影響
Promise物件的狀態由非同步操作的結果決定當前處於pending（進行中）、fulfilled（已成功）還是rejected（已失敗），任何其他操作都無法改變這個狀態。
2.狀態改變不可逆
一旦狀態改變，就不會再變，任何時候都可以得到這個結果。promise物件的狀態改變，只有兩種可能：從pending變為fulfilled和從pending變為rejected。只要這兩種情況發生，狀態就凝固了，不會再變了，會一直保持這個結果，這時就稱為 resolved（已定型）。如果改變已經發生了，你再對promise物件新增回撥函式，也會立即得到這個結果。
3.缺點
（1）無法取消promise，一旦新建它就會立即執行，無法中途取消
（2）如果不設定回撥函式，promise內部丟擲的錯誤，不會反應到外部
（3）當處於pending狀態時，無法得知目前進展到哪一個階段（剛剛開始還是即將完成）
4.優點
promise物件可以將非同步操作以同步操作的流程表達出來，避免了層層巢狀的回撥函式。此外，promise物件提供統一的介面，使得控制非同步操作更加容易。
三、基本用法
Promise物件是一個建構函式，接受一個函式為引數，這個函式的引數是resolve和reject，它們兩個也是函式。
resolve函式的作用是，將promise物件的狀態從“未完成”變為“成功”（即從 pending 變為 resolved），在非同步操作成功時呼叫，並將非同步操作的結果，作為引數傳遞出去，外部用then方法接收
reject函式的作用是，將promise物件的狀態從“未完成”變為“失敗”（即從 pending 變為 rejected），在非同步操作失敗時呼叫，並將非同步操作報出的錯誤，作為引數傳遞出去，外部用catch方法接收
const promise = new Promise(function(resolve, reject) {
// ... some code
if (/* 非同步操作成功 */){
resolve(value);
} else {
reject(error);
}
});
四、API詳解
1.promise.prototype.then()
then方法是定義在原型物件promise.prototype上的，它是非同步操作成功的回撥函式，是resolve函式的外部接收器。引數是一個函式。
工作原理：當promise物件執行非同步操作成功時，會通過resolve函式向外傳遞操作結果，由then方法接收後，對該結果繼續執行傳入then方法內部的函式。
then方法返回的是一個新的promise例項（注意，不是原來那個promise例項）。因此可以採用鏈式寫法，即then方法後面再呼叫另一個then方法。
function async(a,b) {
return new Promise(function (resolve,reject) {
//非同步程式碼
setTimeout(function () {
//加入資料格式的判斷
if(a!=undefined && (typeof a) =="number"){
//如果資料格式正確 則呼叫resolve匹配外部的then
resolve(a+b);
}else{
//資料格式錯誤 呼叫reject 匹配外部的catch
reject(new Error("a is not a number,你瞎啊!!!"));
}
},200)
});
}
var promise=async(1,2);
promise.then(function (res) {
if(res>2){
console.log("我是3分支");
return async(res,3)
}
//如果上一個then返回了一個promise 那麼可以後面繼續跟著then
}).then(function (res) {
if(res>4){
console.log("我是4分支");
return async(res,4);
}
})
2.promise.prototype.catch()
catch方法的使用、原理同then方法，只是catch方法是失敗的回撥函式。
注意：
（1）如果沒有使用catch()方法指定錯誤處理的回撥函式，promise 物件丟擲的錯誤不會傳遞到外層程式碼，即不會有任何反應。
（2）catch方法只能有一個，有多個無意義，後面的catch並不會執行，catch方法通常寫在最後
var user=new User("niujinghui","123456");
user.checkUsername()
.then(function (res) {
return user.checkUserpwd();
})
.then(function (res) {
console.log("使用者名稱密碼都正確");
})
.catch(function (err) {
if(err) throw err;
});
3.promise.prototype.finally()
finally()方法用於指定不管 promise 物件最後狀態如何，都會執行的操作。該方法是 es2018 引入標準的。
promise
.then(result => {···})
.catch(error => {···})
.finally(() => {···});
上面程式碼中，不管promise最後的狀態，在執行完then或catch指定的回撥函式以後，都會執行finally方法指定的回撥函式。
finally方法原始碼
Promise.prototype.finally = function (callback) {
let P = this.constructor;
return this.then(
value => P.resolve(callback()).then(() => value),
reason => P.resolve(callback()).then(() => { throw reason })
);
};
4.promise.all()
promise.all()用於將多個Promise例項包裝成一個新的Promise例項。接受一個陣列作為引數，如果該陣列的元素不是promise物件例項，則使用Promise.resolve()方法將引數轉為Promise例項再處理。另外，promise.all()方法的引數可以不是陣列，但必須具有 iterator 介面，且返回的每個成員都是 promise 例項。
const p = Promise.all([p1, p2, p3]);
上面程式碼中p的狀態由p1、p2、p3決定，有以下兩種情況：
（1）只有p1、p2、p3的狀態都變成fulfilled，p的狀態才會變成fulfilled，此時p1、p2、p3的返回值組成一個陣列，傳遞給p的回撥函式。（都成功，傳返回值陣列，如果沒有返回值，會組成元素為undefined的陣列）
（2）只要p1、p2、p3之中有一個被rejected，p的狀態就變成rejected，此時第一個被reject的例項的返回值，會傳遞給p的回撥函式。（一失敗，傳reject的返回值）
注意！！坑點來襲
1、如果作為引數的 promise 例項，自己定義了catch方法，那麼它一旦被rejected，並不會觸發promise.all()的catch方法。如果沒有自己的catch方法，就會呼叫promise.all()的catch方法。
2、使用all()方法時，傳入的promise物件如果本身定義了then和catch方法，因為這兩個方法都會返回一個新的promise例項，所以呼叫all方法得到的新promise狀態一直都是成功。解釋起來有點繞，結合下面的程式碼看就知道了。
const p1 = new Promise((resolve,reject)=>{
let abc = 10
let a = 10;
let b = 20
if(abc > 30){
resolve(a+b)
}else{
reject(b-a)
}
}).then(function(res){
return res
}).catch(function(err){
console.log(err)
})
const p2 = new Promise((resolve,reject)=>{
let abc = 10
let a = 10;
let b = 20
if(abc > 30){
resolve(a+b+b)
}else{
reject(b-a-a)
}
}).then(function(res){
return res
}).catch(function(err){
console.log(err)
})
const p3 = new Promise((resolve,reject)=>{
let abc = 10
let a = 10;
let b = 20
if(abc > 30){
resolve(a*b)
}else{
reject(b/a)
}
}).then(function(res){
return res
}).catch(function(err){
console.log(err)
})
const p=Promise.all([p1,p2,p3])
p.then(function(){
console.log("正確")
}).catch(function(){
console.log("錯誤")
})
上面的程式碼在abc的值小於30時，就會執行reject方法，當呼叫promise.all()時，應該會輸出錯誤。但是因為p1、p2、p3都有各自的then和catch方法，返回了新的promise例項，又因為這個新例項已經處於完成狀態，所以變數p才會一直處於成功狀態。（小爐寫程式碼的時候還思考了好久，大坑！！！）
5.promise.race()
const p = Promise.race([p1, p2, p3]);
race方法的引數以及對引數中非promise物件的處理都和all方法一致，但是race方法返回的狀態只和陣列中最先改變狀態的例項相同，那個最先改變的 promise 例項的返回值，就傳遞給p的回撥函式。
注意：
（1）如果陣列裡面promise例項執行的速度一樣，返回陣列第一個promise執行的結果
（2）如果陣列裡面promise例項執行的速度不一樣，返回最快的promise執行的結果，結果是失敗就會直接匹配race的catch方法
（3）如果陣列裡面promise例項有成功、有失敗的只要不是返回的結果，失敗的就不影響
6.promise.allsettled()
promise.allsettled()方法接受一組 promise 例項作為引數，包裝成一個新的 promise 例項。只有等到所有這些引數例項都返回結果，不管是fulfilled還是rejected，包裝例項才會結束。該方法由 es2020 引入。
該方法返回的新的 promise 例項，一旦結束，狀態總是fulfilled，不會變成rejected
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.allSettled(promises);
// 過濾出成功的請求
const successfulPromises = results.filter(p => p.status === 'fulfilled');
// 過濾出失敗的請求，並輸出原因
const errors = results
.filter(p => p.status === 'rejected')
.map(p => p.reason);
7.promise.any()
promise.any()跟promise.race()方法很像，只有一點不同，就是不會因為某個 promise 變成rejected狀態而結束。如果所有的promise例項都是rejected，則返回AggregateError: All promises were rejected
經過小爐自己試驗，總結規則如下：
（1）如果陣列裡面promise例項執行的速度不一樣，執行最快的promise結果為成功則返回，為失敗則按照這個規則找第二快的，依次類推。
（2）如果陣列裡面promise例項執行的速度一樣，則返回第一個成功的promise的返回值
8.promise.resolve()
作用：將現有物件轉為 Promise 物件
引數情況：
（1）引數是一個 Promise 例項
如果引數是 promise 例項，那麼promise.resolve將不做任何修改、原封不動地返回這個例項。
（2）引數是一個thenable物件
thenable物件指的是具有then方法的物件，promise.resolve方法會將這個物件轉為 promise 物件，然後就立即執行thenable物件的then方法
let thenable = {
then: function(resolve, reject) {
resolve(42);
}
};
let p1 = Promise.resolve(thenable);
p1.then(function(value) {
console.log(value); // 42
});
上面程式碼中，thenable物件的then方法執行後，物件p1的狀態就變為resolved，從而立即執行最後那個then方法指定的回撥函式，輸出 42。
（3）引數不是具有then方法的物件，或根本就不是物件
如果引數是一個原始值，或者是一個不具有then方法的物件，則promise.resolve方法返回一個新的 promise 物件，狀態為resolved。
（4）不帶有任何引數
promise.resolve()方法允許呼叫時不帶引數，直接返回一個resolved狀態的 promise 物件。
9.promise.reject()
promise.reject(reason)方法也會返回一個新的 promise 例項，該例項的狀態為rejected。
const p = Promise.reject('出錯了');
// 等同於
const p = new Promise((resolve, reject) => reject('出錯了'))
p.then(null, function (s) {
console.log(s)
});
注意：promise.reject()方法的引數，會原封不動地作為reject的理由，變成後續方法的引數。這一點與promise.resolve方法不一致。
五、總結
1.promise的作用：Promise是非同步程式設計的一種解決方案（解決回撥地獄的問題）
2.無法取消promise，一旦新建它就會立即執行，無法中途取消
3.如果不設定回撥函式，promise內部丟擲的錯誤，不會反應到外部
4.當處於pending狀態時，無法得知目前進展到哪一個階段（剛剛開始還是即將完成）
5.promise.then()成功的回撥函式，返回的是一個新的promise例項，可以使用鏈式程式設計，引數來自resolve函式
6.promise。catch()失敗的回撥函式，只寫一個，多寫無意義，通常寫在最後，引數來自reject函式
7.promise.all()監聽所有的promise例項狀態，全成功則成功，一失敗則失敗
8.promise.allsettled()監聽所有的promise例項狀態,等到所有這些引數例項都返回結果才結束，結束時狀態總是fulfilled，不會變成rejected
9.promise.any()不會因為某個 promise 變成rejected狀態而結束。如果所有的promise例項都是rejected，則返回AggregateError: All promises were rejected
10.promise.race()返回的狀態只和陣列中最先改變狀態的例項相同，那個最先改變的 promise 例項的返回值，就傳遞給p的回撥函式。
11.promise.finally()不管 promise 物件最後狀態如何，都會執行的操作
12.promise.resolve()和promise.reject()都返回一個promise例項，但是promise.reject()方法的引數，會原封不動地作為reject的理由，變成後續方法的引數