call和apply的使用

时间:2019-09-18
本文章向大家介绍call和apply的使用,主要包括call和apply的使用使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

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

一、window对象

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

再看代码

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)的改变

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

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;

(构造函数创建对象写法):

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);接收多个参数时,第二个参数及后面所有参数用来替换原函数的参数。

如下使用call方法使A具有B的方法,如下代码:

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

使用call方法 构造函数方式创建对象写法:

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保存的参数。

使用apply方法让对象B具有对象A的fn方法:

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

构造函数方式创建对象写法

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),实现使原本没有某个方法的对象,具有这个方法,的这个过程也叫继承。

原文地址:https://www.cnblogs.com/mengshou/p/11543362.html