this

this是使用再一个作用域内部的关键字，全局很少用，大部分用于函数内部使用。

指向：

全局使用：指向window
函数使用：不管函数怎么定义，只看函数的调用（箭头函数除外）
     1.普通调用（直接调用/全局调用）
      	函数名（):this->window
     2.对象调用
     	xxx.函数名（）：this->xxx
     3.定时器处理函数：this->window
     	setTimeout()  setinterval()
     4.事件处理函数：this->事件源
     	xxx.onclick=function(){}
     	xxx.EventLisener(' ',function(){})
     5.自执行函数:this->window
     	(function（）{})

改变This指向

call()

调用方式：fn.call()或者obj.fn.call()
函数里第一个参数是this指向，第二个参数是给函数传递的参数
调用时会立即执行

function.prototype.call=function(context){
	if(typeof context==="undefined"||context===null)
		context=window
	context.fn=this;
	const args=[...argument].slice(1)
	const result=context.fn(...args)
	delete context.fn
	return result
}

apply（）

调用方式：fn.apply()或者obj.fn.apply()
函数里第一个参数是this指向，第二个参数是（一个数组或伪数组）给函数传递的参数
调用时会立即执行

function.prototype.call=function(context){
	if(typeof this!=='function'{
		throw new TypeError('Error')
	}
	context=context||window
	context.fn=this
	let result
	if(argument[1]){
		result=context.fn(...argument[1])
	]else{
		result=context.fn()
	}
	delete context.fn
	return result
}

bind()

调用方式：fn.bind()或者obj.fn.biind()
函数里第一个参数是this指向，第二个参数是（一个数组或伪数组）给函数传递的参数
调用时不会立即执行，会返回一个新的函数（函数里的this已经被改变）

function.prototype.bind(context){
	if(typeof this!=='function'{
		throw new TypeError('Error')
	}
	const _this=this
	const args=[...argument].slice(1)
	return function F(){
		if(this instanceof F)
		{return new _this(...args,...arguments)}
		return _this.apply(context,args.concat(..arguments))
	}
}