手写底层 —— New、Call、Bind等

function myNew(Con, args){
	let obj = {};  // const obj = Object.create({});
	Object.setPrototypeOf(obj, Con.prototype);  //obj.__prototype__ = con.prototype;
	let result = Con.call(obj, args);
    // 在构造函数有返回值的情况进行判断
	return typeof result === 'object'? result : obj;
}

Function.prototype.myCall = function(context, ...args){
	//context存在 默认window对象
	context = context && typeof context === 'object'? context : window;
	//防止覆盖原属性
	const key = Symbol();
	//this为方法
	context[key] = this;
	const result = context[key](...args);
	delete context[key];
	return result;
}

Function.prototype.myApply = function(context, args = []){
	context = context && typeof context === 'object'? context : window;
	const key = Symbol();
	context[key] = this;
	const result = context[key](...args);
	delete context[key];
	return result;
}

Function.prototype.myBind = function(context, ...args){
	let self = this;
	let fn = function(...args2){
		self.apply(this instanceof fn? this : context, [...args, ...args2]);
	}
	fn.prototype = object(self.prototype);  //保护
	return fn;
}

var a = {
    b : function(){
        var func = function(){
            console.log(this.c);
        }
        func();
    },
    c : 'Hello!'
}
a.b();
//undefined
//this指向b

var a = {
    b : function(){
        var that = this;
        var func = function(){
            console.log(that.c);
        }
        func();
    },
    c : 'Hello!'
}
a.b();
//Hello!
//可以通过赋值的方式将this赋值给that

var a = {
    b : function(){
        var func = function(){
            console.log(this.c);
        }.bind(this);
        func();
    },
    c : 'Hello!'
}
a.b();
//Hello!
 
var a = {
    b : function(){
        var func = function(){
            console.log(this.c);
        }
        func.bind(this)();
    },
    c : 'Hello!'
}
a.b();
//Hello!

function f(y, z){
    return this.x + y + z;
}
var m = f.bind({x : 1}, 2);
console.log(m(3));
//6

const MyPromise = (function(){
	const PromiseStatus = Symbol('PromiseStatus'),
		  PromiseValue = Symbol('PromiseValue');

	const _PENDING = 'pending';
	const _FULFILLED = 'fulfilled';
	const _REJECTED = 'rejected';

	const fulFilledList = Symbol('fulFilledList'),
		  rejectedList = Symbol('rejectedList');

	let that = null;

	const settleHandler = (_status, handler, queue) => {
		if(that[PromiseStatus] === _status){
			setTimeout(() => handler(that[PromiseValue]), 0);
		}else{
			queue.push(handler);
		}
	}

	const changePromiseStatus = (_status, _result) => {
		//Promise的状态一旦改变就不可以进行逆转, 所以我们必须确定当前阶段不是已决
		if( that[PromiseStatus] != _PENDING) return;
		that[PromiseStatus] = _status;
		that[PromiseValue] = _result;
		
		if(that[PromiseStatus] == _FULFILLED){
			that.fulFilledList.forEach((ele) => { ele(that[PromiseValue]); });
		}else{
			that.rejectedList.forEach((ele) => { ele(that[PromiseValue]); });
		}
	}
	const resolve = _data => {
		changePromiseStatus(_FULFILLED, _data);
	}

	const reject = _error => {
		changePromiseStatus(_REJECTED, _error);
	}
	return class MyPromise {
		constructor(executor){
			that = this;
			this[PromiseStatus] = _PENDING;
			this[PromiseValue] = undefined;
			this[fulFilledList] = [];
            this[rejectedList] = [];
			try{
				executor(resolve, reject);
			}
			// 如果我们在executor中报错, 则会直接触发reject从而进入rejected状态
			catch(err){
				reject(err);
			}	
		}

		then = (thenable, catchable) => {
			settleHandler(_FULFILLED, thenable, this[fulFilledList]);
			//a() && b() 如果 a 执行成功返回 true 则执行 b 返回 b 结果的值
			typeof catchable === 'function' &&  this.catch(catchable);
		}	

		catch = catchable => {
			settleHandler(_REJECTED, catchable, this[rejectedList]);
		}

	}
})();

function promiseAll(promises){
	if(!Array.isArray(promises)){
		throw new Error("Params must be an array!");
	}
	return new Promise((resolve, reject) => {
		let asyncLength = promises.length;
		let count = 0;
		let resArray = new Array(asyncLength);
		promises.forEach((item, index) => {
			Promise.resolve(item)
			.then((value) => {
				count++;
				resArray[index] = value;
				if(count==asyncLength){
					resolve(resArray);
				}
			})
			.catch((error) => {
				reject(error);
			})
		})
		
	})
}

function promiseRace(promises){
	if(!Array.isArray(promises)){
		throw new Error("Params must be an array!");
	}
	return new Promise((resolve, reject) => {
		promises.forEach((item) => {
			Promise.resolve(item)
			.then((value) => {
				resolve(value);
			})
			.catch((error) => {
				reject(error);
			})
		})
		
	})
}