本文采用es6语法实现Promise基本的功能, 适合有javascript和es6基础的读者，如果没有，请阅读
- http://es6.ruanyifeng.com/
回调函数
在日常开发中，通常会使用ajax请求数据，拿到数据后，对数据进行处理。
但是，假设你需要多次ajax请求数据，并且每次ajax请求数据都是基于上一次请求数据作为参数，再次发出请求，于是代码可能就成了这样：
function dataAjax() {
$.ajax({
url: '/woCms/getData',
type: 'get',
success: function (data) {
reChargeAjax(data);
}
});
}
function reChargeAjax(data) {
$.ajax({
url: '/woCms/reCharge',
type: 'post',
data: { data },
success: function (data) {
loginAjax(data);
}
});
}
....
很明显，这样的写法有一些缺点：
- 如果需求存在多个操作并且层层依赖的话，那这样的嵌套就可能存在多层，并且每次都需要对返回的数据进行处理，这样就严重加大了调试难度，代码不是很直观，并且增加了后期维护的难度
- 这种函数的层层嵌套，又称之为回调地域，为了解决这种形式存在的缺点，并支持多个并发的请求，于是Promise就出现了
Promise是什么
- Promise是一种异步流程的控制手段。
- Promise对象能够使我们更合理、更规范的处理异步流程操作.
Promise基本用法
let pro = new Promise(function (resolve, reject) {
});
- Promise是一个全局对象，也就是一个类
- 可通过new关键词创建一个Promise实例
- Promise构造函数传递一个匿名函数, 匿名函数有2个参数: resolve和reject
- 两个参数都是方法，resolve方法处理异步成功后的结果
- reject处理异步操作失败后的原因
Promise的三种状态
- pending: Promise 创建完成后，默认的初始化状态
- fulfilled: resolve方法调用时，表示操作成功
- rejected：reject方法调用时，表示操作失败
状态只能从初始化 -> 成功或者初始化 -> 失败，不能逆向转换，也不能在成功fulfilled 和失败rejected之间转换。
Promise 类构造
好了，目前我们知道了Promise的基础定义和语法，那么我们就用代码来模拟Promise的构造函数和内部实现吧
class Promise {
// 构造函数，构造时传入一个回调函数
constructor(executor) {
this.status = "pending";// promise初始化状态为pending
this.value = undefined;// 成功状态函数的数据
this.reason = undefined;// 失败状态的原因
// new Promise((resolve,reject)=>{});
let resolve = data => {
// 成功状态函数,只有当promise的状态为pending时才能修改状态
// 成功或者失败状态函数，只能调用其中的一个
if (this.status === "pending") {
this.status = "fulfilled";
this.value = data;
}
}
let reject = err => {
if (this.status === "pending") {
this.status = "rejected";
this.reason = err;
}
}
}
executor(resolve, rejcte);
}
在Promise的匿名函数中传入resolve, rejcte这两个函数，分别对应着成功和失败时的处理，根据Promise规范，只有当Promise的状态是初始化状态是才能修改其状态为成功或者失败，并且只能转为成功或者失败。
then方法
在了解Promise创建和状态之后，我们来学习Promise中一个非常重要的方法：then方法
then()方法：用于处理操作后的程序，那么它的语法是什么样子的呢，我们一起来看下
pro.then(function (res) {
//操作成功的处理
}, function (error) {
//操作失败的处理
});
那么then函数该如何定义呢？
很明显，then属于Promise原型上的方法，接收2个匿名函数作为参数，第一个是成功函数，第二个是失败函数。
也就是说当Promise状态变为成功的时候，执行第一个函数。当状态变为失败的时候，执行第二个函数。因此then函数可以这样定义：
then(onFulFiled, onRejected) {
// promise 执行返回的状态为成功态
if (this.status === "fulfilled") {
// promise执行成功时返回的数据为成功态函数的参数
onFulFiled(this.value);
}
if (this.status === "rejected") {
// promise 执行失败是返回的原因为失败态函数的参数
onRejected(this.reason);
}
}
Promise then 异步代码队列执行
但是我们现在来看这样一段Promise代码：
let pro = new Promise((resolve, reject) => {
setTimeout(function () {
resolve("suc");
}, 1000);
});
// 同一个promise实例多次调用then函数
pro.then(data => {
console.log("date", data);
}, err => {
console.log("err", err);
});
pro.then(data => {
console.log("date", data);
}, err => {
console.log("err", err);
})
输出结果为
date suc
date suc
这样Promise中异步调用成功或者失败状态函数，并且Promise实例多次调用then方法，我们可以看到最后输出多次成功状态函数中的内容，而此时:
- Promise中异步执行状态函数，但Promise的then函数是还是pending状态
- Promise实例pro多次调用then函数，当状态是pending的时候依然会执行状态函数
那么这块在then函数中是如何处理pending状态的逻辑呢？
采用发布订阅的方式，将状态函数存到队列中，之后调用时取出。
class Promise{
constructor(executor){
// 当promise中出现异步代码将成功态或者失败态函数封装时
// 采用发布订阅的方式，将状态函数存到队列中，之后调用时取出
this.onFuiFiledAry = [];
this.onRejectedAry = [];
let resolve = data => {
if (this.status === "pending") {
...
// 当状态函数队列中有存放的函数时，取出并执行,队列里面存的都是函数
this.onFulFiledAry.forEach(fn => fn());
}
}
let reject = err => {
if (this.status === "pending") {
...
this.onRejectedAry.forEach(fn => fn());
}
}
}
then(onFuiFiled, onRejected) {
...
if (this.status === "pending") {
this.onFuiFiledAry.push(() => {
onFuiFiled(this.value);
});
this.onRejectedAry.push(() => {
onRejected(this.reason);
});
}
}
}
Promise then 函数返回一个新的Promise
看过jQuery源码的童鞋肯定都清楚，jQuery是如何实现链式调用的呢？对，就是this，jQuery通过在函数执行完成后通过返回当前对象的引用，也就是this来实现链式调用。
我们先看看一个例子，假设Promise用this来实现链式调用，会出现什么情况呢？
let pro = new Promise(function (resolve, reject) {
resolve(123);
});
let p2 = pro.then(function () {
// 如果返回this，那p和p2是同一个promise的话，此时p2的状态也应该是成功
// p2状态设置为成功态了，就不能再修改了,但是此时抛出了异常，应该是走下个then的成功态函数
throw new Error("error");
});
p2.then(function (data) {
console.log("promise success", data);
}, function (err) {
// 此时捕获到了错误，说明不是同一个promise，因为promise的状态变为成功后是不能再修改状态
console.log("promise or this:", err);
})
很明显，Promise发生异常，抛出Error时，p2实例的状态已经是失败态了，所以会走下一个then的失败态函数，而结果也正是这样，说明Promise并不是通过this来实现链式调用。
那Promise中的链式调用是如何实现的呢？
结果是，返回一个新的Promise.
then(onFuiFiled, onRejected) {
let newpro;
if (this.status === "fulfilled") {
newpro = new Promise((resolve, reject) => {
onFuiFiled(this.value);
});
}
if (this.status === "rejected") {
newpro = new Promise((resolve, reject) => {
onRejected(this.reason);
});
}
if (this.status === "pending") {
newpro = new Promise((resolve, reject) => {
this.onFuiFiledAry.push(() => {
onFuiFiled(this.value);
});
this.onRejectedAry.push(() => {
onRejected(this.reason);
});
});
}
return newpro;
}
Promise then函数返回值解析
好了，我们继续将目光放在then函数上，then函数接收两个匿名函数，那假设then函数返回的是数值、对象、函数，或者是promise,这块Promise又是如何实现的呢？
来，我们先看例子：
let pro = new Promise((resolve, reject) => {
resolve(123);
});
pro.then(data => {
console.log("then-1",data);
return 1;
}).then(data => {
console.log("then-2", data);
});
例子输出的结果是 then-1 123 then-2 1
也就是说Promise会根据then状态函数执行时返回的不同的结果来进行解析:
- 如果上一个then函数返回的是数值、对象、函数的话，是会直接将这个数值和对象直接返回给下个then;
- 如果then返回的是null，下个then获取到的也是null;
- 如果then返回的是一个新的promise的话，则根据新的promise的状态函数来确定下个then调用哪个状态函数，如果返回的新的promise没有执行任何状态函数的话，则这个promise的状态是pending
那这块，我们该如何实现呢？来，看具体代码吧
function analysisPromise(promise, res, resolve, reject) {
// promise 中返回的是promise实例本身，并没有调用任何的状态函数方法
if (promise === res) {
return reject(new TypeError("Recycle"));
}
// res 不是null，res是对象或者是函数
if (res !== null && (typeof res === "object" || typeof res === "function")) {
try {
let then = res.then;//防止使用Object.defineProperty定义成{then:{}}
if (typeof then === "function") {//此时当做Promise在进行解析
then.call(res, y => {
// y作为参数，promise中成功态的data,递归调用函数进行处理
analysisPromise(promise, y, resolve, reject);
}, err => {
reject(err);
})
} else {
// 此处then是普通对象，则直接调用下个then的成功态函数并被当做参数输出
resolve(res);
}
} catch (error) {
reject(error);
}
} else {
// res 是数值
resolve(res);
}
}
then(onFuiFiled, onRejected) {
let newpro;
if (this.status === "fulfilled") {
newpro = new Promise((resolve, reject) => {
let res = onFuiFiled(this.value);
analysisPromise(newpro, res, resolve, reject);
});
}
...
return newpro;
}
analysisPromise函数就是用来解析Promise中then函数的返回值的，在调用then函数中的状态函数返回结果值时都必须要进行处理。
Promise中的then函数是异步
现在，我们再来看Promise的一个例子：
let pro = new Promise((resolve, reject) => {
resolve(123);
});
pro.then(data => {
console.log(1);
});
console.log(2);
输出的结果是 2 1
so,这里先输出的是2，而then函数中的状态函数后输出1，说明同步代码先于then函数的异步代码执行
那这部分的代码我们该如何来实现呢？
采用setTimeout函数，给then函数中的每个匿名函数都加上setTimeout函数代码，就比如这样:
then(onFuiFiled, onRejected) {
let newpro;
if (this.status === "fulfilled") {
newpro = new Promise((resolve, reject) => {
setTimeout(() => {
try {
let res = onFuiFiled(this.value);
analysisPromise(newpro, res, resolve, reject);
} catch (error) {
reject(error);
}
});
});
}
...
return newpro;
}
好了，关于Promise的大致实现就先分析到这里，希望对大家有帮助，文章中如有错误，欢迎指正
文章主要参考一下具体学习资源
- http://es6.ruanyifeng.com/
- http://liubin.org/promises-book/#es6-promises
