使用 Bind 强调行为

Question

阅读来源： http://documentcloud.github.com/underscore/underscore.js

这是经常使用的 _bind 方法（为了清楚起见，我已经删除了本机检查）

   _.bind = function(func, obj) {
    var args = slice.call(arguments, 2);
    return function() {
      return func.apply(obj, args.concat(slice.call(arguments)));
    };
  };

传递给 func.apply 的参数在最后似乎不必要地重复

使用 Node 解释器的示例（删除最后一行以在 Firebug 等中尝试。）

var arguments = [1,2,3,4,5,6];
var args = Array.prototype.slice.call(arguments, 2);
var appliedArgs = args.concat(Array.prototype.slice.call(arguments));
require('sys').puts(appliedArgs);

此输出：

3,4,5,6,1,2,3,4,5,6

我非常怀疑我已经发现了一个错误，但很困惑为什么它会这样工作，为什么要以这种方式再次附加参数。使困惑

Answer 1

bind 方法返回一个闭包，它可以接受传递给函数的附加参数。下划线代码中对arguments 的两次引用并不引用同一组参数。第一个来自封闭函数，第二个来自返回的闭包。下面是这个方法的一个稍微修改过的版本，希望它能更清楚地说明这一点：

_.bind = function(func, obj /*, arg1, arg2 ... argN */) {

  // Prepare default arguments for currying, removing
  // the function and object references
  var args = Array.prototype.slice.call(arguments, 2);

  // Return a closure that has access to the parent scope
  return function(/* arg1, arg2 ... argN */) {

    // Prepare arguments that are passed when bound
    // method is called
    var args2 = Array.prototype.slice.call(arguments);

    // Curry the method with the arguments passed
    // to the enclosing function and those passed
    // to the bound method
    return func.apply(obj, args.concat(args2));

  }

这本质上允许您在绑定到对象时柯里化一个方法。其用法的一个例子是：

var myObj = {},
    myFunc = function() {
      return Array.prototype.slice.call(arguments);
    };

myObj.newFunc = _.bind(myFunc, myObj, 1, 2, 3);

>>> myObj.newFunc(4, 5, 6);
[1, 2, 3, 4, 5, 6]

Answer 2

对 _bind 的调用将对象和一些参数绑定到方法。调用绑定方法时，您可以将其他参数传递给它。您不太可能两次传递相同的参数。用法是：

function sum() {
    var total = 0;
    for (var i=0; i < arguments.length; ++i) {
        total += arguments[i];
    }
    return total;
}
var sumsome = _bind(sum, {}, 1, 2, 3);
sumsome(4,5,6); // equivalent to the call ({summ: sum}).summ(1,2,3,4,5,6)
sumsome('a','b','c'); // equivalent to the call ({summ: sum}).summ(1,2,3,'a','b','c')