CODEWITHSUNDEEP
javascriptarraysalgorithmfilteriteration
Mehmet Eyüpoğlu
Mehmet Eyüpoğlu

Reputation: 169

Iterating inside JavaScript filter method

I am trying to compare two given parameters of a function. The exact problem is as follows:

You will be provided with an initial array (the first argument in the destroyer function), followed by one or more arguments. Remove all elements from the initial array that are of the same value as these arguments.

Note You have to use the arguments object.

console.log(destroyer([1, 2, 3, 1, 2, 3], 2, 3)); // expected output: [1,1]

I am using filter method to iterate over the array but I couldn't compare the args with the elements of the array inside the callback of the filter. 

    function destroyer(arr, ...args) {

    let result = arr.filter(num => {

        for (let i = 0; i<=args.length; i++ ){
             num !== args[i]
        }

    }); 
    return result; 

    }


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

I can iterate with for loop but I cannot use the output of for loop to do filter iteration.

Any ideas?

Upvotes: 0

Views: 1027

Answers (2)

Jacob Tobiasz
Jacob Tobiasz

Reputation: 458

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

Example:

const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

via MDN

Filter iterates over all elements of some array and returns a new array. It puts an element in the new array only if callback (your function invoked as a parameter of filter) return true otherwise it's omitted.

Next it's worth to use rest parameters to achieve two arrays (initial and values to exclude).

The rest parameter syntax allows us to represent an indefinite number of arguments as an array.

function sum(...theArgs) {
  return theArgs.reduce((previous, current) => {
    return previous + current;
  });
}

console.log(sum(1, 2, 3));
// expected output: 6

console.log(sum(1, 2, 3, 4));
// expected output: 10

Solution with explanation:

//Declare your function, first parameter is initial array, the second one is also array created by using rest parameters
function destroyer(initialArray = [], ...toExclude) {
    // filter initialArray, if el (single element) is NOT included in "toExclude" it returns true
    // and add this particular element to the result array
    let result = initialArray.filter(el => toExclude.includes(el) == false);

    //return result
    return result;
}

Upvotes: 0

norbitrial
norbitrial

Reputation: 15166

Probably an easier way to achieve the goal using .filter() with .includes(). Additionally you can use ...rest so called rest parameters for you function, see form the documentation:

The rest parameter syntax allows us to represent an indefinite number of arguments as an array.

Try as the following:

const destroyer = (arr, ...rest) => {
  return arr.filter(num => !rest.includes(num));
}

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

I hope this helps!

Upvotes: 1

Related Questions