Is there any way to send more arguments to `.call()` in this context?

Question

Given the following code:

/*jslint white:true, devel:true*/
var foo = function () {
  'use strict';
  console.log(
    Array.prototype.slice.call(
      /* How can I send more arguments to call after 'arguments'? */
      arguments,
      /*
       This function gets sent to slice.
       If I sent a '2' it would start the array at the third index.
       */
      function () {
        console.log("bar");
      }
    )
  );
};

foo(1, 2, 3, 4, 5, 6);

I am trying to better understand how the parameters work in this context. It seems that the second parameter is always sent to slice.

Is there any way to send another parameter to call in this context? Or would I need to rewrite the code to .slice() separately from the .call()?

UPDATE:

I am not really sure why this was down-voted. My conceptual misunderstanding was that .slice was taking over, rather than being passed all arguments through .call(). Thanks to Quentin for clarifying it.

What chained methods? You have no chained methods in that code. — Quentin, Apr 02 '16 at 20:41
@Quentin, what about `.slice.call(`? What would you consider that? — ryanpcmcquen, Apr 02 '16 at 20:42
A perfectly ordinary method. It would be a chained method if the return value of `call()` was `slice` so you could say `slice.call().foo().bar()` and have the same effect as `slice.call(); slice.foo(); slice.bar();` — Quentin, Apr 02 '16 at 20:43
This would be helpful for you. http://stackoverflow.com/a/36018463/1209018 — Rajaprabhu Aravindasamy, Apr 02 '16 at 20:44
@RajaprabhuAravindasamy — That doesn't tell me anything I don't know already. It also doesn't use the word "chained". — Quentin, Apr 02 '16 at 20:45
I suspect the question you are trying to ask is "What does the `call` method do and what arguments does it take?" — Quentin, Apr 02 '16 at 20:46
@Quentin I am aware of what `.call()` does from the MDN page, I am trying to better understand the nuance here when used with `.slice()` ... — ryanpcmcquen, Apr 02 '16 at 20:47
@Quentin I know you that you are aware of it. Just sharing that link with OP. :) — Rajaprabhu Aravindasamy, Apr 02 '16 at 20:49
You can send as many arguments into `call` as you want. Judging from your comment about the function and sending a `2`, you already seem to know how they work? — Bergi, Apr 02 '16 at 20:54
@RajaprabhuAravindasamy thanks for the link but that did not help. Quentin's answer clarified it though. — ryanpcmcquen, Apr 02 '16 at 23:49

Quentin · Accepted Answer · 2016-04-02T21:22:02.833

It seems that the second parameter is always sent to slice.

The first argument to call is the value of this that slice should work on. i.e. It acts like arguments.slice(...) if arguments were an array instead of an array-like object that didn't have a slice method of its own.

The second argument to call is the first argument to slice. i.e. the offset in the array to start slicing from. It doesn't make sense to pass a function as you do in the question.

Is there any way to send another parameter to call in this context?

Yes. Just do it.

The third argument to call is the second argument to slice. i.e. the index to stop slicing at.

The fourth argument to call is the third argument to slice, but slice only takes two arguments so it wouldn't make sense to pass any more.

It finally makes sense. Thanks for answering this down-voted question. I still learned something here despite losing some Stack Overflow points. — ryanpcmcquen, Apr 02 '16 at 22:13

Is there any way to send more arguments to `.call()` in this context?

1 Answers1