call和apply的使用-基础篇

在使用call和apply之前，我们需要先做一些知识储备：

一、window对象

window对象是js中的顶层对象，所有全局变量和全局函数都被绑定在了window对象身上，如何证明呢，我们可以先声明一个全局变量和函数，然后来观察window对象。如代码1-1：

var a = 10;               //全局变量
function abc(){           //全局函数
    console.log("Young");
}
console.log(window);      //此时在window对象内已经出现了a属性和abc函数

那我们在定义了全局的变量a和全局的函数abc之后，为什么在使用他们时没有加上window对象的前缀呢，如代码1-2

window.a;               //10
window.abc();           //Young

这是因为window对象作为一个全局对象，一般情况下在使用的时候是可以省略的，也就是不写，如代码1-3

a;               //10
abc();           //Young

也是可以拿到a的值和执行abc函数。以上两种书写方式等价。

简单总结，window可以说是js中最大的boss，所有在明面上的人员和交易，都是属于window的，就算人员没有特别说明，每笔交易也没有单独的署名，但是window对象永远都是掌控一切。

二、this关键字，也就是所谓的执行上下文

说执行上下文可能有好多同学不明白，那么我们就说this这个关键字的含义。

this关键字存在于函数中，表示是一个指向，或者说是一个系统“变量”，值并不是固定的，但总是有迹可循。this的指向永远是一个对象，我们看代码2-1：

var obj = {
    name: "Young",
    show: function (){
      console.log(this);
    }
}
obj.name;        //Young
obj.show();      //obj

从上面代码可以看出，this指向当前函数所在的obj对象，或者说this指向当前函数的调用对象，单只一个案例看不出规律，那么我们再来一个代码2-2:

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

此处执行函数fn之后，打印出fn内部的this为window对象，结合window知识点，可知此时的fn是一个全局函数，属于window对象，执行fn时，相当于执行了window.fn()，fn在window对象那且被window对象调用，所以fn内部的this指向了window。

再看代码2-3:

var obox = document.getElementById("box");
obox.onclick= function (){
    console.log(this);
}
//单击obox这个div时，控制台打印出obox这个div标签

因为obox是一个元素对象，给obox元素添加点击事件，相当于给obox元素对象添加一个onclick属性，属性值为function，函数内部有一个this，当点击obox触发onclick，执行function时，打印出当前对象obox，依然符合this指向调用当前函数对象的原则。

综上所述，this的指向为：谁掉用当前this所在的函数，this就指向谁。也就是说，当前调用函数的那个对象自身就是this，就是当前的执行上下文。

三、执行上下文(this)的改变

执行上下文(this)是可以被改变的，为什么要改变执行上下文(this)呢，我们来模拟一种场景：

宿舍中，小A有每天洗头的习惯，每次洗完之后，头发湿漉漉的不方便，于是就攒钱买了一个吹风机，洗完之后吹一吹，神清气爽。小B洗头没有小A频繁，偶尔洗一次，洗完之后也是湿漉漉的不方便，但是又因为自己洗的次数少，所以不想再单独买一个吹风机，于是每次就借用小A的吹风机。

那么此时，我们如果把小A和小B都理解成一个对象，吹风机就是小A方法，它的所有人就是小A，小A在使用吹风机的时候，小A就是吹风就的执行上下文(this)。小B偶尔会需要用到吹风机，因为使用频次少，没必要重新买一个造成资源浪费，所以每次都是借用小A的，那么小B在使用吹风机的时候，吹风机被小B调用，此时小B就是吹风机的执行上下文(this)。此时吹风机的执行上下文(this)就被修改了。

（此情景仅为模拟，不适用于现实生活，现实生活中不推荐小B的做法）

在代码中，当一个对象A具有一个方法fn，另一个对象B没有方法，但是需要用到同样功能的fn方法时，可以通过改变A对象中函数fn的执行上下文(this)来实现调用，达到节约代码空间，不产生冗余函数的目的。如代码3-1(字面量创建对象写法):

var A = {
    name: "AAA",
    fn: function(skill){
    this.skill = skill;
      console.log("my name is " + this.name +", my skills are " + this.skill);
    }
}
var B = {
    name: "BBB"
}
A.fn("sing");          //my name is AAA, my skills are sing
B.fn("dance");         //Uncaught TypeError: B.fn is not a function;

代码3-2(构造函数创建对象写法):

function ProA(name, skill){
    this.name = name;
    this.skill = skill;
    this.fn = function(){
      console.log("my name is " + this.name +", my skills are " + this.skill);
    }
}
function ProB(name, skill){   }

var A = new ProA("AAA","sing");
A.fn();             //AAA

var B = new ProB("BBB","dance");
B.fn();             //Uncaught TypeError: B.fn is not a function;

那么当我们确定好需求之后，接下来的操作就简单了，只要能找到一种方法，能够将对象A中函数fn的上下文修改成B对象，就可以解决这些问题。

此时，就可以使用call和apply这两个函数的方法，接下来我们只需要如何使用call和apply即可。

四、call和apply的使用

以上可得知call和apply这两个方法的功能是：用来修改函数的执行上下文(this)。

call和apply其实都是函数的方法，我们知道方法是对象中的函数，那么函数怎么还可以有函数呢，我们可以结合js中万物皆对象这句话，其实function在js中也是一个对象（可结合对象的原型来理解了，此处暂不做深究，了解原型请参考下篇文档），所以函数也有方法。

那么这两个方法如何使用呢，我们先来看完整语法：

call(thisObj,arg1,arg2,arg3,……)

call方法接收一个或一个以上的参数，当接收一个参数时，第一个参数表示要改变的原函数的执行上下文(this)；接收多个参数时，第二个参数及后面所有参数用来替换原函数的参数。

将代码3-1使用call方法改成如下代码4-1方式，即可让对象B具有对象A的fn方法，代码4-1：

var A = {
    name: "AAA",
    fn: function(skill){
        this.skill = skill;
        console.log("my name is " + this.name +", my skills are " + this.skill);
    }
}
var B = {
    name: "BBB"
}
A.fn("sing");                 //my name is AAA, my skills are sing
//此处改动产生的效果为：
//在执行A对象的函数fn时，通过call将函数fn的执行上下文(this)暂时修改为对象B，
//此时fn中的this指向对象B，同时修改原函数fn的参数为“dance”，
//call方法自动执行改变之后的原函数
A.fn.call(B,"dance");         //my name is BBB, my skills are dance

将代码3-2使用call方法改成如下代码4-2方式，构造函数方式创建对象写法，代码4-2

function ProA(name, skill){
    this.name = name;
    this.skill = skill;
    this.fn = function(){
        console.log("my name is " + this.name +", my skills are " + this.skill);
    }
}
function ProB(name, skill){
    //此处改动产生的效果为：
    //在ProB内，通过apply，执行，并改动ProA中的执行上下文(this)，
    //及修改ProA的参数为ProB所接收的参数
    //那么在new调用ProB时，相当于调用了被修改了执行上下文和参数之后的ProA
    ProA.call(this, name, skill)
}
var A = new ProA("AAA","sing");
A.fn();          //my name is AAA, my skills are sing
var B = new ProB("BBB","dance");
B.fn();          //my name is BBB, my skills are dance

apply(thisObj,argArr)

apply方法接受一个或两个参数，当接收一个参数时，第一个参数表示要改变的原函数的执行上下文(this)；接收两个参数时，第二个参数必须是数组(或伪数组)，用于替换原函数中arguments保存的参数，

将代码3-1使用apply方法改成如下代码4-3方式，即可让对象B具有对象A的fn方法，代码4-3：

var A = {
    name: "AAA",
    fn: function(skill){
    this.skill = skill;
        console.log("my name is " + this.name +", my skills are " + this.skill);
    }
}
var B = {
    name: "BBB"
}
A.fn("sing");                  //my name is AAA, my skills are sing
//此处改动产生的效果为：
//在执行A对象的函数fn时，通过apply将函数fn的执行上下文(this)暂时修改为对象B，
//此时fn中的this指向对象B，同时修改原函数fn的参数为“dance”(注意“dance”参数必须是数组的形式)，
//apply方法自动执行改变之后的原函数
A.fn.apply(B,["dance"]);       //my name is BBB, my skills are dance

将代码3-2使用call方法改成如下代码4-2方式，构造函数方式创建对象写法

function ProA(name, skill){
    this.name = name;
    this.skill = skill;
    this.fn = function(){
        console.log("my name is " + this.name +", my skills are " + this.skill);
    }
}
function ProB(name, skill){
    //此处改动产生的效果为：
    //在ProB内，通过apply，执行，并改动ProA中的执行上下文(this)，
    //及修改ProA的参数为ProB所接收的参数(注意：此时的参数必须是一个数组的格式)
    //那么在new调用ProB时，相当于调用了被修改了执行上下文和参数之后的ProA
    ProA.apply(this, [name, skill])
    //参数也可以写成arguments的形式，arguments属于伪数组，但是也可以被apply所接收处理，如：
    //ProA.apply(this, arguments)
}
var A = new ProA("AAA","sing");
A.fn();        //my name is AAA, my skills are sing
var B = new ProB("BBB","dance");
B.fn();        //my name is BBB, my skills are dance

以上就是call和apply的使用，在我们明确需求的情况下，只需要掌握call或apply固定语法，就可以自由的转换某个对象中函数的执行上下文(this)了。

同时，在OOP中，通过call和apply改变执行上下文(this)，实现使原本没有某个方法的对象，具有这个方法，的这个过程也叫继承。

以上，如有描述不详，或文中有误，欢迎留言修改。

---

后期又出了一篇《call和apply的使用-扩展篇》，通过修改函数call和apply修改当前函数的执行上下文(this)，我们可以让一些原本不具有某个功能的对象，具有某个功能，从而更方便的进行编程。