// promise可以链式操作，then返回的是一个值或者是一个promise对象
// promise2 = promise1.then(onFulfilled, onRejected);
/**
*
* @param {promise} promise2 promise1.then返回的对象
* @param {[type]} x promise1中onFulfilled的返回值
* @param {[type]} resolve promise2的resolve方法
* @param {[type]} reject promise2的reject方法
*/
function handlePromise(promise2,x,resolve,reject) {
if (promise2 === x) {
// 如果从onFulfilled中返回的x 就是promise2 就会导致循环引用报错
return reject(new TypeError('循环引用'));
}
let called = false; // 避免多次调用
if (x instanceof Promise) {
// 如果 x 为 Promise ，则使 promise 接受 x 的状态
if (x.status === 'pending') {
x.then(y => {
handlePromise(promise2,y,resolve,reject);
}, r => {
reject(r);
})
} else {
x.then(resolve, reject);
}
} else if (x !== null && (typeof x === 'object' || typeof x === 'function')) {
// 如果 x 为对象或者函数
// 把 x.then 赋值给 then
// 如果取 x.then 的值时抛出错误 e ，则以 e 为据因拒绝 promise
try {
// 如果 then 是函数，将 x 作为函数的作用域 this 调用之。传递两个回调函数作为参数，第一个参数叫做 resolvePromise ，第二个参数叫做 rejectPromise:
let then = x.then;
if (typeof then === 'function') {
then.call(x, y => {
// 如果 resolvePromise 或 rejectPromise 已经被调用，则忽略之
if (called) return;
called = true;
handlePromise(promise2,y,resolve,reject);
}, r => {
if (called) return;
called = true;
reject(r)
})
} else {
// 如果 x 不为对象或者函数，以 x 为参数执行 promise
resolve(x);
}
} catch(e) {
// 如果 resolvePromise 或 rejectPromise 已经被调用，则忽略之
if(called) return;
called = true;
reject(e)
}
} else {
// 如果 x 不为对象或者函数，以 x 为参数执行 promise
resolve(x);
}
}
class Promise1 { //创建一个Promise类
constructor(executor) {
this.status = 'pending'; //初始默认状态为pending
this.value = undefined; //默认赋值为undefined
this.reason = undefined; //默认赋值为undefined
this.successStore = [];
this.failStore = [];
let resolve = (value) => {
if (this.status === 'pending') { //只有状态为pending才能转换状态
this.value = value; //将传递进来的的值赋给value保存
this.status = 'resolved'; //将状态设置成resolved
this.successStore.forEach(fn => fn());
}
}
let reject = (reason) => {
if (this.status === 'pending') { //只有状态为pending才能转换状态
this.reason = reason; //将传递进来的失败原因赋给reason保存
this.status = 'rejected'; //将状态设置成rejected
this.failStore.forEach(fn => fn());
}
}
try {
executor(resolve, reject);
} catch (e) {
reject(e); //如果发生错误，将错误放入reject中
}
}
//等同于es5的Promise.prototype.then 当调用then的时候,根据状态，来执行不同的函数
then(onFulfilled, onRejected) {
let promise2;
// 处理参数默认值 保证参数后续能够继续执行
onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : value => value;
onRejected = typeof onRejected === 'function' ? onRejected : reason => { throw reason };
// 为了确保 onFulfilled 和 onRejected 方法异步执行(且应该在 then 方法被调用的那一轮事件循环之后的新执行栈中执行) 所以要在resolve里加上setTimeout
// 对于一个promise，它的then方法可以调用多次.（当在其他程序中多次调用同一个promise的then时 由于之前状态已经为FULFILLED/REJECTED状态，则会走的下面逻辑),所以要确保为FULFILLED/REJECTED状态后 也要异步执行onFulfilled/onRejected
if (this.status === 'resolved') { //如果状态是resolved
promise2 = new Promise((resolve, reject) => {
setTimeout(() => {
try {
let x = onFulfilled(this.value);
handlePromise(promise2,x,resolve,reject);
} catch (error) {
reject(error);
}
})
})
}
if (this.status === 'rejected') { //如果状态是rejected
promise2 = new Promise((resolve, reject) => {
setTimeout(() => {
try {
let x = onRejected(this.reason);
handlePromise(promise2,x,resolve,reject);
} catch (error) {
reject(error);
}
})
})
}
if (this.status === 'pending') {
// 当异步调用resolve/rejected时 将onFulfilled/onRejected收集暂存到集合中
// this.successStore.push(() => onFulfilled(this.value));
// this.failStore.push(() => onRejected(this.reason));
promise2 = new Promise((resolve, reject) => {
this.successStore.push(() => {
try {
let x = onFulfilled(this.value);
handlePromise(promise2,x,resolve,reject);
} catch (error) {
reject(error);
}
});
this.failStore.push(() => {
try {
let x = onRejected(this.reason);
handlePromise(promise2,x,resolve,reject);
} catch (error) {
reject(error);
}
})
})
}
return promise2;
}
}
// module.exports = Promise; //将Promise导出
const p = new Promise1((resolve, reject) => {
setTimeout(() => {
resolve('hi');
}, 1000);
})
p.then((data) =>{
console.log(data);
return new Promise((resolve, reject) => {
resolve('resolve')
});
},(err) =>{
console.log(err);
})
.then(data => {
console.log(data)
}, err => {
console.log(err)
})
