# 一、Promise基础用法
# 1.1 基本用法
new Promise(function(resolve, reject) { //待处理的异步逻辑 //处理结束后,调用resolve或reject方法 })
@程序员poetry: 代码已经复制到剪贴板
- 新建一个
promise
很简单,只需要new
一个promise
对象即可。所以promise
本质上就是一个函数,它接受一个函数作为参数,并且会返回promise
对象,这就给链式调用提供了基础- 其实
Promise
函数的使命,就是构建出它的实例,并且负责帮我们管理这些实例。而这些实例有以下三种状态:
pending
: 初始状态,位履行或拒绝fulfilled
: 意味着操作成功完成rejected
: 意味着操作失败
pending
状态的Promise
对象可能以fulfilled
状态返回了一个值,也可能被某种理由(异常信息)拒绝(reject
)了。当其中任一种情况出现时,Promise
对象的then
方法绑定的处理方法(handlers)就会被调用,then方法分别指定了resolve
方法和reject
方法的回调函数
var promise = new Promise(function(resolve, reject) { if (/* 异步操作成功 */){ resolve(value); } else { reject(error); } }); promise.then(function(value) { // 如果调用了resolve方法,执行此函数 }, function(value) { // 如果调用了reject方法,执行此函数 });
@程序员poetry: 代码已经复制到剪贴板
上述代码很清晰的展示了
promise
对象运行的机制。下面再看一个示例:
var getJSON = function(url) { var promise = new Promise(function(resolve, reject){ var client = new XMLHttpRequest(); client.open("GET", url); client.onreadystatechange = handler; client.responseType = "json"; client.setRequestHeader("Accept", "application/json"); client.send(); function handler() { if (this.status === 200) { resolve(this.response); } else { reject(new Error(this.statusText)); } }; }); return promise; }; getJSON("/posts.json").then(function(json) { console.log('Contents: ' + json); }, function(error) { console.error('出错了', error); });
@程序员poetry: 代码已经复制到剪贴板
上面代码中,
resolve
方法和reject
方法调用时,都带有参数。它们的参数会被传递给回调函数。reject
方法的参数通常是Error
对象的实例,而resolve
方法的参数除了正常的值以外,还可能是另一个Promise
实例,比如像下面这样。
var p1 = new Promise(function(resolve, reject){ // ... some code }); var p2 = new Promise(function(resolve, reject){ // ... some code resolve(p1); })
@程序员poetry: 代码已经复制到剪贴板
上面代码中,
p1
和p2
都是Promise
的实例,但是p2
的resolve
方法将p1
作为参数,这时p1
的状态就会传递给p2
。如果调用的时候,p1
的状态是pending
,那么p2
的回调函数就会等待p1
的状态改变;如果p1
的状态已经是fulfilled
或者rejected
,那么p2
的回调函数将会立刻执行
# 1.2 promise捕获错误
Promise.prototype.catch
方法是Promise.prototype.then(null, rejection)
的别名,用于指定发生错误时的回调函数
getJSON("/visa.json").then(function(result) { // some code }).catch(function(error) { // 处理前一个回调函数运行时发生的错误 console.log('出错啦!', error); });
@程序员poetry: 代码已经复制到剪贴板
Promise
对象的错误具有“冒泡”性质,会一直向后传递,直到被捕获为止。也就是说,错误总是会被下一个catch
语句捕获
getJSON("/visa.json").then(function(json) { return json.name; }).then(function(name) { // proceed }).catch(function(error) { //处理前面任一个then函数抛出的错误 });
@程序员poetry: 代码已经复制到剪贴板
# 1.3 常用的promise方法
Promise.all方法
Promise.all
方法用于将多个Promise
实例,包装成一个新的Promise
实例
var p = Promise.all([p1,p2,p3]);
@程序员poetry: 代码已经复制到剪贴板
- 上面代码中,
Promise.all
方法接受一个数组作为参数,p1
、p2
、p3
都是Promise
对象的实例。(Promise.all
方法的参数不一定是数组,但是必须具有iterator
接口,且返回的每个成员都是Promise
实例。)
p
的状态由p1
、p2
、p3
决定,分成两种情况
- 只有
p1
、p2
、p3
的状态都变成fulfilled
,p
的状态才会变成fulfilled
,此时p1
、p2
、p3
的返回值组成一个数组,传递给p
的回调函数 - 只要
p1
、p2
、p3
之中有一个被rejected
,p
的状态就变成rejected
,此时第一个被reject
的实例的返回值,会传递给p的回调函数
// 生成一个Promise对象的数组 var promises = [2, 3, 5, 7, 11, 13].map(function(id){ return getJSON("/get/addr" + id + ".json"); }); Promise.all(promises).then(function(posts) { // ... }).catch(function(reason){ // ... });
@程序员poetry: 代码已经复制到剪贴板
Promise.race方法
Promise.race
方法同样是将多个Promise
实例,包装成一个新的Promise
实例。
var p = Promise.race([p1,p2,p3]);
@程序员poetry: 代码已经复制到剪贴板
上面代码中,只要
p1
、p2
、p3
之中有一个实例率先改变状态,p的状态就跟着改变。那个率先改变的Promise实例的返回值,就传递给p的返回值
- 如果
Promise.all
方法和Promise.race
方法的参数,不是Promise
实例,就会先调用下面讲到的Promise.resolve
方法,将参数转为Promise
实例,再进一步处理
Promise.resolve
有时需要将现有对象转为
Promise
对象,Promise.resolve
方法就起到这个作用
var jsPromise = Promise.resolve($.ajax('/whatever.json'));
@程序员poetry: 代码已经复制到剪贴板
上面代码将
jQuery
生成deferred
对象,转为一个新的ES6
的Promise
对象
- 如果
Promise.resolve
方法的参数,不是具有then
方法的对象(又称thenable
对象),则返回一个新的Promise
对象,且它的状态为fulfilled
。
var p = Promise.resolve('Hello'); p.then(function (s){ console.log(s) }); // Hello
@程序员poetry: 代码已经复制到剪贴板
- 上面代码生成一个新的
Promise
对象的实例p
,它的状态为fulfilled
,所以回调函数会立即执行,Promise.resolve
方法的参数就是回调函数的参数 - 如果
Promise.resolve
方法的参数是一个Promise
对象的实例,则会被原封不动地返回 Promise.reject(reason)
方法也会返回一个新的Promise
实例,该实例的状态为rejected
。Promise.reject
方法的参数reason
,会被传递给实例的回调函数
var p = Promise.reject('出错啦'); p.then(null, function (error){ console.log(error) }); // 出错了
@程序员poetry: 代码已经复制到剪贴板
# 1.4 Async/await简化写法
function getDataAsync (url) { return new Promise((resolve, reject) => { setTimeout(() => { var res = { url: url, data: Math.random() } resolve(res) }, 1000) }) } async function getData () { var res1 = await getDataAsync('/page/1?param=123') console.log(res1) var res2 = await getDataAsync(`/page/2?param=${res1.data}`) console.log(res2) var res3 = await getDataAsync(`/page/2?param=${res2.data}`) console.log(res3) }
@程序员poetry: 代码已经复制到剪贴板
async/await
是基于Promise
的,因为使用async
修饰的方法最终返回一个Promise
, 实际上,async/await
可以看做是使用Generator
函数处理异步的语法糖,我们来看看如何使用Generator
函数处理异步
# 1.5 Generator
首先异步函数依然是:
function getDataAsync (url) { return new Promise((resolve, reject) => { setTimeout(() => { var res = { url: url, data: Math.random() } resolve(res) }, 1000) }) }
@程序员poetry: 代码已经复制到剪贴板
使用
Generator
函数可以这样写
function * getData () { var res1 = yield getDataAsync('/page/1?param=123') console.log(res1) var res2 = yield getDataAsync(`/page/2?param=${res1.data}`) console.log(res2) var res3 = yield getDataAsync(`/page/2?param=${res2.data}`) console.log(res3)) }
@程序员poetry: 代码已经复制到剪贴板
然后我们这样逐步执行
var g = getData() g.next().value.then(res1 => { g.next(res1).value.then(res2 => { g.next(res2).value.then(() => { g.next() }) }) })
@程序员poetry: 代码已经复制到剪贴板
上面的代码,我们逐步调用遍历器的
next()
方法,由于每一个next()
方法返回值的value
属性为一个Promise
对象,所以我们为其添加then
方法, 在then
方法里面接着运行next
方法挪移遍历器指针,直到Generator
函数运行完成,实际上,这个过程我们不必手动完成,可以封装成一个简单的执行器
function run (gen) { var g = gen() function next (data) { var res = g.next(data) if (res.done) return res.value res.value.then((data) => { next(data) }) } next() }
@程序员poetry: 代码已经复制到剪贴板
run
方法用来自动运行异步的Generator
函数,其实就是一个递归的过程调用的过程。这样我们就不必手动执行Generator
函数了。 有了run
方法,我们只需要这样运行 getData 方法
run(getData)
@程序员poetry: 代码已经复制到剪贴板
这样,我们就可以把异步操作封装到
Generator
函数内部,使用run
方法作为Generator
函数的自执行器,来处理异步。其实我们不难发现,async/await
方法相比于Generator
处理异步的方式,有很多相似的地方,只不过async/await
在语义化方面更加明显,同时async/await
不需要我们手写执行器,其内部已经帮我们封装好了,这就是为什么说async/await
是Generator
函数处理异步的语法糖了
# 二、Promise实现原理剖析
# 2.1 Promise标准
Promise
规范有很多,如Promise/A
,Promise/B
,Promise/D
以及Promise/A
的升级版Promise/A+
。ES6
中采用了Promise/A+
规范
中文版规范: Promises/A+规范(中文) (opens new window)
Promise标准解读
- 一个
promise
的当前状态只能是pending
、fulfilled
和rejected
三种之一。状态改变只能是pending
到fulfilled
或者pending
到rejected
。状态改变不可逆 promise
的then
方法接收两个可选参数,表示该promise
状态改变时的回调(promise.then(onFulfilled, onRejected)
)。then
方法返回一个promise
。then
方法可以被同一个promise
调用多次
# 2.2 实现Promise
构造函数
function Promise(resolver) {}
@程序员poetry: 代码已经复制到剪贴板
原型方法
Promise.prototype.then = function() {} Promise.prototype.catch = function() {}
@程序员poetry: 代码已经复制到剪贴板
静态方法
Promise.resolve = function() {} Promise.reject = function() {} Promise.all = function() {} Promise.race = function() {}
@程序员poetry: 代码已经复制到剪贴板
# 2.3 极简promise雏形
function Promise(fn) { var value = null, callbacks = []; //callbacks为数组,因为可能同时有很多个回调 this.then = function (onFulfilled) { callbacks.push(onFulfilled); }; function resolve(value) { callbacks.forEach(function (callback) { callback(value); }); } fn(resolve); }
@程序员poetry: 代码已经复制到剪贴板
大致的逻辑是这样的
- 调用
then
方法,将想要在Promise
异步操作成功时执行的回调放入callbacks
队列,其实也就是注册回调函数,可以向观察者模式方向思考 - 创建
Promise
实例时传入的函数会被赋予一个函数类型的参数,即resolve
,它接收一个参数value
,代表异步操作返回的结果,当一步操作执行成功后,用户会调用resolve
方法,这时候其实真正执行的操作是将callbacks
队列中的回调一一执行
//例1 function getUserId() { return new Promise(function(resolve) { //异步请求 http.get(url, function(results) { resolve(results.id) }) }) } getUserId().then(function(id) { //一些处理 }) // 结合例子1分析 // fn 就是getUserId函数 function Promise(fn) { var value = null, callbacks = []; //callbacks为数组,因为可能同时有很多个回调 // 当用户调用getUserId().then的时候开始注册传进来的回调函数 // onFulfilled就是例子中的function(id){} // 把then的回调函数收集起来 在resolve的时候调用 this.then = function (onFulfilled) { callbacks.push(onFulfilled); }; // value是fn函数执行后返回的值 function resolve(value) { // callbacks是传给then的回调函数就是例子中的function(id){} // 遍历用户通过then传递进来的回调函数把resolve成功的结果返回给then调用即then(function(data){ console.log(data) }) 这里的data就是通过这里调用返回 callbacks.forEach(function (callback) { callback(value); }); } //执行fn函数即getUserId()并且传入函数参数resolve 当fn执行完成返回的值传递给resolve函数 fn(resolve); }
@程序员poetry: 代码已经复制到剪贴板
结合例1中的代码来看,首先
new Promise
时,传给promise
的函数发送异步请求,接着调用promise
对象的then
属性,注册请求成功的回调函数,然后当异步请求发送成功时,调用resolve(results.id)
方法, 该方法执行then
方法注册的回调数组
then
方法应该能够链式调用,但是上面的最基础简单的版本显然无法支持链式调用。想让then
方法支持链式调用,其实也是很简单的
this.then = function (onFulfilled) { callbacks.push(onFulfilled); return this; };
@程序员poetry: 代码已经复制到剪贴板
只要简单一句话就可以实现类似下面的链式调用
// 例2 getUserId().then(function (id) { // 一些处理 }).then(function (id) { // 一些处理 });
@程序员poetry: 代码已经复制到剪贴板
# 2.4 加入延时机制
上述代码可能还存在一个问题:如果在
then
方法注册回调之前,resolve
函数就执行了,怎么办?比如promise
内部的函数是同步函数
// 例3 function getUserId() { return new Promise(function (resolve) { resolve(9876); }); } getUserId().then(function (id) { // 一些处理 });
@程序员poetry: 代码已经复制到剪贴板
这显然是不允许的,
Promises/A+
规范明确要求回调需要通过异步方式执行,用以保证一致可靠的执行顺序。因此我们要加入一些处理,保证在resolve
执行之前,then
方法已经注册完所有的回调。我们可以这样改造下resolve
函数:
function resolve(value) { setTimeout(function() { callbacks.forEach(function (callback) { callback(value); }); }, 0) }
@程序员poetry: 代码已经复制到剪贴板
上述代码的思路也很简单,就是通过
setTimeout
机制,将resolve
中执行回调的逻辑放置到JS
任务队列末尾,以保证在resolve
执行时,then
方法的回调函数已经注册完成
- 但是,这样好像还存在一个问题,可以细想一下:如果
Promise
异步操作已经成功,这时,在异步操作成功之前注册的回调都会执行,但是在Promise
异步操作成功这之后调用的then
注册的回调就再也不会执行了,这显然不是我们想要的
# 2.5 加入状态
我们必须加入状态机制,也就是大家熟知的pending
、fulfilled
、rejected
Promises/A+
规范中的2.1 Promise States
中明确规定了,pending
可以转化为fulfilled
或rejected
并且只能转化一次,也就是说如果pending
转化到fulfilled
状态,那么就不能再转化到rejected
。并且fulfilled
和rejected
状态只能由pending
转化而来,两者之间不能互相转换
//改进后的代码是这样的: function Promise(fn) { var state = 'pending', value = null, callbacks = []; this.then = function (onFulfilled) { if (state === 'pending') { callbacks.push(onFulfilled); return this; } onFulfilled(value); return this; }; function resolve(newValue) { value = newValue; state = 'fulfilled'; setTimeout(function () { callbacks.forEach(function (callback) { callback(value); }); }, 0); } fn(resolve); }
@程序员poetry: 代码已经复制到剪贴板
上述代码的思路是这样的:
resolve
执行时,会将状态设置为fulfilled
,在此之后调用then
添加的新回调,都会立即执行
# 2.6 链式Promise
如果用户在
then
函数里面注册的仍然是一个Promise
,该如何解决?比如下面的例4
// 例4 getUserId() .then(getUserJobById) .then(function (job) { // 对job的处理 }); function getUserJobById(id) { return new Promise(function (resolve) { http.get(baseUrl + id, function(job) { resolve(job); }); }); }
@程序员poetry: 代码已经复制到剪贴板
- 这种场景相信用过
promise
的人都知道会有很多,那么类似这种就是所谓的链式Promise
- 链式
Promise
是指在当前promise
达到fulfilled
状态后,即开始进行下一个promise
(后邻promise
)。那么我们如何衔接当前promise
和后邻promise
呢?(这是这里的难点 - 只要在
then
方法里面return
一个promise
就好啦。Promises/A+
规范中的2.2.7
就是这样
下面来看看这段暗藏玄机的
then
方法和resolve
方法改造代码
function Promise(fn) { var state = 'pending', value = null, callbacks = []; this.then = function (onFulfilled) { return new Promise(function (resolve) { handle({ onFulfilled: onFulfilled || null, resolve: resolve }); }); }; function handle(callback) { if (state === 'pending') { callbacks.push(callback); return; } //如果then中没有传递任何东西 if(!callback.onFulfilled) { callback.resolve(value); return; } var ret = callback.onFulfilled(value); callback.resolve(ret); } function resolve(newValue) { if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) { var then = newValue.then; if (typeof then === 'function') { then.call(newValue, resolve); return; } } state = 'fulfilled'; value = newValue; setTimeout(function () { callbacks.forEach(function (callback) { handle(callback); }); }, 0); } fn(resolve); }
@程序员poetry: 代码已经复制到剪贴板
我们结合例4的代码,分析下上面的代码逻辑,为了方便阅读,我把例4的代码贴在这里
// 例4 getUserId() .then(getUserJobById) .then(function (job) { // 对job的处理 }); function getUserJobById(id) { return new Promise(function (resolve) { http.get(baseUrl + id, function(job) { resolve(job); }); }); }
@程序员poetry: 代码已经复制到剪贴板
then
方法中,创建并返回了新的Promise
实例,这是串行Promis
e的基础,并且支持链式调用handle
方法是promise
内部的方法。then
方法传入的形参onFulfilled
以及创建新Promise
实例时传入的resolve
均被push
到当前promise
的callbacks
队列中,这是衔接当前promise
和后邻promise
的关键所在getUserId
生成的promise
(简称getUserId promise
)异步操作成功,执行其内部方法resolve
,传入的参数正是异步操作的结果id
- 调用
handle
方法处理callbacks
队列中的回调:getUserJobById
方法,生成新的promise
(getUserJobById promise
) - 执行之前由
getUserId promise
的then
方法生成的新promise
(称为bridge promise
)的resolve
方法,传入参数为getUserJobById promise
。这种情况下,会将该resolve
方法传入getUserJobById promise
的then
方法中,并直接返回 - 在
getUserJobById promise
异步操作成功时,执行其callbacks
中的回调:getUserId bridge promise
中的resolve
方法 - 最后执行
getUserId bridge promise
的后邻promise
的callbacks
中的回调
# 2.7 失败处理
在异步操作失败时,标记其状态为
rejected
,并执行注册的失败回调
//例5 function getUserId() { return new Promise(function(resolve) { //异步请求 http.get(url, function(error, results) { if (error) { reject(error); } resolve(results.id) }) }) } getUserId().then(function(id) { //一些处理 }, function(error) { console.log(error) })
@程序员poetry: 代码已经复制到剪贴板
有了之前处理
fulfilled
状态的经验,支持错误处理变得很容易,只需要在注册回调、处理状态变更上都要加入新的逻辑
function Promise(fn) { var state = 'pending', value = null, callbacks = []; this.then = function (onFulfilled, onRejected) { return new Promise(function (resolve, reject) { handle({ onFulfilled: onFulfilled || null, onRejected: onRejected || null, resolve: resolve, reject: reject }); }); }; function handle(callback) { if (state === 'pending') { callbacks.push(callback); return; } var cb = state === 'fulfilled' ? callback.onFulfilled : callback.onRejected, ret; if (cb === null) { cb = state === 'fulfilled' ? callback.resolve : callback.reject; cb(value); return; } ret = cb(value); callback.resolve(ret); } function resolve(newValue) { if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) { var then = newValue.then; if (typeof then === 'function') { then.call(newValue, resolve, reject); return; } } state = 'fulfilled'; value = newValue; execute(); } function reject(reason) { state = 'rejected'; value = reason; execute(); } function execute() { setTimeout(function () { callbacks.forEach(function (callback) { handle(callback); }); }, 0); } fn(resolve, reject); }
@程序员poetry: 代码已经复制到剪贴板