Javascript 试图理解subline.js源代码-库中使用的调用和应用

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

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

以便：

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

.call

或

.apply

是函数的方法。但是在这里，

.call

指的是哪些函数？第一个参数应该是上下文，但是

参数

是上下文吗？第二个参数应该是要在函数中传递的参数。这里是编号

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

感谢您的帮助。

阵列原型上的“切片”功能希望

此

将引用它应该在其上运行的阵列。换句话说，如果您有一个实数组：

var myArray = [1, 2, 3];

然后调用

slice（）

：

然后在对

slice（）

的调用中，

这个

引用数组“myArray”。正如Raynos在评论中指出的：

myArray.slice(1)

与

myArray.slice.call(myArray, 1);

因此，当您使用

call（）

调用函数，并将其作为上下文对象传递

arguments

时，

slice（）

代码对

arguments

进行操作。通过

.call（）

传递的其他参数只是

slice（）

本身的一个或多个参数。在上面的示例中，请注意，我向函数传递了1

现在，关于第二个问题，

.invoke（）

函数首先隔离前两个之后传入的参数。这意味着，当您使用

\uuuu.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”函数，并返回由结果生成的列表。效果将是列表

[“国会议员鲍勃”、“国会议员萨姆”、“国会议员卢”]

现在说说那些废话。在

的代码中。invoke（）

：

子表达式

method | | value

将始终返回“method”的值，或者至少几乎总是禁止某些特殊技巧。如果

method.call

是truthy，那么对

method

的引用也必须是truthy。另外，如果它是我的代码，我会在

\uu.map（）

回调之外检查

方法，这样就不必反复做出决定。可能是这样的：

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

myArray.slice（1）==slice.call（myArray，1）
@Raynos，它实际上是假的<代码>切片

创建两个不同的数组对象，它们不完全相同。@katspaugh我不确定我是否理解你的意思。哦，等等。。。您的意思是对

slice（）

的两个单独调用会创建两个不同的数组吗？是的，这当然是真的，但我不认为这就是雷诺斯的意思（尽管使用了

===

），他的意思是它具有相同的净效应。那么他可能不应该用代码来表达非正式的平等。@katspaugh你不应该从字面上理解它。这是一个上下文相关的语句，不是代码，

==

表示这些语句具有相同的效果

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

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