/*
自定义promise
1. 执行MyPromise构造函数，要立即执行executor
2. promise实例对象，内部有三种状态
初始化 pending
成功 resolved
失败 rejected
注意：状态只能修改一次
如果executor内部出错了，promise状态改成rejected
3. then方法的实现
promise.then(onResolved, onRejected)
promise的状态是resolved时，异步调用onResolved函数
promise的状态是rejected时，异步调用onRejected函数
promise的状态是pending时，不调用函数。
未来promise可能会变化，此时还是要异步调用相应的函数
4. promise.then().then()
then方法返回值是promise，才能链式调用
返回值promise对象的状态：
1. 如果内部没有返回值 / 返回值不是promise 就是resolved
2. 如果内部返回值是promise 看promise的状态
3. 如果内部抛异常，就是rejected
*/
function MyPromise(executor) {
// 初始化promise实例对象状态
this._status = 'pending';
// 初始化promise实例对象结果值
this._value = undefined;
// 初始化存储 回调函数 的容器
this._callbacks = {};
// 缓存this --> promise实例对象
const _that = this;
try {
// 放置可能出错代码
// 一旦try里面代码出错了，就会中断try中代码运行，直接来到catch
// 执行MyPromise构造函数，要立即执行executor
executor(resolve, reject);
} catch (e) {
// 来到catch，说明executor函数内部出错了~
// 将promise对象状态改成rejected
reject(e);
}
// 定义resolve
function resolve(value) {
// 状态只能修改一次
if (_that._status === 'pending') {
// 调用resolve方法将promise对象状态改成resolved状态
_that._status = 'resolved';
_that._value = value;
// 异步调用onResolved函数
if (_that._callbacks.onResolved) {
setTimeout(() => {
_that._callbacks.onResolved(value)
})
}
}
}
// 定义reject
function reject(reason) {
if (_that._status === 'pending') {
// 调用reject方法将promise对象状态改成rejected状态
_that._status = 'rejected';
_that._value = reason;
// 异步调用onRejected函数
if (_that._callbacks.onRejected) {
setTimeout(() => {
_that._callbacks.onRejected(reason)
})
}
}
}
}
MyPromise.prototype.then = function (onResolved, onRejected) {
const _that = this;
// 如果onResolved存在，不变
// 如果onResolved不存在，说明catch触发的。 如果是成功状态promise，保证返回值还是一个成功状态promise
onResolved = onResolved ? onResolved : (value) => value;
// then方法一旦只传一个参数，并且是失败状态promise，保证返回值 是 失败状态promise内部的值
onRejected = onRejected ? onRejected : (reason) => {
throw reason
};
// 为了将来作为promise对象使用
let promise = null;
// this指向promise实例对象
if (this._status === 'resolved') {
// 说明promise对象的状态是resolved
// 异步调用onResolved函数
promise = new MyPromise(function (resolve, reject) {
setTimeout(() => {
doResolve(onResolved, _that._value, resolve, reject);
})
})
} else if (this._status === 'rejected') {
promise = new MyPromise(function (resolve, reject) {
setTimeout(() => {
doResolve(onRejected, _that._value, resolve, reject);
})
})
} else {
// 说明promise对象的状态是pending状态
// 将回调函数存在this上
promise = new MyPromise(function (resolve, reject) {
// _that是p1， 外面promise是p2
// p1调用onResolved/onRejected回调时，要更新p2的状态
_that._callbacks.onResolved = function (value) {
doResolve(onResolved, value, resolve, reject);
};
_that._callbacks.onRejected = function (reason) {
doResolve(onRejected, reason, resolve, reject);
};
})
}
// 为了链式调用
return promise;
}
// 定义函数复用代码
function doResolve(onFn, value, resolve, reject) {
try {
const result = onFn(value);
if (result instanceof MyPromise) {
result.then(resolve, reject)
} else {
resolve(result);
}
} catch (e) {
reject(e);
}
}
MyPromise.prototype.catch = function (onRejected) {
return this.then(undefined, onRejected);
}
MyPromise.prototype.finally = function (onResolved) {
const _that = this;
return new Promise((resolve, reject) => {
if (_that._status === 'pending') {
const callback = function (value) {
doResolve(onResolved, value, resolve, reject)
};
_that._callbacks.onResolved = callback;
_that._callbacks.onRejected = callback;
} else {
doResolve(onResolved, _that._value, resolve, reject);
}
})
}
// 返回一个成功状态promise
MyPromise.resolve = function (value) {
return new MyPromise((resolve, reject) => {
resolve(value);
})
}
// 返回一个失败状态promise
MyPromise.reject = function (reason) {
return new MyPromise((resolve, reject) => {
reject(reason);
})
}
// 接受一个数组（数组中放置n个promise对象），只有所有promise对象都成成功状态，方法返回值的promise才是成功
// 只要有一个失败，方法返回值的promise就失败
MyPromise.all = function (promises) {
// promises的长度
const promiseLength = promises.length;
// 定义标识变量: promise对象成功的数量
let resolvedCount = 0;
// 成功的结果值
const resolvedValues = [];
return new MyPromise((resolve, reject) => {
for (let i = 0; i < promiseLength; i++) {
const promise = promises[i];
// 看promise的状态
promise.then((value) => {
resolvedCount++;
// 不能用push，输出顺序会乱
// 使用下标，才能保证顺序ok
resolvedValues[i] = value;
if (resolvedCount === promiseLength) {
// 说明都成功了
resolve(resolvedValues);
}
}, reject)
}
})
}
const promise = new MyPromise((resolve, reject) => {
console.log('executor函数执行了~');
setTimeout(() => {
// resolve(111);
reject(222);
}, 2000)
})
promise
.then(() => {
console.log(111);
// 当then方法没有传入第二个回调。
// 那么一旦接受的promise对象的状态是失败状态，返回值也是失败状态
})
.catch((reason) => {
console.log(222, reason);
// return Promise.reject();
// throw new Error(111)
return 333;
})
.then((value) => {
console.log(333, value);
})
.catch(() => {
console.log(444);
})
