手写promise

手写promise，在此整理下，方便自己后续翻看学习

class写法

class Promise{
	constructor(executor){
		this.PromiseState = 'pending';  //默认值pending
		this.PromiseResult = null;
		// 声明属性
		this.callbacks = [];
		// 保存实例对象的this值
		const self = this;
		// resolve函数
		function resolve (data){
			// 添加判断条件
			if(self.PromiseState !== 'pending') return;
			//1、 设置对象状态 （promiseState）
			self.PromiseState = 'fulfilled'
			// 2、设置对象结果值 （promiseResult）
			self.PromiseResult = data;
			// 支持多回调
			setTimeout(()=>{
				self.callbacks.forEach(item=>{
					item.onResolved(data)
				})			
			})
			// if(self.callback.onResolve){
			// 	self.callback.onResolve(data)
			// }
		}
		// reject函数
		function reject(data){
			// 添加判断条件
			if(self.PromiseState !== 'pending') return;
			//1、 设置对象状态 （promiseState）
			self.PromiseState = 'rejected'
			// 2、设置对象结果值 （promiseResult）
			self.PromiseResult = data;
			// 支持多回调
			setTimeout(()=>{
				self.callbacks.forEach(item=>{
					item.onRejected(data)
				})			
			})
			// if(self.callback.onReject){
			// 	self.callback.onReject(data)
			// }
		}
		// 抛异常
		try{
			// 同步调用，执行器函数
			executor(resolve,reject);
		}catch(e){
			//修改promise对象状态为【失败】
			reject(e);
		}
	}
	then(onResolve,onReject){
		const self = this;
		// 异常穿透，与值传递
		if(typeof onReject !== 'function'){
			onReject = reason=>{
				throw reason
			}
		}
		if(typeof onResolve !== 'function'){
			onResolve = value=>value
		}
		return new Promise((resolve,reject)=>{
			// 封装函数
			function callback(type){
				try{
					// 获取回调函数执行结果
					let result = type(self.PromiseResult);
					if(result instanceof Promise){
						result.then(v=>{
							resolve(v)
						},r=>{
							reject(r)
						})
					}else{
						// 结果的对象状态为成功
						resolve(result)
					}
				}catch(e){
					//TODO handle the exception
					reject(e)
				}
			}			
			// 调用回调函数 PromiseState
			if(this.PromiseState === 'fulfilled'){
				setTimeout(()=>{
					callback(onResolve)
				})				
			}	
			if(this.PromiseState === 'rejected'){
				setTimeout(()=>{
					callback(onReject)
				})
			}
			// 判断pending状态(异步执行)
			if(this.PromiseState === 'pending'){
				this.callbacks.push({
					onResolved:function(){
						callback(onResolve)
					},
					onRejected:function(){
						callback(onReject)
					}
				})
			}
		})
		
	}
	catch(onReject){
		return this.then(undefined,onReject)
	}
	static resolve(value){
		return new Promise((resolve,reject)=>{
			if(value instanceof Promise){
				value.then(v=>{
					resolve(v)
				},r=>{
					reject(r)
				})
			}else{
				// 设置状态为成功
				resolve(value)
			}
		})
	}
	static reject(reason){
		return new Promise((resolve,reject)=>{
			reject(reason)
		})
	}
	static all(promise){
		// 返回结果为peomise对象
		return new Promise((resolve,reject)=>{
			let count = 0;
			let arr = [];
			// 遍历
			for (let i = 0; i < promise.length; i++) {
				promise[i].then(v=>{
					arr[i] = v;
					count++;				
					if(promise.length===count){
						resolve(arr)
					}
				},r=>{
					reject(r)
				})
			}
		})
	}
	static race(promise){
		return Promise((resolve,reject)=>{
			for (var i = 0; i < promise.length; i++) {
				promise[i].then(v=>{
					resolve(v)
				},r=>{
					reject(r)
				})
			}
		})
	}
}

构造函数方式

// 声明构造函数
function Promise(executor){
	
	
}
// 添加then方法
Promise.prototype.then = function(onResolve,onReject){
	const self = this;
	// 异常穿透，与值传递
	if(typeof onReject !== 'function'){
		onReject = reason=>{
			throw reason
		}
	}
	if(typeof onResolve !== 'function'){
		onResolve = value=>value
	}
	return new Promise((resolve,reject)=>{
		// 封装函数
		function callback(type){
			try{
				// 获取回调函数执行结果
				let result = type(self.PromiseResult);
				if(result instanceof Promise){
					result.then(v=>{
						resolve(v)
					},r=>{
						reject(r)
					})
				}else{
					// 结果的对象状态为成功
					resolve(result)
				}
			}catch(e){
				//TODO handle the exception
				reject(e)
			}
		}
		
		// 调用回调函数 PromiseState
		if(this.PromiseState === 'fulfilled'){
			setTimeout(()=>{
				callback(onResolve)
			})
			
			// try{
			// 	// 获取回调函数执行结果
			// 	let result = onResolve(this.PromiseResult);
			// 	if(result instanceof Promise){
			// 		result.then(v=>{
			// 			resolve(v)
			// 		},r=>{
			// 			reject(r)
			// 		})
			// 	}else{
			// 		// 结果的对象状态为成功
			// 		resolve(result)
			// 	}
			// }catch(e){
			// 	//TODO handle the exception
			// 	reject(e)
			// }
			
		}	
		if(this.PromiseState === 'rejected'){
			setTimeout(()=>{
				callback(onReject)
			})
			// try{
			// 	// 获取回调函数执行结果
			// 	let result = onReject(this.PromiseResult);
			// 	if(result instanceof Promise){
			// 		result.then(v=>{
			// 			resolve(v)
			// 		},r=>{
			// 			reject(r)
			// 		})
			// 	}else{
			// 		// 结果的对象状态为成功
			// 		resolve(result)
			// 	}
			// }catch(e){
			// 	//TODO handle the exception
			// 	reject(e)
			// }
			
		}
		// 判断pending状态(异步执行)
		if(this.PromiseState === 'pending'){
			// 保存回调函数
			// this.callback = {
			// 	onResolve,
			// 	onReject
			// }
			// 支持多回调
			// this.callbacks.push({
			// 	onResolve,
			// 	onReject
			// })
			this.callbacks.push({
				onResolved:function(){
					callback(onResolve)
					// try{
					// 	let result = onResolve(self.PromiseResult)
					// 	if(result instanceof Promise){
					// 		result.then(v=>{
					// 			resolve(v)
					// 		},r=>{
					// 			reject(r)
					// 		})
					// 	}else{
					// 		resolve(result)
					// 	}
					// }catch(e){
					// 	//TODO handle the exception
					// 	reject(e)
					// }
					
				},
				onRejected:function(){
					callback(onReject)
					// try{
					// 	let result = onReject(self.PromiseResult)
					// 	if(result instanceof Promise){
					// 		result.then(v=>{
					// 			resolve(v)
					// 		},r=>{
					// 			reject(r)
					// 		})
					// 	}else{
					// 		resolve(result)
					// 	}
					// }catch(e){
					// 	//TODO handle the exception
					// 	reject(e)
					// }
				}
			})
		}
	})
	
}
// 添加catch方法
Promise.prototype.catch = function(onReject){
	return this.then(undefined,onReject)
}
// 添加resolve方法
Promise.resolve = function(value){
	return new Promise((resolve,reject)=>{
		if(value instanceof Promise){
			value.then(v=>{
				resolve(v)
			},r=>{
				reject(r)
			})
		}else{
			// 设置状态为成功
			resolve(value)
		}
	})
}
// 添加reject方法
Promise.reject = function(reason){
	return new Promise((resolve,reject)=>{
		reject(reason)
	})
}
// 添加all方法
Promise.all = function(promise){
	// 返回结果为peomise对象
	return new Promise((resolve,reject)=>{
		let count = 0;
		let arr = [];
		// 遍历
		for (let i = 0; i < promise.length; i++) {
			promise[i].then(v=>{
				arr[i] = v;
				count++;				
				if(promise.length===count){
					resolve(arr)
				}
			},r=>{
				reject(r)
			})
		}
	})
}
// 添加race方法
Promise.race = function(promise){
	return Promise((resolve,reject)=>{
		for (var i = 0; i < promise.length; i++) {
			promise[i].then(v=>{
				resolve(v)
			},r=>{
				reject(r)
			})
		}
	})
}