call和apply的使用

就是想整理一篇关于call和apply的文档，不想编一些什么最近学习的时候遇到问题研究之后想分享给大家之类的理由，就是想写！就是想发！就是想！！！

以下是正文>>>>>>>>>

 

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

一、window对象

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

 

var a = 10;             //全局变量

function abc(){         //全局函数

    console.log("liyang");

}

console.log(window);  //此时在window对象内已经出现了a属性和abc函数

就是想整理一篇关于call和apply的文档，不想编一些什么最近学习的时候遇到问题研究之后想分享给大家之类的理由，就是想写！就是想发！就是想！！！

以下是正文>>>>>>>>>

 

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

一、window对象

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

 

var a = 10;             //全局变量

function abc(){         //全局函数

    console.log("liyang");

}

console.log(window);  //此时在window对象内已经出现了a属性和abc函数

 

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

 

window.a;        //10

window.abc();   //liyang

 

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

 

a;               //10

abc();           //liyang

 

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

 

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

 

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

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

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

 

var obj = {

    name:"liyang",

    show:function(){

        console.log(this);

    }

}

obj.name;        //liyang

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();        //AAA

 

var B = new ProB("BBB","dance");

B.fn();        //Uncaught TypeError: B.fn is not a function;

 

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”参数必须是数组的形式)，call方法自动执行改变之后的原函数

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();        //AAA

 

var B = new ProB("BBB","dance");

B.fn();        //Uncaught TypeError: B.fn is not a function;

 

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

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

    

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

 

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

 

    

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

 

window.a;        //10

window.abc();   //liyang

 

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

 

a;               //10

abc();           //liyang

 

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

 

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

 

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

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

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

 

var obj = {

    name:"liyang",

    show:function(){

        console.log(this);

    }

}

obj.name;        //liyang

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();        //AAA

 

var B = new ProB("BBB","dance");

B.fn();        //Uncaught TypeError: B.fn is not a function;

 

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”参数必须是数组的形式)，call方法自动执行改变之后的原函数

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();        //AAA

 

var B = new ProB("BBB","dance");

B.fn();        //Uncaught TypeError: B.fn is not a function;

 

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

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

    

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

 

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

来源：千锋HTML5