理解JS中的call、apply、bind方法(转)

理解JS中的call、apply、bind方法(*****************************************************************)





在JavaScript中，call、apply和bind是Function对象自带的三个方法，这三个方法的主要作用是改变函数中的this指向。

call、apply、bind方法的共同点和区别：
apply 、 call 、bind 三者都是用来改变函数的this对象的指向的；
apply 、 call 、bind 三者第一个参数都是this要指向的对象，也就是想指定的上下文（函数的每次调用都会拥有一个特殊值——本次调用的上下文（context）——这就是this关键字的值。）；
apply 、 call 、bind 三者都可以利用后续参数传参；
bind 是返回对应函数，便于稍后调用；apply 、call 则是立即调用 。

一、call

call()
语法：
call([thisObj[,arg1[, arg2[, [,.argN]]]]])

定义：调用一个对象的一个方法，以另一个对象替换当前对象。

说明： call 方法可以用来代替另一个对象调用一个方法。
call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。

thisObj的取值有以下4种情况：
（1） 不传，或者传null,undefined， 函数中的this指向window对象
（2） 传递另一个函数的函数名，函数中的this指向这个函数的引用
（3） 传递字符串、数值或布尔类型等基础类型，函数中的this指向其对应的包装对象，如 String、Number、Boolean
（4） 传递一个对象，函数中的this指向这个对象
function a(){  
  console.log(this);   //输出函数a中的this对象
}      

function b(){}      

var c={name:"call"};    //定义对象c 

a.call();   //window
a.call(null);   //window
a.call(undefined);   //window
a.call(1);   //Number
a.call('');   //String
a.call(true);   //Boolean
a.call(b);   //function b(){}
a.call(c);   //Object

如果你不理解上面的，没关系，我们再来看一个例子：
function class1(){  
  this.name=function(){  
    console.log("我是class1内的方法");  
  }  
}  
function class2(){
  class1.call(this);  //此行代码执行后，当前的this指向了class1（也可以说class2继承了class1）  
}  

var f=new class2();  
f.name();   //调用的是class1内的方法，将class1的name方法交给class2使用

常用例子：
（1）
function eat(x,y){  
  console.log(x+y);  
}  
function drink(x,y){  
  console.log(x-y);  
}  
eat.call(drink,3,2);

输出：5

这个例子中的意思就是用 eat 来替换 drink，eat.call(drink,3,2) == eat(3,2) ，所以运行结果为：console.log(5);
注意：js 中的函数其实是对象，函数名是对 Function 对象的引用。

（2）
function Animal(){  
  this.name="animal";  
  this.showName=function(){  
    console.log(this.name);  
  }  
}  
function Dog(){  
  this.name="dog";  
}  
var animal=new Animal();  
var dog=new Dog();      

animal.showName.call(dog);

输出：dog

在上面的代码中，我们可以看到Dog里并没有showName方法，那为什么（this.name）的值是dog呢？

关键就在于最后一段代码（animal.showName.call(dog)），意思是把animal的方法放到dog上执行，也可以说，把animal 的showName()方法放到 dog上来执行，所以this.name 应该是 dog。

（3）继承
function Animal(name){  
  this.name=name;  
  this.showName=function(){  
    console.log(this.name);  
  }  
}  
function Dog(name){  
  Animal.call(this,name);  
}  
var dog=new Dog("Crazy dog");  
dog.showName();

输出：Crazy dog

Animal.call(this) 的意思就是使用 Animal对象代替this对象，那么Dog就能直接调用Animal的所有属性和方法。

二、apply()

语法：apply([thisObj[,argArray]])

定义：应用某一对象的一个方法，用另一个对象替换当前对象。

说明：
如果 argArray 不是一个有效的数组或者不是 arguments 对象，那么将导致一个 TypeError。
如果没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用作 thisObj， 并且无法被传递任何参数。

call 和 apply的区别
对于 apply、call 二者而言，作用完全一样，只是接受参数的方式不太一样。
function class1(args1,args2){      
  this.name=function(){     
   console.log(args,args);     
  }    
}    
function class2(){   
  var args1="1";
  var args2="2";
  class1.call(this,args1,args2); 
  /*或*/
  class1.apply(this,[args1,args2]);
}

var c=new class2();  
c.name();

输出：1 2

call 需要把参数按顺序传递进去，而 apply 则是把参数放在数组里。

既然两者功能一样，那该用哪个呢？

在JavaScript 中，某个函数的参数数量是不固定的，因此要说适用条件的话，当你的参数是明确知道数量时用 call ；而不确定的时候用 apply，然后把参数 push 进数组传递进去。当参数数量不确定时，函数内部也可以通过 arguments 这个数组来遍历所有的参数。

三、bind
bind是在EcmaScript5中扩展的方法（IE6,7,8不支持）
bind() 方法与 apply 和 call 很相似，也是可以改变函数体内 this 的指向。

　　MDN的解释是：bind()方法会创建一个新函数，称为绑定函数，当调用这个绑定函数时，绑定函数会以创建它时传入 bind()方法的第一个参数作为 this，传入 bind() 方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数。

注意：bind方法的返回值是函数
var bar=function(){  
  console.log(this.x);  
}
var foo={
     x:3  
}  
bar(); 
bar.bind(foo)();
/*或*/
var func=bar.bind(foo);  
func();

输出：
undefined
3







这篇文章实在是很难下笔，因为网上相关文章不胜枚举。

巧合的是前些天看到阮老师的一篇文章的一句话：

“对我来说，博客首先是一种知识管理工具，其次才是传播工具。我的技术文章，主要用来整理我还不懂的知识。我只写那些我还没有完全掌握的东西，那些我精通的东西，往往没有动力写。炫耀从来不是我的动机，好奇才是。"

对于这句话，不能赞同更多，也让我下决心好好写这篇，网上文章虽多，大多复制粘贴，且晦涩难懂，我希望能够通过这篇文章，能够清晰的提升对apply、call、bind的认识，并且列出一些它们的妙用加深记忆。



   apply、call


在 javascript 中，call 和 apply 都是为了改变某个函数运行时的上下文（context）而存在的，换句话说，就是为了改变函数体内部 this 的指向。

JavaScript 的一大特点是，函数存在「定义时上下文」和「运行时上下文」以及「上下文是可以改变的」这样的概念。

先来一个栗子：


function fruits() {}



fruits.prototype = {

    color: "red",

    say: function() {

        console.log("My color is " + this.color);

    }

}



var apple = new fruits;

apple.say();    //My color is red



但是如果我们有一个对象banana= {color : "yellow"} ,我们不想对它重新定义 say 方法，那么我们可以通过 call 或 apply 用 apple 的 say 方法：

banana = {

    color: "yellow"

}

apple.say.call(banana);     //My color is yellow

apple.say.apply(banana);    //My color is yellow


所以，可以看出 call 和 apply 是为了动态改变 this 而出现的，当一个 object 没有某个方法（本栗子中banana没有say方法），但是其他的有（本栗子中apple有say方法），我们可以借助call或apply用其它对象的方法来操作。



   apply、call 的区别

对于 apply、call 二者而言，作用完全一样，只是接受参数的方式不太一样。例如，有一个函数定义如下：


var func = function(arg1, arg2) {

    

};


就可以通过如下方式来调用：

func.call(this, arg1, arg2);

func.apply(this, [arg1, arg2])


其中 this 是你想指定的上下文，他可以是任何一个 JavaScript 对象(JavaScript 中一切皆对象)，call 需要把参数按顺序传递进去，而 apply 则是把参数放在数组里。　　

JavaScript 中，某个函数的参数数量是不固定的，因此要说适用条件的话，当你的参数是明确知道数量时用 call 。

而不确定的时候用 apply，然后把参数 push 进数组传递进去。当参数数量不确定时，函数内部也可以通过 arguments 这个数组来遍历所有的参数。



为了巩固加深记忆，下面列举一些常用用法：

1、数组之间追加


var array1 = [12 , "foo" , {name "Joe"} , -2458];

var array2 = ["Doe" , 555 , 100];

Array.prototype.push.apply(array1, array2);

/* array1 值为  [12 , "foo" , {name "Joe"} , -2458 , "Doe" , 555 , 100] */


2、获取数组中的最大值和最小值

var  numbers = [5, 458 , 120 , -215 ];

var maxInNumbers = Math.max.apply(Math, numbers),   //458

    maxInNumbers = Math.max.call(Math,5, 458 , 120 , -215); //458


number 本身没有 max 方法，但是 Math 有，我们就可以借助 call 或者 apply 使用其方法。

3、验证是否是数组（前提是toString()方法没有被重写过）


functionisArray(obj){

    return Object.prototype.toString.call(obj) === '[object Array]' ;

}


4、类（伪）数组使用数组方法


var domNodes = Array.prototype.slice.call(document.getElementsByTagName("*"));


Javascript中存在一种名为伪数组的对象结构。比较特别的是 arguments 对象，还有像调用 getElementsByTagName , document.childNodes 之类的，它们返回NodeList对象都属于伪数组。不能应用 Array下的 push , pop 等方法。

但是我们能通过 Array.prototype.slice.call 转换为真正的数组的带有 length 属性的对象，这样 domNodes 就可以应用 Array 下的所有方法了。



   深入理解运用apply、call

下面就【借用一道面试题】，来更深入的去理解下 apply 和 call 。

定义一个 log 方法，让它可以代理 console.log 方法，常见的解决方法是：

function log(msg)　{

  console.log(msg);

}

log(1);    //1

log(1,2);    //1


上面方法可以解决最基本的需求，但是当传入参数的个数是不确定的时候，上面的方法就失效了，这个时候就可以考虑使用 apply 或者 call，注意这里传入多少个参数是不确定的，所以使用apply是最好的，方法如下：

function log(){

  console.log.apply(console, arguments);

};

log(1);    //1

log(1,2);    //1 2


接下来的要求是给每一个 log 消息添加一个"(app)"的前辍，比如：


log("hello world");    //(app)hello world


该怎么做比较优雅呢?这个时候需要想到arguments参数是个伪数组，通过 Array.prototype.slice.call 转化为标准数组，再使用数组方法unshift，像这样：

function log(){

  var args = Array.prototype.slice.call(arguments);

  args.unshift('(app)');



  console.log.apply(console, args);

};




   bind

说完了 apply 和 call ，再来说说bind。bind() 方法与 apply 和 call 很相似，也是可以改变函数体内 this 的指向。

MDN的解释是：bind()方法会创建一个新函数，称为绑定函数，当调用这个绑定函数时，绑定函数会以创建它时传入 bind()方法的第一个参数作为 this，传入 bind() 方法的第二个以及以后的参数加上绑定函数运行时本身的参数按照顺序作为原函数的参数来调用原函数。

直接来看看具体如何使用，在常见的单体模式中，通常我们会使用 _this , that , self 等保存 this ，这样我们可以在改变了上下文之后继续引用到它。 像这样：


var foo = {

    bar : 1,

    eventBind: function(){

        var _this = this;

        $('.someClass').on('click',function(event) {

            /* Act on the event */

            console.log(_this.bar);     //1

        });

    }

}


由于 Javascript 特有的机制，上下文环境在 eventBind:function(){ } 过渡到 $('.someClass').on('click',function(event) { }) 发生了改变，上述使用变量保存 this 这些方式都是有用的，也没有什么问题。当然使用 bind() 可以更加优雅的解决这个问题：

var foo = {

    bar : 1,

    eventBind: function(){

        $('.someClass').on('click',function(event) {

            /* Act on the event */

            console.log(this.bar);      //1

        }.bind(this));

    }

}


在上述代码里，bind() 创建了一个函数，当这个click事件绑定在被调用的时候，它的 this 关键词会被设置成被传入的值（这里指调用bind()时传入的参数）。因此，这里我们传入想要的上下文 this(其实就是 foo )，到 bind() 函数中。然后，当回调函数被执行的时候， this 便指向 foo 对象。再来一个简单的栗子：



var bar = function(){

console.log(this.x);

}

var foo = {

x:3

}

bar(); // undefined

var func = bar.bind(foo);

func(); // 3


这里我们创建了一个新的函数 func，当使用 bind() 创建一个绑定函数之后，它被执行的时候，它的 this 会被设置成 foo ， 而不是像我们调用 bar() 时的全局作用域。

有个有趣的问题，如果连续 bind() 两次，亦或者是连续 bind() 三次那么输出的值是什么呢？像这样：

var bar = function(){

    console.log(this.x);

}

var foo = {

    x:3

}

var sed = {

    x:4

}

var func = bar.bind(foo).bind(sed);

func(); //?



var fiv = {

    x:5

}

var func = bar.bind(foo).bind(sed).bind(fiv);

func(); //?


答案是，两次都仍将输出 3 ，而非期待中的 4 和 5 。原因是，在Javascript中，多次 bind() 是无效的。更深层次的原因， bind() 的实现，相当于使用函数在内部包了一个 call / apply ，第二次 bind() 相当于再包住第一次 bind() ,故第二次以后的 bind 是无法生效的。

　　

   apply、call、bind比较

那么 apply、call、bind 三者相比较，之间又有什么异同呢？何时使用 apply、call，何时使用 bind 呢。简单的一个栗子：

var obj = {

    x: 81,

};



var foo = {

    getX: function() {

        return this.x;

    }

}



console.log(foo.getX.bind(obj)());  //81

console.log(foo.getX.call(obj));    //81

console.log(foo.getX.apply(obj));   //81


三个输出的都是81，但是注意看使用 bind() 方法的，他后面多了对括号。

也就是说，区别是，当你希望改变上下文环境之后并非立即执行，而是回调执行的时候，使用 bind() 方法。而 apply/call 则会立即执行函数。



再总结一下：
•apply 、 call 、bind 三者都是用来改变函数的this对象的指向的；
•apply 、 call 、bind 三者第一个参数都是this要指向的对象，也就是想指定的上下文；
•apply 、 call 、bind 三者都可以利用后续参数传参；
•bind 是返回对应函数，便于稍后调用；apply 、call 则是立即调用 。



本文转自：http://www.cnblogs.com/coco1s/p/4833199.html