在 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;
    };
  };

问题二: 我不太明白这个函数的逻辑。需要帮助才能理解。一个例子应该很有帮助。

  // 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);
    });
  };

谢谢你的帮助。

最佳答案

Array 原型(prototype)上的“切片”函数期望 this 将引用它应该操作的数组。换句话说，如果你有一个真正的数组:

var myArray = [1, 2, 3];

然后调用 slice():

var sliced = myArray.slice(1);

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

myArray.slice(1)

与

myArray.slice.call(myArray, 1);

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

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

对 _.map() 的调用很复杂(事实上我认为它有点胡说八道)。它所做的是遍历列表，为列表中的每个值调用一个函数。该函数首先确定“方法”参数是否真的是一个函数。如果是，则它通过 .apply() 调用该函数，并将列表的元素作为上下文。如果“方法”不是函数，则它假定它是每个列表元素的属性名称，并且这些属性是函数。

例如，对于一个简单的列表，它非常简单:

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

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

对于更复杂的列表，我可以使用 _.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);
});

子表达式 方法 || value 将总是 返回“方法”的值，或者至少几乎总是会返回一些奇特的技巧。如果 method.call 为真，则对 method 的引用也必须为真。另外，如果是我的代码，我会检查 method outside _.map() 回调，这样决定就没有了一遍又一遍地制作。也许是这样的:

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

关于javascript - 尝试了解 underscore.js 源代码 - 在库中调用和应用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8870445/