手写promise

function Promise(fn) {
	var self = this;
	self.status = 'pending';
	self.onResolvedCallback = [];
	self.onRejectedCallback = [];

	function resolve(value) {
		if (value instanceof Promise) {
			return value.then(resolve, reject);
		}
		setTimeout(function () {
			if (self.status === 'pending') {
				self.status = 'resolved';
				self.data = value;
				self.onResolvedCallback.forEach(fn => fn(value));
			}
		})
	}

	function reject(reason) {
		setTimeout(function () {
			if (self.status === 'pending') {
				self.status = 'rejected';
				self.data = reason;
				self.onRejectedCallback.forEach(fn => fn(reason));
			}
		})
	}

	try {
		fn(resolve, reject);
	} catch (reason) {
		reject(reason);
	}
}

function resolvePromise(promise2, x, resolve, reject) {
	var then;
	var thenCalledOrThrow = false;
	if (promise2 === x) {
		return reject(new TypeError('Chaining cycle detected for primise!'));
	}
	if (x instanceof Promise) {
		if (x.status === 'pending') {
			x.then(function (v) {
				resolvePromise(promise2, v, resolve, reject);
			}, reject)
		} else {
			x.then(resolve, reject);
		}
		return;
	}
	if ((x !== null) && (typeof x === 'object') || (typeof x === 'function')) {
		try {
			then = x.then;
			if (typeof then === 'function') {
				then.call(x, function rs(y) {
					if (thenCalledOrThrow) return;
					thenCalledOrThrow = true;
					return resolvePromise(promise2,)
				}, function rj(r) {
					if (thenCalledOrThrow) return;
					thenCalledOrThrow = true;
					return reject(r);
				})
			} else {
				resolve(x)
			}
		} catch (error) {
			if (thenCalledOrThrow) return;
			thenCalledOrThrow = true;
			return reject(error);
		}
	}
}

// 版本一
Promise.prototype.then = function (onResolved, onRejected) {
	var self = this;
	var promise2;
	onResolved = typeof onResolved === 'function' ? onResolved : function (v) { return v };
	onRejected = typeof onRejected === 'function' ? onRejected : function (r) { return r };
	if (self.status === 'resolved') {
		return promise2 = new Promise(function (resolve, reject) {
			setTimeout(function () {
				try {
					var x = onResolved(self.data);
					resolvePromise(promise2, x, resolve, reject);
				} catch (reason) {
					reject(reason)
				}
			})
		})
	}
	if (self.status === 'rejected') {
		return promise2 = new Promise(function (resolve, reject) {
			setTimeout(function () {
				try {
					var x = onRejected(self.data);
					resolvePromise(promise2, x, resolve, reject);
				} catch (reason) {
					reject(reason)
				}
			})
		})
	}
	if (self.status === 'pending') {
		return promise2 = new Promise(function (resolve, reject) {
			self.onResolvedCallback.push(function (value) {
				try {
					var x = onResolved(value);
					resolvePromise(promise2, x, resolve, reject);
				} catch (r) {
					reject(r);
				}
			})
			self.onRejectedCallback.push(function (reason) {
				try {
					var x = onRejected(reason);
					resolvePromise(promise2, x, resolve, reject);
				} catch (r) {
					reject(r);
				}
			})
		})
	}
}

// 版本二
Promise.prototype.then = function (onResolved, onRejected) {
	var self = this;
	onResolved = typeof onResolved === 'function' ? onResolved : function (v) { return v };
	onRejected = typeof onRejected === 'function' ? onRejected : function (r) { return r };
	if (self.status === 'resolved') {
		return new Promise(function (resolve, reject) {
			if (self.data instanceof Promise) {
				self.data.then(onResolved, onRejected)
			} else {
				try {
					resolve(onResolved(self.data));
				} catch (e) {
					reject(e)
				}
			}
		})
	}
	if (self.status === 'rejected') {
		return new Promise(function (resolve, reject) {
			try {
				resolve(onRejected(self.data));
			} catch (e) {
				reject(e)
			}
		})
	}
	if (self.status === 'pending') {
		return new Promise(function (resolve, reject) {
			self.onResolvedCallback.push(function () {
				if (self.data instanceof Promise) {
					self.data.then(onResolved, onRejected)
				} else {
					try {
						resolve(onResolved(self.data))
					} catch (e) {
						reject(e);
					}
				}
			})
			self.onRejectedCallback.push(function () {
				try {
					resolve(onRejected(self.data))
				} catch (e) {
					reject(e);
				}
			})
		})
	}
}

Promise.prototype.catch = function (onRejected) {
	return this.then(null, onRejected);
}