Javascript中关于call,apply,bind这三个函数的用法

关于call,apply,bind这三个函数的用法，是学习javascript这门语言无法越过的知识点。下边我就来好好总结一下它们三者各自的用法，及常见的应用场景。

首先看call这个函数，可以理解成"借用“,"请求"。想像一下如下的情景：你孤单一人漂泊在外，有急事想往家里打电话，可是很不巧，手机欠费了，或者没电了，或者掉坑里了，总之你的手机就是用不成。可是你非打这个电话不可，于是你可以去借一下朋友的手机，或者借用一下邻居的手机，或者公用电话，这样呢，你就可以在自己没有手机可用的情况下，完成打电话这个事情，而至于你是用谁的电话打的，就不重要了，反正和用你自己的手机打的电话是一样的效果。call这个函数的初衷也和这个类似，下面我用代码来模拟一下它的应用情景：

    var frog = {
        name : 'frog',
        say  : function(){
            alert(this.name);
        }
    }

    var rabbit = {
        name : 'rabbit'
    }

    frog.say.call(rubbit) // rabbit

rubbit这个对象是个哑吧，但是他想要说出自己的名字，光凭它自己的能力，是不可能实现的，好在呢，它有一个叫frog的好基友，它可以说话。于是呢，rubbit就请求frog替它实现这个心愿。frog.say.call()的第一个参数，一定是要填写发出请求的人，律师喜欢称为委托人。这里是rubbit请求frog替它say名字，所以填写rubbit。这样一来，在say的时候，就会查找rubbit的name,而不是frog的name了。如果这里填写frog会是什么样子呢？这就好比是自己请求自己做某事，喂自己代盐也是可以的。可以试一下：

  var frog = {
        name : 'frog',
        say  : function(){
            alert(this.name);
        }
    }

    var rabbit = {
        name : 'rabbit'
    }

    frog.say.call(frog) // frog

自己喂自己袋盐，肯定是说自己的名字啦，这完全没有什么意外的。下面我们来看看call的经典用法：

//把参数转化成真正的数组对象
function frog(){
    var arr = [].slice.call(arguments);
    console.log(arguments.slice,arr.slice)
        //  undefined function slice() { [native code] }
}
    frog(1,2,3,4)

能过这么一call,我们就可以把arguments对象当成数组对象来使用了。关于call的用法很多,翻开jquery的源码，很容易就能找到很多运用的地方。在此不一一列举了，还是回到我们前面的情景，借电话这种事太简单了，打完电话，肯定还想捎点什么东西回去，毕竟这么多年漂泊在外，没有好好孝敬下老人，买点当地的特产回去，肯定是极好的。可是外边的生活压力是如此之大，每天除了上班还要加班，如果请假的话，不但工资要扣，还要花费不少的路费，这些钱加起来，估计都够老人在家里一年的用度了。想想不划算，于是又想到call这个函数，请它帮忙，顺道带回去是非常明智的选择，而且它不收费，不限量，不限重，有多少，带多少。我再次用代码来演示一下：

  var frog = {
        name : 'frog',
        send  : function(money,food,milk,suagate){
            alert(money+food+milk+suagate);
        }
    }

    var rabbit = {
        name : 'rabbit'
    }

    frog.send.call(rubbit,'money','food','milk','suagate')

如果你有钱任性，甚至可以把iphone6 plus什么的也寄几个回去。.^_^.

说到这里call就差不多结束了，我也不知道上面的情景剧，是不是让你明白了call是怎么回事，如果只是勾起了你的思乡之情，那我表示抱歉。

call还有一个同父异母的兄弟，叫apply,如果弄明白了call的用法，那么apply其实也是一回事，唯一的区别呢，就是apply不喜欢传东西的时候，一个东西打一个包，显得很麻烦不说，还不环保。于是他就提供一个装东西的大箱子，你把你要传的东西全放在它提供的箱子里就好了。这个大箱子，就是一个数组。上面的例子，用apply来做的话，就是这样子的：

var frog = {
        name : 'frog',
        send  : function(money,food,milk,suagate){
            alert(money+food+milk+suagate);
        }
    }

    var rabbit = {
        name : 'rabbit'
    }
　　　　　　　　　　　　　　　　//注意参数的区别
    frog.send.apply(rubbit,['money','food','milk','suagate'])

以上就是apply,call的前世今生了。可是万万没想到，apply和call的爸爸，前些年搞房地产发了财，在外边还有一个叫bind 的私生子。虽然比call和apply这两个哥哥晚出道几年，但是能力也不容小视。只不过，他的身份，在某些地方，是不承认的。比如IE6。下面我还是用代码来演示下他的本领：

    var name = 'rubbit';

    var frog = {
        name : 'frog',
        say : function(){
            setTimeout(function(money,milk){
                alert(this.name+money+milk)
            }.bind(this,'money','milk'),1)
        }
    }
    
    frog.say();

通过对比发现,bind可以直接连在function(){}后面用。相当于把call 和 apply 都省了，直接在函数后面指定委托人和要传递的参数。从传参的风格上来说，更像call一些。

关于bind ，我们再来看一段经典的用法：

var obj = {
    name : 'frog'
}

document.addEventListener('click',function(){

    alert(this.name); // frog

}.bind(obj),false);

 

总结一下，apply,call,bind,这三兄弟的相同点是：

 1. 第一个参数都是邦定作用域，即是在谁的地盘上做事。

 2. 都可以传递参数

不同点是：

  apply,call 兼容性更好，bind某些低版本的浏览器不支持。

  apply 传递的参数必须是用数组进行包装的，而 call 和 bind 则是将要传递的参数一一列出。

在讨论bind()方法之前我们先来看一道题目：

var altwrite = document.write;  
altwrite("hello");  
//1.以上代码有什么问题
//2.正确操作是怎样的
//3.bind()方法怎么实现

对于上面这道题目，答案并不是太难，主要考点就是this指向的问题，altwrite()函数改变this的指向global或window对象，导致执行时提示非法调用异常，正确的方案就是使用bind()方法：

altwrite.bind(document)("hello")  

当然也可以使用call()方法：

altwrite.call(document, "hello")  

本文的重点在于讨论第三个问题bind()方法的实现，在开始讨论bind()的实现之前，我们先来看看bind()方法的使用：

绑定函数

bind()最简单的用法是创建一个函数，使这个函数不论怎么调用都有同样的this值。常见的错误就像上面的例子一样，将方法从对象中拿出来，然后调用，并且希望this指向原来的对象。如果不做特殊处理，一般会丢失原来的对象。使用bind()方法能够很漂亮的解决这个问题：

this.num = 9;  
var mymodule = {  
  num: 81,
  getNum: function() { return this.num; }
};

module.getNum(); // 81

var getNum = module.getNum;  
getNum(); // 9, 因为在这个例子中，"this"指向全局对象

// 创建一个'this'绑定到module的函数
var boundGetNum = getNum.bind(module);  
boundGetNum(); // 81  

偏函数（Partial Functions）

Partial Functions也叫Partial Applications，这里截取一段关于偏函数的定义：

Partial application can be described as taking a function that accepts some number of arguments, binding values to one or more of those arguments, and returning a new function that only accepts the remaining, un-bound arguments.

这是一个很好的特性，使用bind()我们设定函数的预定义参数，然后调用的时候传入其他参数即可：

function list() {  
  return Array.prototype.slice.call(arguments);
}

var list1 = list(1, 2, 3); // [1, 2, 3]

// 预定义参数37
var leadingThirtysevenList = list.bind(undefined, 37);

var list2 = leadingThirtysevenList(); // [37]  
var list3 = leadingThirtysevenList(1, 2, 3); // [37, 1, 2, 3]  

和setTimeout一起使用

一般情况下setTimeout()的this指向window或global对象。当使用类的方法时需要this指向类实例，就可以使用bind()将this绑定到回调函数来管理实例。

function Bloomer() {  
  this.petalCount = Math.ceil(Math.random() * 12) + 1;
}

// 1秒后调用declare函数
Bloomer.prototype.bloom = function() {  
  window.setTimeout(this.declare.bind(this), 1000);
};

Bloomer.prototype.declare = function() {  
  console.log('我有 ' + this.petalCount + ' 朵花瓣!');
};

注意：对于事件处理函数和setInterval方法也可以使用上面的方法

绑定函数作为构造函数

绑定函数也适用于使用new操作符来构造目标函数的实例。当使用绑定函数来构造实例，注意：this会被忽略，但是传入的参数仍然可用。

function Point(x, y) {  
  this.x = x;
  this.y = y;
}

Point.prototype.toString = function() {  
  return this.x + ',' + this.y; 
};

var p = new Point(1, 2);  
p.toString(); // '1,2'


var emptyObj = {};  
var YAxisPoint = Point.bind(emptyObj, 0/*x*/);  
// 实现中的例子不支持,
// 原生bind支持:
var YAxisPoint = Point.bind(null, 0/*x*/);

var axisPoint = new YAxisPoint(5);  
axisPoint.toString(); // '0,5'

axisPoint instanceof Point; // true  
axisPoint instanceof YAxisPoint; // true  
new Point(17, 42) instanceof YAxisPoint; // true  

上面例子中Point和YAxisPoint共享原型，因此使用instanceof运算符判断时为true。

捷径

bind()也可以为需要特定this值的函数创造捷径。

例如要将一个类数组对象转换为真正的数组，可能的例子如下：

var slice = Array.prototype.slice;

// ...

slice.call(arguments);  

如果使用bind()的话，情况变得更简单：

var unboundSlice = Array.prototype.slice;  
var slice = Function.prototype.call.bind(unboundSlice);

// ...

slice(arguments);  

实现

上面的几个小节可以看出bind()有很多的使用场景，但是bind()函数是在 ECMA-262 第五版才被加入；它可能无法在所有浏览器上运行。这就需要我们自己实现bind()函数了。

首先我们可以通过给目标函数指定作用域来简单实现bind()方法：

Function.prototype.bind = function(context){  
  self = this;  //保存this，即调用bind方法的目标函数
  return function(){
      return self.apply(context,arguments);
  };
};

考虑到函数柯里化的情况，我们可以构建一个更加健壮的bind()：

Function.prototype.bind = function(context){  
  var args = Array.prototype.slice.call(arguments, 1),
  self = this;
  return function(){
      var innerArgs = Array.prototype.slice.call(arguments);
      var finalArgs = args.concat(innerArgs);
      return self.apply(context,finalArgs);
  };
};

这次的bind()方法可以绑定对象，也支持在绑定的时候传参。

继续，Javascript的函数还可以作为构造函数，那么绑定后的函数用这种方式调用时，情况就比较微妙了，需要涉及到原型链的传递：

Function.prototype.bind = function(context){  
  var args = Array.prototype.slice(arguments, 1),
  F = function(){},
  self = this,
  bound = function(){
      var innerArgs = Array.prototype.slice.call(arguments);
      var finalArgs = args.concat(innerArgs);
      return self.apply((this instanceof F ? this : context), finalArgs);
  };

  F.prototype = self.prototype;
  bound.prototype = new F();
  return bound;
};

这是《JavaScript Web Application》一书中对bind()的实现：通过设置一个中转构造函数F，使绑定后的函数与调用bind()的函数处于同一原型链上，用new操作符调用绑定后的函数，返回的对象也能正常使用instanceof，因此这是最严谨的bind()实现。

对于为了在浏览器中能支持bind()函数，只需要对上述函数稍微修改即可：

Function.prototype.bind = function (oThis) {  
    if (typeof this !== "function") {
      throw new TypeError("Function.prototype.bind - what is trying to be bound is not callable");
    }

    var aArgs = Array.prototype.slice.call(arguments, 1), 
        fToBind = this, 
        fNOP = function () {},
        fBound = function () {
          return fToBind.apply(
              this instanceof fNOP && oThis ? this : oThis || window,
              aArgs.concat(Array.prototype.slice.call(arguments))
          );
        };

    fNOP.prototype = this.prototype;
    fBound.prototype = new fNOP();

    return fBound;
  };

if (!Function.prototype.bind) {

    /**
     * 返回一个新函数，这个函数执行时 @this 始终为指定的 @scope。
     * @param {Object} scope 要绑定的 @this 的值。
     * @returns {Function} 返回一个新函数。
     * @example (function(){ return this;  }).bind(0)() // 0
     * @since ES5
     */
    Function.prototype.bind = function (scope) {
        var me = this;
        return function () {
            return me.apply(scope, arguments);
        }
    };
}