filter and includes in array, how does that work?

I think the key to understanding what is going on is the parameter(s) of the function, num. The code uses a nice trick that I have not encountered before. So, num is:

[[1, 2, 3, 4], 3];

a 1D array with TWO elements: [1, 2, 3, 4] at index 0, and 3 at index 1. As a result:

num.includes([1, 2, 3, 4]) // is true
num.includes(3) // is true
num.includes(anything-else) // is false

The Array#includes method determines whether an array includes a certain value among its entries, returning true or false as appropriate.

In the simplest form, whenever a boolean expression is prefixed with !, the result of the expression is negated. For example:

!num.includes(3) // becomes false

The Array#filter method creates a new array with all elements that pass the test implemented by the provided function.

Pass the test simply means return true.

Now we are ready to look at num[0].filter(val => !num.includes(val)). Or:

[1, 2, 3, 4].filter(val => !num.includes(val))

Please recall that ONLY 3 and [1, 2, 3, 4] return true to:

num.includes(val)

Hence of all the elements of num[0] or [1, 2, 3, 4] only 3 returns false to the negated expression:

!num.includes(val)

1, 2, and 4 return true or !false, meaning that they pass the test and hence will be returned by the function:

[1, 2, 4];

Please note that val => !num.includes(val) is a shorthand way of writing:

function( val ) {
    return !num.includes(val);
}

const removeFromArray = function(...num) {
    let array = num[0];
    return array.filter(val => !num.includes(val))
};

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

Rest parameters shouldn't be used like that, it should only be used for like values. So, the array should be accepted separately and only the numbers to remove should be accepted using rest (refer to the snippet below).

The includes() method determines whether an array includes a certain value among its entries, returning true or false as appropriate.

So, we simply filter out numbers that are not present in the itemsToRemove array.

const removeFromArray = (array, ...itemsToRemove) =>
  array.filter((item) => !itemsToRemove.includes(item));

removeFromArray([1, 2, 3, 4], 3, 2);

! means "not". If something is falsy (null, 0, false, an empty string), then !something returns true. This leads to a really strange looking "cheat code" where you can convert any value to a boolean (i.e. truthy to true and falsy to false) via !!value. One exclamation point converts it to a boolean value that's true if value is falsy, then the second exclamation point changes true to false (or false to true)!

array.prototype.filter requires a function to be evaluated against each element and returns an array of only the elements where the supplied function returns a truthy value.

It might be easier to think of the following code that is nearly equivalent to yours...

const removeFromArray = function(array, ...valsToRemove) {

  const isValToKeep = val => array.includes(val) === false;
  
  return array.filter(isValToKeep)
};

The only difference in this code, besides being longer, is that the first argument won't be looked for within the first argument. Consider

const a1 = [1,2,3];
a1.push(a1); // appends itself as its last element

In your version, removeFromArray(a1, 2) would return [1, 3], but mine doesn't combine the first argument as one of the elements to look for and remove from the first argument, which is probably what most people would expect and be more performant, but would definitely have a different effect in the example returning [1, 3, a1], i.e. [1, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [1, 2, 3, [...]]]]]]]]

This is a simple form to explain how to use filter

function isBigEnough(value) {
  return value >= 10;
}

var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);

// result is [12, 130, 44]

This example is from: https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

Lets start by rewriting this line:

Before

return array.filter(val => !num.includes(val))

after

const callback = val => {
return !num.includes(val)
}

const filteredArray = array.filter(callback);
return filteredArray

Now lets break and explain parts of this statement:

1. ! num.includes(val)

includes method here will check if num has val in it. If num has val it will return true else it will return false. note the ! at the begining of the line ,that will change the value returned by includes to its opposite e.g if value returned is false it will change it to true if value returned is true it will change it to false.

2. array.filter(callback)

The filter method here will go through every element of the array and at each element it will ask whether to add that element to the filteredArray or not based on what is returned from the callback. If callback returns true(truthy) it will add it else it will not add it. The callback should only return true(truthy) or false(falsy).

example : At index 0 of array the filter will ask did callback return true if it returned true the element at index 0 will be added to the filtered array. It will do the same for the rest of the elements.

How they work together:

array has [1,2,3,4] so array.filter(callback) will go over each element and call callback on each. Based on your function num has this [[1,2,3,4],3] so when val from array is 3 !num.includes(val) will return true but this ! will change it to false as a result callback will return false and 3 will not be included in the final array the filteredArray.

Hope a 5 year old can understand this explantion. You can now rewrite your function like this :

const removeFromArray = (array, ...numbersToRemove) => array.filter((number) => !numsToRemove.includes(number));