promise用了這麼多年了，一直也沒有系統整理過。今天整理整理promise的相關東西，感興趣的可以一起看一看。我盡量用更容易了解的語言來剖析一下promise

我準備分兩篇文章來說明一下promise

一篇來了解和使用promise（本篇）另一篇來從promise使用功能的角度來剖析下promise的源碼（下一篇）

我準備從以下幾點來慢慢了解Promise

1、Promise,Promise存在的意義

2、Promise基本用法

3、.then()函數

4、.catch()函數

5、實作簡單的axios

6、Promise.all, Promise.race 以及兩者的差別

7、Promise.resolve和Promise.reject

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執行個體添加狀态改變時的回調函數

它存在以下特點

then()是添加在Promise的原型上的。即Promise.prototype.then(), 故所有Promise執行個體都存在.then()方法
.then()可以進行鍊式操作即promise.then().then().then()，then的回調函數将會按照次序調用
.then()函數存在兩個參數，這兩個參數一般情況下是函數。其中，第一個函數是在狀态變為Resolved的時候才會執行(我們下文中統稱為.then的resolve回調)，并且參數是Promise對象resolve(res)時的值。第二個函數是在狀态變為Rejected的時候才會執行(我們下文統稱為.then的reject回調)，後面我們會說哪幾種情況下，狀态會變成Rejected
Promise會存在值穿透的情況，當我們then()的兩個參數不為函數時，會穿透到下一個then()裡面，如果下一個then()參數也不是函數，則會繼續向下穿透
我們上面說過了，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

從上面代碼，我們可以看出兩點

1、then()方法被鍊式調用了，從這裡我們其實是可以看出一點東西的。首先，我們知道，隻有對象，才可以去調用他的方法。那是不是說明，上面的3個.then()分别是3個對象是調用了呢。首先第一個.then()，毫無疑問，getData()得到的是一個Promise對象，這個Promise對象，調用了他自己的then()方法，而第二個.then(),是在getData().then()之後被調用，那麼我們是不是就可以看出一點，getData().then()其實也傳回了一個對象。這個對象也是個Promise對象，也有他自己的then()。第三個.then()也是同理。故，我們得出結論：每一個then()方法被調用後内部其實都會傳回一個新得Promise對象，而隻要是Promise對象，都有.then()方法，故而，實作了鍊式調用。
2、當getData() resolve() 執行時 .then的resolve回調函數被依次調用，但是隻有第一個then()的resolve回調函數的參數有值，而其他兩個是undefind，這是為什麼呢？我們再來看一個代碼

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

看上面代碼咱好像發現，第二個then中resolve回調得參數好像是第一個then得resolve回調函數得傳回值啊。我告訴你，是的。這是怎麼回事呢！

答：上面我們已經說過了，每一個.then()内部都傳回了一個Promise對象，那麼第二個.then必定是這個新傳回得Promise對象所調用得，那第二個.then的resolve()回調的參數肯定也就是第一個.then()内部傳回的Promis對象所resolve(res）的值。進而，我們不難推測出。then函數内部的基礎邏輯是如下的

Promise.prototype.then = (Resolved, Rejected) => {
	return new Promise((resolve, reject) => {
		// 定義一個變量存儲then的resolve回調函數的傳回值
		let x
		if (this.status === 'fulFilled') { // 狀态是成功時
			x = Resolved()
			resolve(x)
		} else if (this.status === 'rejected') { // 狀态是失敗時
			x = Rejected()
			reject(x)
		}
	})
}

現在，我們就不難了解之前為什麼後面2個.then()的resolve()回調函數的參數是undefind了，是因為第一個then()的resolve回調函數并沒有return 值，而沒有return 預設return的就是一個undefind

但是。上圖中Resolved（）回調所傳回的值，是有幾種情況的

1、第一個then的resolve回調當傳回的是一個普通值時，就像上圖一樣，直接被resolve()
2、如果then的resolve回調傳回的是一個Promise對象時。那麼會将這個Promise對象的狀态做為then函數傳回的Promise對象的狀态，将這個Promise對象resolve()或者reject()的值作為then函數傳回的Promise對象被resolve()或者reject()的值

下面我們看一段代碼驗證一下

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

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

總結：

每一個.then函數都會傳回預設傳回一個Resolved狀态的Promise對象
這個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方法。它的作用是用來指定發生錯誤時的回調函數，也就是捕獲異步操作所發生的錯誤

它有什麼特點呢。我們先總結一下，後來再一一來驗證

.catch()會指定一個參數作為錯誤發生時的回調，故catch((err) => {})的參數會在Promise狀态變更為Rejected時被觸發。
.then(null, (err) => {})的第二個參數，也是在Promise狀态變更為Rejected時被觸發。故其實.catch()和 .then()的reject回調函數本質上是一樣的，隻是寫法不一樣。但我們一般更傾向于使用.catch()而不使用.then的reject回調。原因後面會講
代碼抛出錯誤和reject()函數執行都會讓Promise對象的狀态轉變為Rejected，故兩種情況都會觸發catch()的回調執行或者then()的reject回調執行。是以，reject()的本質，其實就是抛出一個錯誤
.catch()的回調函數以及.then的reject回調一樣，執行時預設都會傳回一個狀态為Resolved的Promise對象（也就是 return Promise.resolve()）
.catch()和.then()一樣，也可以寫多個，也支援鍊式操作，原因就是上面的第三點
抛出的錯誤一旦被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執行個體

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()的回調參數傳回。也就是說參數沒有前面1，2，3種的差別。大家可以去試試，我就不過多說明了。

Promise的使用就說到這裡了。下一次給大家帶來從功能的角度來看Promise的源碼敬請期待。喜歡的話，點個贊吧！！

ES6 之 Promise用法詳解 1、什麼是Promise 2、Promise基本用法 .then() 函數 .catch() 函數實作簡單的axios Promise.all, Promise.race 以及兩者的差別 Promise.resolve和Promise.reject

1、什麼是Promise

2、Promise基本用法

2.1、Promise狀态

2.2 Promise結構

.then() 函數

.catch() 函數

實作簡單的axios

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

1、Promise.all

2、Promise.race()

Promise.resolve和Promise.reject

Promise.resolve()

Promise.resolve()

繼續閱讀

JavaScript自學筆記【4】函數的聲明與調用目錄二、函數的聲明三、函數的調用

請求逾時VUE axios重新再次請求

nodejs微信開發---授權登入+擷取使用者資訊微信網頁授權

debian9更新4.9.0核心到4.19.2核心過程

Javascript建構Bingo卡片遊戲

JavaScript的那些坑之事件代理事件代理事件階段

javascript的for (var i in data)慎用javascript中的for (var i in data)謹慎用

jquery_126_demo

tab滑鼠經過菜單切換

vue （vue2.0）使用總結(從大體結構總結)

vue搭建過程及出現問題

/\B(?=(?:\d{3})+$)/g 一條令人費解的正規表達式

适用于JavaScript的ECMAScript 2020規範向前發展

JS生成uuid的四種方法

layui多任務上傳添加進度條

ES6 之 Promise用法詳解 1、什麼是Promise 2、Promise基本用法 .then() 函數 .catch() 函數 實作簡單的axios Promise.all, Promise.race 以及兩者的差別 Promise.resolve和Promise.reject

1、什麼是Promise

2、Promise基本用法

2.1、Promise狀态

2.2 Promise結構

.then() 函數

.catch() 函數

實作簡單的axios

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

1、Promise.all

2、Promise.race()

Promise.resolve和Promise.reject

Promise.resolve()

Promise.resolve()

繼續閱讀

ES6 之 Promise用法詳解 1、什麼是Promise 2、Promise基本用法 .then() 函數 .catch() 函數實作簡單的axios Promise.all, Promise.race 以及兩者的差別 Promise.resolve和Promise.reject