Promise方法如何在ES6中使用

本篇文章給大家分享的是有關Promise方法如何在ES6中使用，小編覺得挺實用的，因此分享給大家學習，希望大家閱讀完這篇文章后可以有所收獲，話不多說，跟著小編一起來看看吧。

1、什么是Promise

我的理解是：實現讓我們用同步的方式去寫異步代碼的一種技術。是異步解決方案的一種。

他可以將多個異步操作進行隊列化，讓它們可以按照我們的想法去順序執行。

那么，Promise之前有沒有其他的異步解決方案。肯定是有的，常見的有callback回調函數以及事件。

那Promise有啥優勢，我認為Promise功能更為強大，且能讓我們代碼寫的更為清晰

• Promise提供了統一的API, 讓我們控制異步操作更加容易
• Promise可以避免callback回調函數的層層嵌套，使代碼更為清晰。可讀性性與維護性更高
   

2、Promise基本用法

首先，我們先來了解一些Promise的基本概念

2.1、Promise狀態

Promise一共有3中狀態，分別是Pending（進行中）、Resolved（已完成，又稱Fulfilled）和Rejected（已失敗）
狀態的改變只可能從Pending轉------>Resolved,或者從Pending------->Rejected。并且狀態一旦發生改變，就不會再更改了。而觸發狀態發生改變的，只有異步操作的結果。結果為成功 觸發狀態變更為 Resolved, 結果失敗或者中途發生錯誤，則會觸發狀態變更為 Rejected

2.2 Promise結構

Promise是一個構造函數，故通過new Promise()可以實例化出來一個Promise對象

new Promise()時，接受一個函數作為參數，且這個函數，有兩個參數，分別是resolve,reject。 而resolve和 reject也是兩個函數。他們由JavaScript引擎提供，不用自己部署。

每一個被實例化出來的promise實例，都有.then() 和 .catch() 兩個方法。且這兩個方法的調用支持鏈式操作

好，了解完概念，我們看看Promise的基本用法

首先，如何實例化一個promise對象

const promise = new Promise((resolve, reject) => {
	setTimeout(() => {
		if (/* 成功 */) {
			resolve(res)
		} else {
			reject(err)
		}
	}, 100)
})

上圖中，通過new Promise() 實例化了一個promise實例，注意：new Promise()方法中的函數是一個立即執行函數，即，在new Promise()的一瞬間就會被執行。函數內代碼是同步代碼。

resolve和reject用于返回異步操作的結果，當使用resolve()時，promise狀態會由Pending—>Resolved, 并將異步的正確結果返回。當使用reject()時，promise狀態由Pending---->Rejected，并將錯誤信息返回

再看這個對象如何接收返回的結果

promise.then((res) => {
	console.log(res)
}).catch((err) => {
	console.log(err)
})

上圖中，.then的回調函數 和 .catch的回調函數分別用來接收resolve()返回的正確信息和reject返回的錯誤信息。

下面我們來詳細看下.then() 和 .catch()

.then() 函數

then()函數是Promise實例的一個方法，他的作用是為Promise實例添加狀態改變時的回調函數
它存在以下特點

1. then()是添加在Promise的原型上的。即Promise.prototype.then(), 故所有Promise實例都存在.then()方法
2. .then()可以進行鏈式操作 即promise.then().then().then()，then的回調函數將會按照次序調用
3. .then()函數存在兩個參數，這兩個參數一般情況下是函數。其中，第一個函數是在狀態變為Resolved的時候才會執行(我們下文中統稱為.then的resolve回調)，并且參數是Promise對象resolve(res)時的值。第二個函數是在狀態變為Rejected的時候才會執行(我們下文統稱為.then的reject回調)，后面我們會說哪幾種情況下，狀態會變成Rejected
4. Promise會存在值穿透的情況，當我們then()的兩個參數不為函數時，會穿透到下一個then()里面，如果下一個then()參數也不是函數，則會繼續向下穿透
5. 我們上面說過了，Promise實例resolve()方法執行時，會將實例的狀態變更為Resolved，故.then的resolve回調會在當前Promise實例resolve()時被觸發
    

下面，我們重點來分析下第2，3，4，5

function getData(url) {
 return new Promise((resolve, reject) => {
 setTimeout(() => {
  if (url) {
  resolve({
   code: 200,
   message: 'ok',
   data: 123
  })
  } else {
  reject(new Error('缺少url'))
  }
 }, 100)
 })
}
getData('http://www.baidu.com').then((res) => {
 console.log('第一個回調')
 console.log(res)
}).then((res) => {
 console.log('第二個回調')
 console.log(res)
}).then((res) => {
 console.log('第三個回調')
 console.log(res)
})
// 第一個回調
// { code: 200, message: 'ok', data: 123 }
// 第二個回調
// undefined
// 第三個回調
// undefined

可以看出，首先，當getData() resolve() 執行時 .then的resolve回調函數被依次調用，但是只有第一個then()的resolve回調函數的參數有值，而其他兩個是undefind，這是為什么呢？我們再來看一個代碼

getData('http://www.baidu.com').then((res) => {
 console.log('第一個回調')
 console.log(res)
 return Promise.resolve()
}).then((res) => {
 console.log(res)
})
// 第一個回調
// { code: 200, message: 'ok', data: 123 }
// undefined

看這個代碼我們可以發現，上一個then的resolve回調當return一個Promise.resolve()時，和我們不return 任何東西時得到的結果是一樣的。那我們是不是可以理解為，每個.then()方法的resolve回調函數，執行完后默認都會返回一個Promise.resolve()。沒錯，我告訴你，是的。

至于Promise.resolve()得到的是一個什么，我先告訴你，他得到的是一個resolve狀態的Promise實例。這個后面我們會再講。

此時，我們可以總結出：從第二個.then()開始，調用這個.then的resolve回調函數的-----是上一個.then的resolve回調所返回的Promise實例。而.then回調函數的參數，便是上一個.then的回調函數所返回的Promise實例resolve的值。下面我們看一段代碼驗證一下

getData('http://www.baidu.com').then((res) => {
 console.log('第一個回調')
 console.log(res)
 return new Promise((resolve, reject) => {
 resolve('123')
 })
}).then((res) => {
 console.log(res)
})

// 第一個回調
// { code: 200, message: 'ok', data: 123 }
// 123

總結：

1. 每一個.then的resolve回調都會返回默認返回一個Resolved狀態的Promise對象
2. 當你收到return了一個新的Promise實例時，會覆蓋默認返回的Promise實例
3. 返回的Promise實例resolve()的值，會作為下一個.then的resolve回調的參數返回
    

下面我們再來看下，如果then()的參數不是函數，那會怎么樣，下面，我們看一段代碼

var getData = function() {
 return new Promise(function(resolve, reject) {
  resolve(123)
 });
};
getData().
then(345)
.catch(err => {
 console.log('捕捉到一個錯誤')
 console.log(err)
}).then((res) => {
 console.log('我是第二個then')
 console.log(res)
})
// 輸出
我是第二個then
123

如上圖，可以看到，當我們第一個then的resolve回調不是函數，而是一個數字345時，resolve(123)穿透到第二個then中了，觸發了第二個then的resolve回調執行，并將resolve的返回值給了第二個then的resolve回調。這種現象，叫做值穿透。

var getData = function() {
 return new Promise(function(resolve, reject) {
  reject(new Error(123))
 });
};
getData().
then(345)
.catch(678)
.then((res) => {
 console.log('我是第二個then')
 console.log(res)
}).catch(err => {
 console.log('我是第二個catch')
 console.log(err)
})
// 輸出
我是第二個catch
Error: 123

可以看到，報錯時，同樣發生了值穿透

到此，.then()相關以及 then()的第一個參數就講完了，而第二個參數，我們放到.catch()方法中一起將

.catch() 函數

catch()也是掛載在Promise對象原型下的方法(Promise.prototype)，和then()一樣, 故所有Promise對象也都有catch方法。它的作用是用來指定發生錯誤時的回調函數，也就是捕獲異步操作所發生的錯誤
它有什么特點呢。我們先總結一下，后來再一一來驗證

1. .catch()會指定一個參數作為錯誤發生時的回調，故catch((err) => {})的參數會在Promise狀態變更為Rejected時被觸發。
2. .then(null, (err) => {})的第二個參數，也是在Promise狀態變更為Rejected時被觸發。故其實.catch()和 .then()的reject回調函數本質上是一樣的，只是寫法不一樣。但我們一般更傾向于使用.catch()而不使用.then的reject回調。原因后面會講
3. 代碼拋出錯誤和reject()函數執行都會讓Promise對象的狀態轉變為Rejected，故兩種情況都會觸發catch()的回調執行或者then()的reject回調執行。 所以，reject()的本質，其實就是拋出一個錯誤
4. .catch()的回調函數以及.then的reject回調一樣，執行時默認都會返回一個狀態為Resolved的Promise對象（也就是 return Promise.resolve()）
5. .catch()和.then()一樣，也可以寫多個，也支持鏈式操作，原因就是上面的第三點
6. 拋出的錯誤一旦被catch捕獲，便不會再向外傳播，只有再次向外拋出錯誤，才會繼續被后面的catch所捕獲。故錯誤具有冒泡性質，會一步一步向外傳播，直到被catch捕獲
    

1、我們先看第一點：

var getData = function() {
 return new Promise(function(resolve, reject) {
  reject(123)
 });
};
getData().then((res) => {
 console.log('成功')
}).catch((err) => {
 console.log('捕捉到錯誤')
 console.log(err)
})

// 捕捉到錯誤
// 123

毫無疑問，reject(123)拋出一個錯誤，catch的回調捕捉到錯誤，并輸出

2、再看第二點：

var getData = function() {
 return new Promise(function(resolve, reject) {
  reject(123)
 });
};
getData().then((res) => {
 console.log('成功')
}, (err) => {
	console.log('捕捉到一個錯誤')
	console.log(err)
})

// 捕捉到錯誤
// 123

從代碼上也可以看出，上面這兩種方式是一樣的。

現在，我來說說為什么建議使用catch() ,而不推薦使用then()的reject回調呢。看下下面的代碼

var getData = function() {
 return new Promise(function(resolve, reject) {
  resolve(123)
 });
};
getData().then((res) => {
 console.log('成功')
 return new Promise((resolve, reject) => {
  reject(new Error('123'))
 })
}, (err) => {
	console.log('捕捉到一個錯誤')
	console.log(err)
})

// 成功

此時，只輸出了成功, 而then的resolve回調中所拋出的錯誤，并沒有被捕捉到

再看下面一段代碼

var getData = function() {
 return new Promise(function(resolve, reject) {
  resolve(123)
 });
};
getData().then((res) => {
 console.log('成功')
 return new Promise((resolve, reject) => {
  reject(new Error('123'))
 })
}).catch((err) => {
	console.log('捕捉到一個錯誤')
	console.log(err)
})

成功
捕捉到一個錯誤
Error: 123

看，同樣的錯誤，但是使用catch()，可以捕捉到，而使用then()的reject回調，卻捕捉不到。

結論：catch()可以通過放到操作鏈的最底部而捕捉到任意地方（指的是Promise內）的錯誤。而then()的reject回調，只能捕捉到這個.then()執行之前的錯誤，當前執行的then的resolve回調內的錯誤無法捕捉到，后面再執行的代碼所拋出的錯誤也無法捕捉到。并且.catch的寫法，代碼層面也更為清晰

var getData = function() {
 return new Promise(function(resolve, reject) {
  resolve(123)
 });
};
getData().then((res) => {
 console.log('成功')
 return new Promise((resolve, reject) => {
  reject(new Error('123'))
 })
}, (err) => {
 console.log('第一個錯誤捕捉')
}).then((res) => {
 console.log('第二個resolve回調')
}, err => {
 console.log('第二個錯誤捕捉')
})

成功
第二個錯誤捕捉

如上圖中，第一個then的resolve回調中拋出的錯誤被第二個then中reject回調所捕捉

故 結論：一般情況下，不要去用then的第二個參數，而盡可能的去用.catch()方法去捕捉錯誤

3、下面我們再看第三點

var getData = function() {
 return new Promise(function(resolve, reject) {
  resolve(x)
 });
};
getData().then((res) => {
 console.log('成功')
}).catch(err => {
 console.log('捕捉到一個錯誤')
 console.log(err)
 throw new Error('我拋出了一個錯誤')
}).catch(err => {
 console.log('我也捕捉到了一個錯誤')
 console.log(err)
})

捕捉到一個錯誤
ReferenceError: x is not defined
我也捕捉到了一個錯誤
Error: 我拋出了一個錯誤

上面代碼可以看出，不是只有reject()執行了才會拋出一個錯誤，x未定義，系統會自動拋出一個錯誤，throw new Error是我們自己手動拋出一個錯誤。而這些都會使得Promise對象的狀態變更為Rejected,從而觸發catch。
同時上面的代碼我們還可以看出我們上面寫的第六點，錯誤會冒泡式向外傳播，當被catch之后，便不會再進行傳播了。直到再次拋出錯誤。上面代碼中，第一個錯誤被第一個catch捕獲后，原本第二個catch是不會再走的，但因為在第一個catch中又拋出了一個錯誤，才導致了第二個catch的執行。

4、下面我們再看第四點（catch()的回調函數也會返回一個狀態是Resolved的Promise實例）
其實這一點，我們從上面那張圖中也是可以看出來的，第一個catch()的回調原本是要返回了一個Resolved狀態的Promise，但是因為throw了一個錯誤，導致這個Promise實例狀態變更為Rejected并返回，而變成成Rejected變觸發了第二個catch的回調執行

我們看下下面的代碼，再次驗證下

var getData = function() {
 return new Promise(function(resolve, reject) {
  resolve(x)
 });
};
getData().then((res) => {
 console.log('成功')
}).catch(err => {
 console.log('捕捉到一個錯誤')
 console.log(err)
}).then((res) => {
 console.log('我是第二個then')
})

捕捉到一個錯誤
ReferenceError: x is not defined
我是第二個then

上面代碼可以看出，catch的回調執行后，后面的then依然被執行了，為什么，就是因為catch的回調執行后默認返回了一個Resolved狀態的Promise實例（return Promise.resolve()）

第五點，第六點我們已經驗證過了。不再多說。

實現簡單的axios

axios我們比較常用，大家應該都發現了，axios的使用方式，和Promise好像是一樣的，

axios({
 url:'http://www.baidu.com',
 method: 'post',
 data: {}
}).then((res) => {
 console.log(res)
}).catch((err) => {
 console.log(err)
})

沒錯。axios就是一個Promise實例。他是一個用Promise來封裝的一個XMLHttpRequest
下面我們也來實現一個簡單的axios

function MyAxios(option) {
 return new Promise((resolve, reject) => {
  const http = new XMLHttpRequest()
  http.open(option.method, option.url);
  http.responseType = "json";
  http.setRequestHeader("Accept", "application/json");
  http.onreadystatechange = myHandler;
  http.send();

  function myHandler() {
   if (this.readyState !== 4) {
    return;
   }
   if (this.status === 200) {
    resolve(this.response);
   } else {
    reject(new Error(this.statusText));
   }
  }
 })
}
MyAxios({
 url:'http://www.baidu.com',
 method: 'post'
}).then((res) => {
 console.log(res)
}).catch((err) => {
 console.log(err)
})

Promise.all, Promise.race 以及兩者的區別

1、Promise.all

Promise.all()可以并行執行多個Promise(), 并返回一個新的Promise實例

var p = Promise.all([p1, p2, p3]); // p1,p2,p3為3個Promise實例

Promise.all（）的參數不一定是數組，只要具有Iterator接口的數據都可以（Iterator是一個遍歷器，我這里就不做過多介紹，感興趣的可以自己去官網看看）。但是參數遍歷后返回的成員必須必須是Promise對象（如上面的，p1,p2,p3都必須是Promise對象，如果不是，則會先調用Promise.resolve(p1)將他轉化為Promise實例）

那么，Promise.all()返回的Promise實例的狀態是如何定義的。

• 只有參數的各個成員(p1,p2,p3)狀態都變成Resolved，p的狀態才會變成Resolved,
• 參數的各個成員中，有任意一個狀態變成Rejected, p的狀態都會立刻變成Rejected
   

function getData (data) {
 return new Promise((resolve, reject) => {
  setTimeout(() => {
   if (data === 6) {
    reject(new Error('請求發生錯誤了'))
   } else {
    resolve(data)
   }
  }, data * 500)
 })
}
const promises = [1,3,5,7].map((item) => {
 return getData(item)
})
Promise.all(promises)
.then((res) => {
 console.log('請求成功')
 console.log(res)
}).catch((err) => {
 console.log('請求失敗')
 console.log(err)
})

// 3.5s后輸出
請求成功
[ 1, 3, 5, 7 ]

如上圖, 最后一個成員(上圖中7返回的promise實例)的狀態是在3.5s后才變更為Resolved，故.then()的resolve回調在3.5s后才執行

function getData (data) {
 return new Promise((resolve, reject) => {
  setTimeout(() => {
   if (data === 6) {
    reject(new Error('請求發生錯誤了'))
   } else {
    resolve(data)
   }
  }, data * 500)
 })
}
const promises = [2,4,6,8].map((item) => {
 return getData(item)
})
Promise.all(promises)
.then((res) => {
 console.log('請求成功')
 console.log(res)
}).catch((err) => {
 console.log('請求失敗')
 console.log(err)
})

// 3s后輸出
請求失敗
Error: 請求發生錯誤了

上圖可以看出，當我們改用 2，4，6，8去得到promise成員時，第3s得時候 發生了錯誤，此時，Promise.all()返回得Promise實例得狀態立刻變更為Rejected，catch()的回調立即觸發。故輸出錯誤

2、Promise.race()

Promise.race()和Promise.all()的作用是一樣的，都是并發處理多個Promise實例，并返回一個新的實例。
而區別在于，兩者返回的新的Promise實例的狀態改變的時機不同。

Promise.all是 所有Promise子成員狀態都變為Resolved, 新的Promise實例狀態才會變成Resolved。中途如果有任何一個子成員狀態變成了Rejected，新的Promise實例的狀態就會立刻變為Rejected

Promise.race是 只要子成員中，有任何一個的狀態發生了變化(不管是變成Resolved還是Rejected)，那么返回的新的Promise實例的狀態也會立刻發生變化，而變化的狀態就是那個子成員所變化的狀態。

function getData (data) {
 return new Promise((resolve, reject) => {
  setTimeout(() => {
   if (data === 6) {
    reject(new Error('請求發生錯誤了'))
   } else {
    resolve(data)
   }
  }, data * 500)
 })
}
const promises = [2,4,6,8].map((item) => {
 return getData(item)
})
Promise.race(promises)
.then((res) => {
 console.log('請求成功')
 console.log(res)
}).catch((err) => {
 console.log('請求失敗')
 console.log(err)
})

// 1s后輸出
請求成功
2

上圖可以看出，1s后 第一個子成員狀態變更為Resolved，那么返回的新Promise實例狀態也立馬變更為Resolved，故1s后.then()的resolve回調執行。輸出請求成功.

最后，我們來說一說前面用到了的Promise.resolve()吧

Promise.resolve和Promise.reject

Promise.resolve()

前面我們說到過 Promise.resolve可以返回一個狀態是Resolved的Promise對象。沒錯，其實它等同于

new Promise((resolve, reject) => {
 resolve()
})

當Promise.resolve()有參數時，會返回一個Promise對象的同時，將參數做作為then()resolve回調的參數返回（當參數是thenable對象除外，后面會將）。主要有以下幾種情況

1、參數是一個Promise對象時

將會直接返回這個參數，不做任何更改

2、參數是thenable對象時，（即，存在.then()方法的對象），如下

let obj= {
 then: function(resolve, reject) {
 resolve('我是thenable對象');
 }
};

此時，Promise.resolve(obj) 會返回一個Promise對象，并且調用obj的then()方法，哎，這里注意了，這個.then()并不是 新Promise對象的.then() , obj的then()會立即執行，可不代表 新的Promise對象的then() 的回調也會執行， 還記得嗎，我們前面說的Promise對象的then()的回調執行的條件是這個Promise對象的狀態發生變化了才會執行。

let obj= {
 then: function(resolve, reject) {
  console.log(123)
 }
};
 
let p1 = Promise.resolve(obj);
p1.then(function(value) {
 console.log('成功')
 console.log(value); // 42
});
// 輸出
123

從上圖可以看出來，立即執行了obj.then()，但Promise的then的回調并沒有被執行

3、參數不是對象，或者說是沒有.then方法的對象

會返回一個Promise實例，并將參數作為.then()的resolve回調的參數返回

如，Promise.resolve(‘123') 等價于

new Promise((resolve, reject) => {
 resolve('123')
})

4、不帶參數，即Promise.resolve()，也就是我們前面說的。

返回了一個Resolved狀態的Promise對象，但是.then()的resolve回調沒有參數。

new Promise((resolve, reject) => {
 resolve()
}).then((res) => {
	console.log(res)
})
// 輸出
undefined

Promise.resolve()

Promise.reject() 也是返回一個Promise對象，只是這個對象的狀態是Rejected
至于參數的用法和Promise.resolve()完全一樣，唯一的區別是沒有thenable參數一說，也就是說有參數時，參數不論哪種情況，都會被當做catch()的回調參數返回。

以上就是Promise方法如何在ES6中使用，小編相信有部分知識點可能是我們日常工作會見到或用到的。希望你能通過這篇文章學到更多知識。更多詳情敬請關注億速云行業資訊頻道。