// 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;
}