Question

在Jeremy Ashkenas的令人敬畏的Underscore.js库中，我试图了解源文件的一个方面。我不明白这一点：

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

那样：

args = Array.prototype.slice.call(arguments, 2);

.call或.apply是函数的方法。但是在这里，.call指的是哪些函数？第一个参数应该是上下文，但arguments是上下文？第二个参数应该是传递函数的参数。这里是数字2。这是什么意思？有时在库中，它使用1或0。它们是传递函数的参数的数量吗？

_.bind = function bind(func, context) {
    var bound, args;
    if (func.bind === nativeBind && nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));
    if (!_.isFunction(func)) throw new TypeError;
    args = slice.call(arguments, 2);
    return bound = function() {
      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));
      ctor.prototype = func.prototype;
      var self = new ctor;
      var result = func.apply(self, args.concat(slice.call(arguments)));
      if (Object(result) === result) return result;
      return self;
    };
  };

问题2：我不太明白这个功能的逻辑。需要帮助才能理解。一个例子应该非常有用。

  // Invoke a method (with arguments) on every item in a collection.
  _.invoke = function(obj, method) {
    var args = slice.call(arguments, 2);
    return _.map(obj, function(value) {
      return (method.call ? method || value : value[method]).apply(value, args);
    });
  };

感谢您的帮助。

Answer 1

Array原型上的“slice”函数期望this将引用它应该运行的数组。换句话说，如果你有一个真正的数组：

var myArray = [1, 2, 3];

并致电slice()：

var sliced = myArray.slice(1);

然后在对slice()的调用中，this引用数组“myArray”。正如雷诺斯在评论中指出的那样：

myArray.slice(1)

与

相同

myArray.slice.call(myArray, 1);

因此，当您使用call()调用该函数并将其作为上下文对象传递arguments时，slice()代码将在arguments上运行。通过.call()传递的其他参数只是slice()本身的参数或参数。在上面的示例中，请注意我将1传递给函数。

现在关于你的第二个问题，.invoke()函数首先隔离前两个后传入的参数。这意味着当你使用_.invoke()时，你传递两个或更多参数：第一个是要操作的列表，第二个是方法，并且（可选的）后续参数被传递到列表中每个元素的方法。

对_.map()的调用很复杂（实际上我觉得它有点废话）。它正在做的是迭代列表，为列表中的每个值调用一个函数。该函数的作用是首先确定“method”参数是否真的是一个函数。如果是，则它通过.apply()调用该函数，并将列表元素作为上下文。如果“method”不是一个函数，那么它假定它是每个列表元素的属性名称，并且属性是函数。

例如，通过一个简单的列表，它非常简单：

var myList = [1, 2, 3];
var result = _.invoke(myList, function(n) { return this * n; }, 2);

这将给出结果[2, 4, 6]，因为我传递的函数将其上下文对象（this）乘以传递的参数，并且在调用_.invoke()时传递了2。

使用更复杂的列表，我可以使用_.invoke()的第二种风格，并在列表中的每个对象上调用一个方法：

var getName = function(prefix) { return prefix + " " + this.name; };
var list = [
  { name: "Bob", getName: getName },
  { name: "Sam", getName: getName },
  { name: "Lou", getName: getName }
];

var result = _.invoke(list, "getName", "Congressman");

这将在列表中的每个对象上调用“getName”函数，并返回从结果中生成的列表。效果将是列表["Congressman Bob", "Congressman Sam", "Congressman Lou"]。

现在谈论那个废话。在_.invoke()的代码中：

return _.map(obj, function(value) {
  return (method.call ? method || value : value[method]).apply(value, args);
});

subexpresion method || value将始终返回“method”的值，或者至少几乎总是禁止一些奇特的技巧。如果method.call是真实的，那么对method的引用也必须是真实的。另外，如果是我的代码，我会在method回调之外检查_.map() ，以便不必一次又一次地做出决定。也许是这样的：

return _.map(obj, method.call ? function(value) { method.apply(value, args); } : function(value) { value[method].apply(value, args); } );

试图理解underscore.js源代码 - 调用和应用于库中

1 个答案: