call,bind,apply

都是原型上提供的共有属性方法，三个都是改变函数的this指向的方法

call

语法：函数.call([context],[params1],….),传值是一个个的传递
函数基于原型链找到Function.prototype.call这个方法，并且把它执行，在call方法执行的时候完成了一些功能:

1. 让当前函数执行
2. 把函数中的THIS指向改为第一个传递给CALL的实参
3. 把传递给CALL其余的实参，当做参数信息传递给当前函数
4. 如果执行CALL一个实参都没有传递，非严格模式下是让函数中的THIS指向WINDOW，严格模式下指向的是UNDEFINED

window.name = 'WINDOW';
let obj = {name: 'OBJ'};
function fn(n,m) {
    console.log(this.name);
}
fn(10,20); //=>this:window  严格下是undefined
fn.call(obj); //=>this:obj  n/m=undefined
fn.call(obj,10,20); //=>this:obj  n=10 m=20
fn.call(10,20); //=>this:10  n=20  m=undefined
fn.call(); //=>this:window  严格下是undefined
fn.call(null); //=>this:window  严格下是null（第一个参数传递的是null/undefined/
  不传，非严格模式下this指向window，严格模式下传递的是谁this就是谁，不传this是undefined）

重写call方法

~ function () {
    /*
     * call：改变函数中的THIS指向 
     *   @params
     *      context 可以不传递，传递必须是引用类型值（因为后面要给它加$fn的属性）  
     */
    function call(context) {
        //this:sum 也就是当前要操作的这个函数实例
        context = context || window;
        let args = [], //=>除第一个参数外剩余传递的信息值
            result;
        for (let i = 1; i < arguments.length; i++) {
            args.push(arguments[i]);
        }
        context.$fn = this;
        result = context.$fn(...args); //=>args=[10,20] ...是ES6中的展开运算符，把数组中的每一项分别的展开传递给函数 //=>context.$fn(10,20)
        delete context.$fn;
        return result;
    }
    /* 扩展到内置类的原型上 */
    Function.prototype.call = call;
}();

apply

语法：函数.call([context],[a,b,c…]),传值是以数组的形式传的，其他的与call方法相同

bind

用法同call/bind相同，区别于他们的是，bind不是立即执行this，而是预先改变this

let obj={name:'OBJ'};
function fn(){
    console.log(this.name);
}
document.body.onclick=fn; //=>当事件触发,fn中的this:BODY
//=>点击BODY，让FN中的THIS指向OBJ
//document.body.onclick=fn.call(obj); //=>基于call/apply这样处理，不是把fn绑定给事件，而是把fn
执行后的结果绑定给事件
document.body.onclick=function(){
    //this:BODY
    fn.call(obj);
}
document.body.onclick=fn.bind(obj); //=>bind的好处是：通过bind方法只是预先把fn中的this修改为obj
，此时fn并没有执行呢，当点击事件触发才会执行fn（call/apply都是改变this的同时立即把方法执行） =>在IE6~8中不支持bind方法  预先做啥事情的思想被称为“柯理化函数”