apply()和call()和bind()

一、方法定义

call, apply都属于Function.prototype的一个方法,它是JavaScript引擎内在实现的,由于属于Function.prototype,因此每一个Function对象实例,也就是每一个方法都有call, apply属性.既然做为方法的属性,那它们的使用就固然是针对方法的了.这两个方法是容易混淆的,由于它们的做用同样,只是使用方式不一样.

call方法: 
语法：call([thisObj[,arg1[, arg2[,   [,.argN]]]]]) 
定义：调用一个对象的一个方法，以另外一个对象替换当前对象。 
说明： 
call 方法能够用来代替另外一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。 
若是没有提供 thisObj 参数，那么 Global 对象被用做 thisObj。 

apply方法： 
语法：apply([thisObj[,argArray]]) 
定义：应用某一对象的一个方法，用另外一个对象替换当前对象。 
说明： 
若是 argArray 不是一个有效的数组或者不是 arguments 对象，那么将致使一个 TypeError。 
若是没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用做 thisObj， 而且没法被传递任何参数

call, apply做用就是借用别人的方法来调用,就像调用本身的同样.

它们的不一样之处：

• apply：最多只能有两个参数——新this对象和一个数组 argArray。若是给该方法传递多个参数，则把参数都写进这个数组里面，固然，即便只有一个参数，也要写进数组里面。若是 argArray 不是一个有效的数组或者不是 arguments 对象，那么将致使一个 TypeError。若是没有提供 argArray 和 thisObj 任何一个参数，那么 Global 对象将被用做 thisObj， 而且没法被传递任何参数。
• call：则是直接的参数列表，主要用在js对象各方法互相调用的时候，使当前this实例指针保持一致,或在特殊状况下须要改变this指针。若是没有提供 thisObj 参数，那么 Global 对象被用做 thisObj。 
• 更简单地说，apply和call功能同样，只是传入的参数列表形式不一样：如 func.call(func1,var1,var2,var3)对应的apply写法为：func.apply(func1,[var1,var2,var3])
• 如：
  add.apply(sub,[3,1]);
  //add.call(sub,3,1);

var a={
n:1,
m:2,
add:function(){
return this.n+this.m;
}
}
var b={n:3,m:4

}
console.log(a.add.call(b));//b.n+b.m=7

function Animal(){
this.name = "Animal";
this.showName = function(){
alert(this.name);
}
}

function Cat(){
this.name = "Cat";
}

var animal = new Animal();
var cat = new Cat();

//经过call或apply方法，将本来属于Animal对象的showName()方法交给对象cat来使用了。
//输入结果为"Cat"
animal.showName.call(cat,",");
animal.showName.apply(cat,[]);

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

一、数组之间追加

1 2 3 4

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] */

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

1 2 3

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 使用其方法。

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

1 2 3

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

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

1	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 方法，常见的解决方法是：

1 2 3 4 5

function  log(msg)　{    console.log(msg); } log(1);     //1 log(1,2);     //1

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

1 2 3 4 5

function  log(){    console.log.apply(console, arguments); }; log(1);     //1 log(1,2);     //1 2

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

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

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

1 2 3 4 5 6

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 ，这样咱们能够在改变了上下文以后继续引用到它。 像这样：

1 2 3 4 5 6 7 8 9 10

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() 能够更加优雅的解决这个问题：

1 2 3 4 5 6 7 8 9

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 对象。再来一个简单的栗子：

1 2 3 4 5 6 7 8 9

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() 三次那么输出的值是什么呢？像这样：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

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 是没法生效的。