将参数传递给filter（）

Question

I have a function that takes an array and then a number of arguments. In that function I want to use the filter() method on the array, but I want to use arguments[i]. As an example:

function destroyer(arr) {
  var test = arr.filter(function(value){
    return value != arguments[1];
  });
  return test;
}

console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3));

Calling arguments[1] there doesn't give me what I want, because I'm guessing the anonymous function has its own arguments that filter() is using. One solution I thought of was creating an array and copying the arguments to that. But I was wondering if there was a way to pass the arguments to filter? I know filter has a thisArg value, but I'm not sure how to use that to get what I want.

Edit: I have tried googling for a solution, and most of the solutions involve using bind or apply. However, I couldn't find anything directly related to filter() or similar methods like forEach, reduce, map, etc. I've tried using "this" as the thisArg value, but that doesn't seem to do anything. I've tried using bind and apply with it, but I can't seem to get the correct syntax for it.

Answer 1

If you have access to an ES6 environment, you can use "spread parameters" ( ... ) to represent your variable-length argument list. Along with arrow functions, and Array#includes , your code could be quite compact:

function destroyer(arr, ...destroy) {
  return arr.filter(value => !destroy.includes(value));
}

I have a working solution (with copying the arguments to an array), but I'm more interested in trying to figure how to pass the arguments to filter() to better understand how filter() and other similar methods work.

You don't need to pass the arguments to filter() . The arguments can simply be made available in the scope of the filter callback. However, arguments is special; it refers to the arguments of the current function. There is no way to refer to the arguments of some other function, such as the outer function. Therefore, there is no alternative but to save the arguments under a different variable name (such as args ) in the outer function; then you can refer to that variable from within the callback, because the callback "closes" over that variable.

If you're really intent on "passing" the list of numbers to be destroyed to the inner function, instead of just letting it access them by referring to a variable created in the outer scope, then yes, in theory you could use thisArg :

function destroyer(arr/*, number to destroy*/) {
  return arr.filter(do_not_destroy, arguments);
                                    ^^^^^^^^^ PASS thisArg
}

Now we can define do_not_destroy as

function do_not_destroy(elt) {
  return [].slice.call(this, 1).indexOf(elt) === -1;
                       ^^^^ REFER TO thisArg (arguments)
}

Note two things here. First, we refer to the list of arguments as this , because we passed them to filter using thisArg . Second, we cannot write this.slice... , and instead must write [].slice.call(this... , because this is an arguments object, which is not a "real" array and does not have the slice method.

To make do_not_destroy independent of the fact that its parameter is a special arguments object, with an extra parameter (the array) at the beginning, we could do the conversion to an array within the destroyer function:

function destroyer(arr/*, number to destroy*/) {
  return arr.filter(do_not_destroy, [].slice.call(arguments, 1));
}

Now we can define do_not_destroy as

function do_not_destroy(elt) {
  return this.indexOf(elt) === -1;
}

But now we are basically back to where we started. Instead of "passing" the list of values to be omitted by merely letting the inner function (callback) refer to a variable set in the outer scope, we are passing them to the callback using the back-door thisArg mechanism. I don't really see the point in this.