注:本文案例环境为非严格模式，严格模式下禁止关键字this指向全局对象

一、方法是怎么执行的？

首先说一下js中方法的执行，在window全局下声明一个方法a：

function a () {
  console.log(this);
}
a();//window

全局中执行这个方法普遍的方法是直接a()，这个方法的执行环境是window，控制台会打印出window对象。

那么为什么会打印出window对象呢？我们可以这样理解，方法的执行必须要有个直接调用者，刚才那个方法a是定义在window全局下的，window下的变量和方法有个特点就是访问和调用的时候可以省略window！所以刚才执行a() === window.a()，也就是说，执行a方法时的直接调用者是window。！

上面有提到直接调用者，怎么看待这个直接调用者呢？举个例子，声明一个全局对象obj：

var name = "window-name";
var obj = {
    name:"obj-name",
    a:function(){
        console.log(this.name);
    },
    b:{
        name:"b-name",
        a:function(){
            console.log(this.name);
        }
    }
}
obj.a();//obj-name
obj.b.a();//b-name

分别执行obj.a();和obj.b.a();控制台会分别打印出obj-name和b-name（这里obj.a() === window.obj.a()，obj.b.a() === window.obj.b.a()），方法执行时的直接调用者就是离这个被调用方法最近的那个对象，两个分别是obj和obj.b，打印出的name分别是obj的name和obj.b的name。

二、this指向了谁？

那么函数里面的this到底是谁呢？this就是这个方法被调用时的直接调用者。可以再来个特殊的例子，理解这个例子了就能很好理解this指向了谁。在刚才的基础上定义一个全局变量：

var ax = obj.b.a;
ax();//window-name

此时执行ax();控制台则会打印出window-name;为什么会打印出window-name？这是因为 ax 是定义在window全局下的变量，执行ax()时的直接调用者是window（ax() === window.ax()），所以执行ax()时内部的this就是它的直接调用者window，因此打印出的值就是定义在window下的name的值，所以本文最开始时的a()，执行后会打印window，因为内部的this指向的是a的调用者window。

实际上在非严格模式下，如果方法有直接调用者，那么this指向的是这个直接调用者，在没有直接调用者（比如回调函数）的情况下this指向的是全局对象（浏览器中是window，node中是global）。

三、call和apply改变了什么？

理解了函数的直接调用者和this，再说call和apply就比较容易理解了。在此对call和apply不做过多的定义性解释，先来看下调用了call后谁是那个被执行的方法，直接代码示例：

function fn1 () {
    console.log(1);
};
function fn2 () {
    console.log(2);
};
fn1.call(fn2);//1

执行fn1.call(fn2);控制台会打印1，这里可以说明fn1调用call后被执行的方法还是fn1。一定要弄清楚谁是这个被执行的方法，就是调用call的函数，而fn2现在的身份是替代window作为fn1的直接调用者，这是理解call和apply的关键，也可以运行下fn2.call(fn1);//2来验证被执行的方法是谁。那么call的作用是什么呢？再来个代码示例：

var obj1 = {
    num : 20,
    fn : function(n){
        console.log(this.num+n);
    }
};
var obj2 = {
    num : 15,
    fn : function(n){
        console.log(this.num-n);
    }
};
obj1.fn.call(obj2,10);//25

执行obj1.fn.call(obj2,10);控制台会打印25，call在此的作用其实很简单，就是在执行obj1.fn的时候把这个fn的直接调用者由obj1变为obj2，obj1.fn(n)内部的this经过call的作用指向了obj2，所以this.num就是obj2.num，10作为执行obj1.fn时传入的参数，obj2.num是15，因此打印出的值是15+10=25。

所以我们可以这样理解：call的作用是改变了那个被执行的方法(也就是调用call的那个方法)的直接调用者！而这个被执行的方法内部的this也会重新指向那个新的调用者，就是call方法所接收的第一个obj参数。还有两个特殊情况就是当这个obj参数为null或者undefined的时候，this会指向window。

四、call和apply的区别

call方法除了第一个obj参数外，还接受一串参数作为被执行的方法的参数，apply用法和call类似，只不过除第一个obj参数外，接收的第二个参数是一个数组来作为被执行的方法的参数。

五、延伸拓展

我们来执行下面的代码：

fn1.call.call(fn2);//2

执行fn1.call.call(fn2);控制台会打印出2，先不说为什么会打印出2，先来理解下fn1.call.call是什么，call()方法是Function对象原型链上的方法，所以fn1这个函数可以通过原型链继承使用这个方法，也就是说fn1.call === Function.prototype.call === Function.call。所以fn1.call.call(fn2) === Function.call.call(fn2)，可以把Function.call先看做一个整体，用FunCall来表示如下：

FunCall.call(fn2);

这样就比较好理解，相当于是fn2作为FunCall的直接调用者来执行FunCall，而FunCall === Function.call，所以就相当于是fn2.call()。

此时call没有传入对象，那么全局对象window就会作为默认对象，也就是相当于fn2.call(window)，再继续解释就是window.fn2.call(window)，把fn2的直接调用对象变成window，所以就相当于直接执行了fn2();控制台会打印出2。

此外还有Function.call.apply和Function.apply.call等多种组合，原理都类似，只不过接收的参数类型不太一样，可以尝试一下。加深对call和apply的理解。

六、补充bind

bind用法和call类似，只不过调用bind后方法不能立即执行需要再次调用，其实就是柯里化的一个语法糖。我们来实现一个简易版的bind方法，命名为bindFn，大致就能了解bind了：

Function.prototype.bindFn = function() {
    var args = Array.prototype.slice.call(arguments);//得到传入的参数
    var obj = args.shift();//得到第一个传入的对象
    var self = this; // 调用bindFn的函数
    
    return function() { // return一个函数 实现柯里化
        //拼接新参数
        var newArgs = args.concat(Array.prototype.slice.call(arguments));
        //下面这里使用了apply,用来改变self的直接调用者
        return self.apply(obj,newArgs);
    }
}
//测试一下，doSum方法实现对传入的参数的累加，并把累加结果返回
function doSum(){
    var arg = Array.prototype.slice.call(arguments);
    return arg.length ? arg.reduce((a,b) => a + b) : "";
}
var newDoSum = doSum.bindFn(null,1,2,3);
console.log(newDoSum());//6
console.log(newDoSum(4));//10
console.log(newDoSum(4,5));//15