// promise的第一版实现
function
myPromise(
constructor) {
let
self =
this;
self.
status =
"pending"
//定义状态改变前的初始状态
self.
value =
undefined;
//定义状态为resolved的时候的状态
self.
reason =
undefined;
//定义状态为rejected的时候的状态
function
resolve(
value) {
//两个==="pending"，保证了状态的改变是不可逆的
console.
log(
222)
if (
self.
status ===
"pending") {
self.
value =
value;
self.
status =
"resolved";
}
}
function
reject(
reason) {
//两个==="pending"，保证了状态的改变是不可逆的
if (
self.
status ===
"pending") {
self.
reason =
reason;
self.
status =
"rejected";
}
}
//捕获构造异常
try {
constructor(
resolve,
reject);
}
catch (
e) {
reject(
e);
}
}
myPromise.
prototype.
then =
function (
onFullfilled,
onRejected) {
let
self =
this;
console.
log(
'78878' +
self.
status)
switch (
self.
status) {
case
"resolved":
onFullfilled(
self.
value);
break;
case
"rejected":
onRejected(
self.
reason);
break;
default:
}
}
var
p =
new
myPromise(
function (
resolve,
reject) {
resolve(
1) });
p.
then(
function (
x) {
console.
log(
x)
})
//输出1
// mypromise 无法执行异步的resolve
var
p =
new
myPromise(
function (
resolve,
reject) {
setTimeout(
function () {
console.
log(
'thisthisthis================' +
this)
resolve(
1)
},
1000)
});
p.
then(
function (
x) {
console.
log(
x) })
//无输出
// 2, 基于观察者
function
myPromise(
constructor) {
let
self =
this;
self.
status =
"pending"
//定义状态改变前的初始状态
self.
value =
undefined;
//定义状态为resolved的时候的状态
self.
reason =
undefined;
//定义状态为rejected的时候的状态
console.
log(
'55566567676')
self.
onFullfilledArray = [];
self.
onRejectedArray = [];
function
resolve(
value) {
console.
log(
232323)
if (
self.
status ===
"pending") {
self.
value =
value;
self.
status =
"resolved";
self.
onFullfilledArray.
forEach(
function (
f) {
// self.value
console.
log(
'value==================' +
self.
value)
f();
//如果状态从pending变为resolved，
//那么就遍历执行里面的异步方法
});
}
}
function
reject(
reason) {
if (
self.
status ===
"pending") {
self.
reason =
reason;
self.
status =
"rejected";
self.
onRejectedArray.
forEach(
function (
f) {
f(
self.
reason);
//如果状态从pending变为rejected,
//那么就遍历执行里面的异步方法
})
}
}
//捕获构造异常
try {
constructor(
resolve,
reject);
}
catch (
e) {
reject(
e);
}
}
myPromise.
prototype.
then =
function (
onFullfilled,
onRejected) {
let
self =
this;
console.
log(
'status==========' +
self.
status)
switch (
self.
status) {
case
"pending":
self.
onFullfilledArray.
push(
function () {
onFullfilled(
self.
value)
});
self.
onRejectedArray.
push(
function () {
onRejected(
self.
reason)
});
break;
case
"resolved":
onFullfilled(
self.
value);
break;
case
"rejected":
onRejected(
self.
reason);
break;
default:
}
}
var
p =
new
myPromise(
function (
resolve,
reject) {
setTimeout(
function () {
console.
log(
this)
resolve(
1)
},
1000)
});
p.
then(
function (
x) {
console.
log(
x) })
//无输出
// 3.v3.0then方法实现链式调用
myPromise.
prototype.
then =
function (
onFullfilled,
onRejected) {
let
self =
this;
let
promise2;
switch (
self.
status) {
case
"pending":
promise2 =
new
myPromise(
function (
resolve,
reject) {
self.
onFullfilledArray.
push(
function () {
try {
let
temple =
onFullfilled(
self.
value);
resolve(
temple)
}
catch (
e) {
reject(
e)
//error catch
}
});
self.
onRejectedArray.
push(
function () {
try {
let
temple =
onRejected(
self.
reason);
reject(
temple)
}
catch (
e) {
reject(
e)
// error catch
}
});
})
break;
case
"resolved":
promise2 =
new
myPromise(
function (
resolve,
reject) {
try {
let
temple =
onFullfilled(
self.
value);
//将上次一then里面的方法传递进下一个Promise的状态
resolve(
temple);
}
catch (
e) {
reject(
e);
//error catch
}
})
break;
case
"rejected":
promise2 =
new
myPromise(
function (
resolve,
reject) {
try {
let
temple =
onRejected(
self.
reason);
//将then里面的方法传递到下一个Promise的状态里
resolve(
temple);
}
catch (
e) {
reject(
e);
}
})
break;
default:
}
return
promise2;
}
var
p =
new
myPromise(
function (
resolve,
reject) {
setTimeout(
function () {
console.
log(
this)
resolve(
1)
},
1000)
});
p.
then(
function (
x) {
console.
log(
x)
})
//输出 1 链式调用1 链式调用2
// 4.v4.0 then函数中的onFullfilled和onRejected方法的返回值问题
function
resolvePromise(
promise,
x,
resolve,
reject) {
if (
promise ===
x) {
throw
new
TypeError(
"type error") }
let
isUsed;
if (
x !==
null && (
typeof
x ===
"object" ||
typeof
x ===
"function")) {
try {
let
then =
x.
then;
if (
typeof
then ===
"function") {
//是一个promise的情况
then.
call(
x,
function (
y) {
if (
isUsed)
return;
isUsed =
true;
resolvePromise(
promise,
y,
resolve,
reject);
},
function (
e) {
if (
isUsed)
return;
isUsed =
true;
reject(
e);
})
}
else {
//仅仅是一个函数或者是对象
resolve(
x)
}
}
catch (
e) {
if (
isUsed)
return;
isUsed =
true;
reject(
e);
}
}
else {
//返回的基本类型，直接resolve
resolve(
x)
}
}
myPromise.
prototype.
then =
function (
onFullfilled,
onRejected) {
let
self =
this;
let
promise2;
switch (
self.
status) {
case
"pending":
promise2 =
new
myPromise(
function (
resolve,
reject) {
self.
onFullfilledArray.
push(
function () {
setTimeout(
function () {
try {
let
temple =
onFullfilled(
self.
value);
resolvePromise(
temple)
}
catch (
e) {
reject(
e)
//error catch
}
})
});
self.
onRejectedArray.
push(
function () {
setTimeout(
function () {
try {
let
temple =
onRejected(
self.
reason);
resolvePromise(
temple)
}
catch (
e) {
reject(
e)
// error catch
}
})
});
})
case
"resolved":
promise2 =
new
myPromise(
function (
resolve,
reject) {
setTimeout(
function () {
try {
let
temple =
onFullfilled(
self.
value);
//将上次一then里面的方法传递进下一个Promise状态
resolvePromise(
temple);
}
catch (
e) {
reject(
e);
//error catch
}
})
})
break;
case
"rejected":
promise2 =
new
myPromise(
function (
resolve,
reject) {
setTimeout(
function () {
try {
let
temple =
onRejected(
self.
reason);
//将then里面的方法传递到下一个Promise的状态里
resolvePromise(
temple);
}
catch (
e) {
reject(
e);
}
})
})
break;
default:
}
return
promise2;
}