Help me understand Seek and Destroy

[Dbuckholz]

Tell us what’s happening:

the code works, but I cant wrap my head around what
“var args = Array.prototype.slice.call(arguments).slice(1)” is doing. can someone help explain this?

Your code so far

function destroyer(arr) {
  // Remove all the values
  var args = Array.prototype.slice.call(arguments).slice(1);
  for (i = 0; i < arr.length; i++){
    for(j = 0; j < args.length; j++){
      if(arr[i] === args[j]){
        delete arr[i];
      }
    }
  }
  
  return arr.filter(Boolean);
}

destroyer([1, 2, 3, 1, 2, 3], 2, 3);

Your browser information:

Your Browser User Agent is: Mozilla/5.0 (X11; CrOS x86_64 10323.58.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/65.0.3325.167 Safari/537.36.

Link to the challenge:
https://www.freecodecamp.org/challenges/seek-and-destroy

[Dbuckholz]

Looking at the solutions, the “.slice(1)” isnt needed. which is even more confusing.

[RandellDawson]

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

The above line creates an array out of the arguments object which contains all the arguments passed to the function. The array reference is then assigned to the variable args.

[Dbuckholz]

what about slice.call?

[RandellDawson]

You already know what slice does, but for call, take a look at the documentation.

.

[IsaacAbrahamson]

@Dbuckholz

what about slice.call?

You may find this SO question to be beneficial:

how does Array.prototype.slice.call() work?

Copying from the second answer:

The arguments object is not actually an instance of an Array, and does not have any of the Array methods. So, arguments.slice(...) will not work because the arguments object does not have the slice method.

Arrays do have this method, and because the arguments object is very similar to an array, the two are compatible. This means that we can use array methods with the arguments object. And since array methods were built with arrays in mind, they will return arrays rather than other argument objects.

So why use Array.prototype? The Array is the object which we create new arrays from (new Array()), and these new arrays are passed methods and properties, like slice. These methods are stored in the [Class].prototype object. So, for efficiency sake, instead of accessing the slice method by (new Array()).slice.call() or [].slice.call(), we just get it straight from the prototype. This is so we don’t have to initialize a new array.

But why do we have to do this in the first place? Well, as you said, it converts an arguments object into an Array instance. The reason why we use slice, however, is more of a “hack” than anything. The slice method will take a, you guessed it, slice of an array and return that slice as a new array. Passing no arguments to it (besides the arguments object as its context) causes the slice method to take a complete chunk of the passed “array” (in this case, the arguments object) and return it as a new array.

Let me try to simplify: arguments is not an array. Slice() is an array method. To use Slice() on the arguments object we must take the arguments and pass them into the slice array method using call.

Since the call to slice returns an array, there is no need to call slice a second time.