试图理解下划线.js源 - 调用和应用在库中使用的

Trying to understand underscore.js source - call and apply used in library

本文关键字：应用 调用 下划线 js      更新时间：2023-09-26

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

谢谢你的帮助。

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

var myArray = [1, 2, 3];

你打电话给slice()：

var sliced = myArray.slice(1);

然后在对slice()的调用中，this引用数组"myArray"。正如Raynos在评论中指出的那样：

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

这种子探索method || value总是返回"方法"的值，或者至少几乎总是排除一些奇特的技巧。 如果method.call是真实的，那么对method的引用也必须是真实的。此外，如果这是我的代码，我会检查_.map()回调之外的method，这样就不必一遍又一遍地做出决定。也许像这样：

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