ES6語法——Promise對象
一、概念
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('//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的理由，變成後續方法的參數
