是的,很多東西都需要寫下來。看了會忘記,在寫的同時會加深記憶,以後找起來也方便。
原文鏈接:http://es6.ruanyifeng.com/#docs/promise
含義
Promise是異步編程的一種解決方案。相比於回調函數和事件,更好更強大。
Promise一個承諾,保存着某個未來纔會結束的事件的結果(通常是異步操作事件的結果)。
Promise對象有以下特點:
- 對象的狀態不受外界影響。只用異步操作的結果,可以決定Promise的狀態。有三種狀態,Pending(進行中)、Resolved(已完成)、Reject(失敗)。
- 一旦狀態改變,就不會在變。任何時候都可以得到結果。
Promise的缺點:
- 無法取消Promise,一旦新建它就會立即執行,無法中途取消。
- 如果不設置回調函數,Promise內部拋出的錯誤,不會反應到外部。
- 處於Pending階段時,無法得知目前處於哪一個狀態(剛剛開始還是即將完後)。
基本用法
創造一個Promise
var promise = new Promise((resolve, reject) => {
// 異步操作
if(/* 異步操作成功 */) {
resolve(data);
} else {
reject(err);
}
})
Promise接受兩個參數一個函數作爲參數,函數的兩個參數是resolve和reject。它們是兩個函數,有JavaScript引擎提供。分別表示異步操作成功和失敗。data指的是異步操作返回的結果。如果異步操作失敗了,將異步操作報出的錯誤,作爲reject的參數。
Promise實例生成以後,可以使用then方法制定Resolved狀態和Rejected狀態的回調函數。
promise.then(function(value) {
// success
}, function(err) {
// error
})
then函數的兩個參數都是函數,其中第一個表示異步操作成功(狀態是Resolved)時候調用,第二個是異步操作失敗時(狀態是Rejected)調用。其中其二個參數可以省略。
Promise新建後就會立即執行
let promise = new Promise(function(resolve, reject) {
console.log('Promise');
resolve();
});
promise.then(function() {
console.log('Resolved.');
});
console.log('Hi!');
// Promise
// Hi!
// Resolved
上面代碼中,Promise新建後立即執行,所以首先輸出的是“Promise”。然後,then方法指定的回調函數,將在當前腳本所有同步任務執行完纔會執行,所以“Resolved”最後輸出。
下面是用Promise實現Ajax的例子:
function getJSON = function(url) {
var promise = new Promise(function(resolve, reject){
var xhr = new XMLHttpRequest();
xhr.open('get', url);
xhr.setRequestHeader("Accept", "application/json");
xhr.send();
xhr.onreadystatechange = function() {
if(xhr.readyState === 4 && xhr.status = 200) {
resolve(xhr.response);
} else {
reject(new Error(this.statusText));
}
}
})
return promise;
}
getJSON('test.json').then(function(json) {
console.log(json);
}, function(error) {
console.log(error);
})
如果調用resolve函數和reject函數時帶有參數,那麼它們的參數會被傳遞給回調函數。reject函數的參數通常是Error對象的實例,表示跑出的錯誤;resolve的參數除了正常的數據以外,還可能是另一個Promise實例。
var p1 = new Promise(function (resolve, reject) {
// ...
});
var p2 = new Promise(function (resolve, reject) {
// ...
resolve(p1);
})
上面代碼中,p1和p2都是Promise的實例,但是p2的resolve方法將p1作爲參數,即一個異步操作的結果是返回另一個異步操作。
注意,這時p1的狀態就會傳遞給p2,也就是說,p1的狀態決定了p2的狀態。如果p1的狀態是Pending,那麼p2的回調函數就會等待p1的狀態改變;如果p1的狀態已經是Resolved或者Rejected,那麼p2的回調函數將會立刻執行。
var p1 = new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('fail')), 3000)
})
var 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秒之後變爲rejected。p2的狀態在1秒之後改變,resolve方法返回的是p1。此時,由於p2返回的是另一個Promise,所以後面的then語句都變成針對後者(p1)。又過了2秒,p1變爲rejected,導致觸發catch方法指定的回調函數。
.then/.catch
Promise.protype.catch方法是.then(null, rejection)的別名,用於指定發生錯誤時的回調函數。
推薦在.then中只處理成功時的狀態,使用.catch處理失敗的狀態。這樣.catch也可以處理包含.then在內的之前的所有出現的錯誤。
前面說了一旦Promise的狀態改變了,就不會再改變了。
var promise = new Promise(function(resolve, reject) {
resolve('ok');
throw new Error('test');
});
promise
.then(function(value) { console.log(value) })
.catch(function(error) { console.log(error) });
// ok
上面代碼中,在resolve後跑出錯誤,這時Promise的狀態已經變成Resolve了,無法再次改變。
Promise對象拋出的錯誤不會傳遞到外層代碼,即不會有任何反應。
var someAsyncThing = function() {
return new Promise(function(resolve, reject) {
// 下面一行會報錯,因爲x沒有聲明
resolve(x + 2);
});
};
someAsyncThing().then(function() {
console.log('everything is great');
});
上面代碼中,someAsyncThing函數產生的Promise對象會報錯,但是由於沒有指定catch方法,這個錯誤不會被捕獲,也不會傳遞到外層代碼,導致運行後沒有任何輸出。注意,Chrome瀏覽器不遵守這條規定,它會拋出錯誤“ReferenceError: x is not defined”。
var promise = new Promise(function(resolve, reject) {
resolve('ok');
setTimeout(function() { throw new Error('test') }, 0)
});
promise
.then(function(value) { console.log(value) })
.catch(function(err) { console.log(err) });
// ok
// Uncaught Error: test
上面代碼中,Promise 指定在下一輪“事件循環”再拋出錯誤,結果由於沒有指定使用try…catch語句,就冒泡到最外層,成了未捕獲的錯誤。因爲此時,Promise的函數體已經運行結束了,所以這個錯誤是在Promise函數體外拋出的。
Node 有一個unhandledRejection事件,專門監聽未捕獲的reject錯誤。
process.on('unhandledRejection', function (err, p) {
console.error(err.stack)
});
上面代碼中,unhandledRejection事件的監聽函數有兩個參數,第一個是錯誤對象,第二個是報錯的Promise實例,它可以用來了解發生錯誤的環境信息。。
需要注意的是,catch方法返回的還是一個 Promise 對象,因此後面還可以接着調用then方法。
Promise.all()
Promise.all方法用於將多個Promise實例,包裝成一個新的Promise實例。
var p = Promise.all([p1, p2, p3]);
上面代碼中,Promise.all方法接受一個數組作爲參數,p1、p2、p3都是Promise對象的實例,如果不是,就會先調用下面講到的Promise.resolve方法,將參數轉爲Promise實例,再進一步處理。(Promise.all方法的參數可以不是數組,但必須具有Iterator接口,且返回的每個成員都是Promise實例。)
p的狀態由p1、p2、p3決定,分成兩種情況。
(1)只有p1、p2、p3的狀態都變成fulfilled,p的狀態纔會變成fulfilled,此時p1、p2、p3的返回值組成一個數組,傳遞給p的回調函數。
(2)只要p1、p2、p3之中有一個被rejected,p的狀態就變成rejected,此時第一個被reject的實例的返回值,會傳遞給p的回調函數。
下面是一個具體的例子。
// 生成一個Promise對象的數組
var promises = [2, 3, 5, 7, 11, 13].map(function (id) {
return getJSON("/post/" + id + ".json");
});
Promise.all(promises).then(function (posts) {
// ...
}).catch(function(reason){
// ...
});
上面代碼中,promises是包含6個Promise實例的數組,只有這6個實例的狀態都變成fulfilled,或者其中有一個變爲rejected,纔會調用Promise.all方法後面的回調函數。
下面是另一個例子。
const databasePromise = connectDatabase();
const booksPromise = databasePromise
.then(findAllBooks);
const userPromise = databasePromise
.then(getCurrentUser);
Promise.all([
booksPromise,
userPromise
])
.then(([books, user]) => pickTopRecommentations(books, user));
上面代碼中,booksPromise和userPromise是兩個異步操作,只有等到它們的結果都返回了,纔會觸發pickTopRecommentations這個回調函數。
Promise.race()
Promise.race方法同樣是將多個Promise實例,包裝成一個新的Promise實例。
var p = Promise.race([p1, p2, p3]);
上面代碼中,只要p1、p2、p3之中有一個實例率先改變狀態,p的狀態就跟着改變。那個率先改變的 Promise 實例的返回值,就傳遞給p的回調函數。
Promise.race方法的參數與Promise.all方法一樣,如果不是 Promise 實例,就會先調用下面講到的Promise.resolve方法,將參數轉爲 Promise 實例,再進一步處理。
下面是一個例子,如果指定時間內沒有獲得結果,就將Promise的狀態變爲reject,否則變爲resolve。
const p = Promise.race([
fetch('/resource-that-may-take-a-while'),
new Promise(function (resolve, reject) {
setTimeout(() => reject(new Error('request timeout')), 5000)
})
]);
p.then(response => console.log(response));
p.catch(error => console.log(error));
上面代碼中,如果5秒之內fetch方法無法返回結果,變量p的狀態就會變爲rejected,從而觸發catch方法指定的回調函數。
Promise.resolve
有時需要將現有對象轉爲Promise對象,Promise.resolve方法就起到這個作用。
var jsPromise = Promise.resolve($.ajax('/whatever.json'));
上面代碼將jQuery生成的deferred對象,轉爲一個新的Promise對象。
Promise.resolve等價於下面的寫法。
Promise.resolve('foo')
// 等價於
new Promise(resolve => resolve('foo'))
Promise.resolve方法的參數分成四種情況。
(1)參數是一個Promise實例
如果參數是Promise實例,那麼Promise.resolve將不做任何修改、原封不動地返回這個實例。
(2)參數是一個thenable對象
thenable對象指的是具有then方法的對象,比如下面這個對象。
let thenable = {
then: function(resolve, reject) {
resolve(42);
}
};
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。
var p = Promise.resolve('Hello');
p.then(function (s){
console.log(s)
});
// Hello
上面代碼生成一個新的Promise對象的實例p。由於字符串Hello不屬於異步操作(判斷方法是它不是具有then方法的對象),返回Promise實例的狀態從一生成就是Resolved,所以回調函數會立即執行。Promise.resolve方法的參數,會同時傳給回調函數。
(4)不帶有任何參數
Promise.resolve方法允許調用時不帶參數,直接返回一個Resolved狀態的Promise對象。
所以,如果希望得到一個Promise對象,比較方便的方法就是直接調用Promise.resolve方法。
var p = Promise.resolve();
p.then(function () {
// ...
});
上面代碼的變量p就是一個Promise對象。
需要注意的是,立即resolve的Promise對象,是在本輪“事件循環”(event loop)的結束時,而不是在下一輪“事件循環”的開始時。
setTimeout(function () {
console.log('three');
}, 0);
Promise.resolve().then(function () {
console.log('two');
});
console.log('one');
// one
// two
// three
上面代碼中,setTimeout(fn, 0)在下一輪“事件循環”開始時執行,Promise.resolve()在本輪“事件循環”結束時執行,console.log(’one‘)則是立即執行,因此最先輸出。
Promise.reject()
Promise.reject(reason)方法也會返回一個新的 Promise 實例,該實例的狀態爲rejected。
var p = Promise.reject('出錯了');
// 等同於
var p = new Promise((resolve, reject) => reject('出錯了'))
p.then(null, function (s) {
console.log(s)
});
// 出錯了
上面代碼生成一個Promise對象的實例p,狀態爲rejected,回調函數會立即執行。
注意,Promise.reject()方法的參數,會原封不動地作爲reject的理由,變成後續方法的參數。這一點與Promise.resolve方法不一致。
const thenable = {
then(resolve, reject) {
reject('出錯了');
}
};
Promise.reject(thenable)
.catch(e => {
console.log(e === thenable)
})
// true
上面代碼中,Promise.reject方法的參數是一個thenable對象,執行以後,後面catch方法的參數不是reject拋出的“出錯了”這個字符串,而是thenable對象。
兩個有用的附加方法
ES6的Promise API提供的方法不是很多,有些有用的方法可以自己部署。下面介紹如何部署兩個不在ES6之中、但很有用的方法。
done()
Promise對象的回調鏈,不管以then方法或catch方法結尾,要是最後一個方法拋出錯誤,都有可能無法捕捉到(因爲Promise內部的錯誤不會冒泡到全局)。因此,我們可以提供一個done方法,總是處於回調鏈的尾端,保證拋出任何可能出現的錯誤。
asyncFunc()
.then(f1)
.catch(r1)
.then(f2)
.done();
它的實現代碼相當簡單。
Promise.prototype.done = function (onFulfilled, onRejected) {
this.then(onFulfilled, onRejected)
.catch(function (reason) {
// 拋出一個全局錯誤
setTimeout(() => { throw reason }, 0);
});
};
從上面代碼可見,done方法的使用,可以像then方法那樣用,提供Fulfilled和Rejected狀態的回調函數,也可以不提供任何參數。但不管怎樣,done都會捕捉到任何可能出現的錯誤,並向全局拋出。
finally()
finally方法用於指定不管Promise對象最後狀態如何,都會執行的操作。它與done方法的最大區別,它接受一個普通的回調函數作爲參數,該函數不管怎樣都必須執行。
下面是一個例子,服務器使用Promise處理請求,然後使用finally方法關掉服務器。
server.listen(0)
.then(function () {
// run test
})
.finally(server.stop);
它的實現也很簡單。
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 })
);
};
上面代碼中,不管前面的Promise是fulfilled還是rejected,都會執行回調函數callback。
應用
加載圖片
我們可以將圖片的加載寫成一個Promise,一旦加載完成,Promise的狀態就發生變化。
const preloadImage = function (path) {
return new Promise(function (resolve, reject) {
var image = new Image();
image.onload = resolve;
image.onerror = reject;
image.src = path;
});
};
Generator函數與Promise的結合
使用Generator函數管理流程,遇到異步操作的時候,通常返回一個Promise對象。
function getFoo () {
return new Promise(function (resolve, reject){
resolve('foo');
});
}
var g = function* () {
try {
var foo = yield getFoo();
console.log(foo);
} catch (e) {
console.log(e);
}
};
function run (generator) {
var it = generator();
function go(result) {
if (result.done) return result.value;
return result.value.then(function (value) {
return go(it.next(value));
}, function (error) {
return go(it.throw(error));
});
}
go(it.next());
}
run(g);
上面代碼的Generator函數g之中,有一個異步操作getFoo,它返回的就是一個Promise對象。函數run用來處理這個Promise對象,並調用下一個next方法。
Promise.try()
實際開發中,經常遇到一種情況:不知道或者不想區分,函數f是同步函數還是異步操作,但是想用 Promise 來處理它。因爲這樣就可以不管f是否包含異步操作,都用then方法指定下一步流程,用catch方法處理f拋出的錯誤。一般就會採用下面的寫法。
Promise.resolve().then(f)
上面的寫法有一個缺點,就是如果f是同步函數,那麼它會在本輪事件循環的末尾執行。
const f = () => console.log('now');
Promise.resolve().then(f);
console.log('next');
// next
// now
上面代碼中,函數f是同步的,但是用 Promise 包裝了以後,就變成異步執行了。
那麼有沒有一種方法,讓同步函數同步執行,異步函數異步執行,並且讓它們具有統一的 API 呢?回答是可以的,並且還有兩種寫法。第一種寫法是用async函數來寫。
const f = () => console.log('now');
(async () => f())();
console.log('next');
// now
// next
上面代碼中,第二行是一個立即執行的匿名函數,會立即執行裏面的async函數,因此如果f是同步的,就會得到同步的結果;如果f是異步的,就可以用then指定下一步,就像下面的寫法。
(async () => f())()
.then(...)
需要注意的是,async () => f()會喫掉f()拋出的錯誤。所以,如果想捕獲錯誤,要使用promise.catch方法。
(async () => f())()
.then(...)
.catch(...)
第二種寫法是使用new Promise()。
const f = () => console.log('now');
(
() => new Promise(
resolve => resolve(f())
)
)();
console.log('next');
// now
// next
上面代碼也是使用立即執行的匿名函數,執行new Promise()。這種情況下,同步函數也是同步執行的。
鑑於這是一個很常見的需求,所以現在有一個提案,提供Promise.try方法替代上面的寫法。
const f = () => console.log('now');
Promise.try(f);
console.log('next');
// now
// next
事實上,Promise.try存在已久,Promise 庫Bluebird、Q和when,早就提供了這個方法。
由於Promise.try爲所有操作提供了統一的處理機制,所以如果想用then方法管理流程,最好都用Promise.try包裝一下。這樣有許多好處,其中一點就是可以更好地管理異常。
function getUsername(userId) {
return database.users.get({id: userId})
.then(function(user) {
return user.name;
});
}
上面代碼中,database.users.get()返回一個 Promise 對象,如果拋出異步錯誤,可以用catch方法捕獲,就像下面這樣寫。
database.users.get({id: userId})
.then(...)
.catch(...)
但是database.users.get()可能還會拋出同步錯誤(比如數據庫連接錯誤,具體要看實現方法),這時你就不得不用try…catch去捕獲。
try {
database.users.get({id: userId})
.then(...)
.catch(...)
} catch (e) {
// ...
}
上面這樣的寫法就很笨拙了,這時就可以統一用promise.catch()捕獲所有同步和異步的錯誤。
Promise.try(database.users.get({id: userId}))
.then(...)
.catch(...)
事實上,Promise.try就是模擬try代碼塊,就像promise.catch模擬的是catch代碼塊。