8

So far I tried this but it returns unfiltered array:

function filterRangeInPlace(array, min, max) {
  array = array.filter(item => (item >= min && item <= max));
  console.log(array);
}

let arr = [5, 3, 8, 1];

filterRangeInPlace(arr, 1, 4);

console.log(arr);
adiga
  • 34,372
  • 9
  • 61
  • 83
Robert Hovhannisyan
  • 2,938
  • 6
  • 21
  • 43
  • 1
    `.filter()` *always* creates a new array. Your code doesn't work because the assignment to `array` in the function is an assignment to the parameter and JavaScript is a pass-by-value language. – Pointy Aug 21 '19 at 19:01
  • To actually achieve what the question title requests you'd have to write a function to "smush" the array in place to get rid of filtered-out entries. – Pointy Aug 21 '19 at 19:03
  • 1
    [Pass Variables by Reference in Javascript](https://stackoverflow.com/a/26610095/3082296) – adiga Aug 21 '19 at 19:04
  • The function `.filter()` is doesn't like a `for` loop, This function actually apply the filter on array entities and return a new filtered array, It doesn't make changes on a actual array like `for` loop, So when you need to filter any array then you must need to take a variable which holds filtered array result or just use `for` loop and remove unsatisfied entries from the array which affects on original array elements – Neel Rathod Aug 21 '19 at 19:22

4 Answers4

9

If it's actually important to do the filtering in-place without creating another array, you have to go sort-of old school and iterate through the array with two indexes, copying values along the way. Every time you hit an element that fails the filter test, you increment one of the indexes but not the other one. At the end of that, you reset the array .length to the trailing index:

function filterInPlace(array, fn) {
  let from = 0, to = 0;
  while (from < array.length) {
    if (fn(array[from])) {
      array[to] = array[from];
      to++;
    }
    from++;
  }
  array.length = to;
}

This has the advantage of being O(n), with just one pass over the array, while the solutions involving .splice() are O(n2).

To do your "range check", you could write another function to create a filter predicate given a minimum and a maximum value:

function rangePredicate(min, max) {
  return n => n >= min && n <= max;
}

Then you can pass the return value of that to the filter function:

var arr = [1, 2, 3, ... ];
filterInPlace(arr, rangePredicate(0, 10));
Pointy
  • 405,095
  • 59
  • 585
  • 614
4

You need to return the new filtered array and assign it to a variable (such as arr itself):

function filterRangeInPlace(array, min, max){
  return array.filter(item => (item >= min && item <= max));
}

let arr = [5, 3, 8, 1];

arr = filterRangeInPlace(arr, 1, 4);

console.log(arr);
DjaouadNM
  • 22,013
  • 4
  • 33
  • 55
3

Return the value and set it equal to itself. 

function filterRangeInPlace(array, min, max) {
  return array.filter(item => (item >= min && item <= max));
}

let arr = [5, 3, 8, 1];

arr = filterRangeInPlace(arr, 1, 4);

console.log(arr);

Or you could of course omit the function entirely with:

let arr = [5, 3, 8, 1];

arr = arr.filter(item => (item >= min && item <= max));

console.log(arr);
Jbluehdorn
  • 475
  • 2
  • 11
3

You can't use .filter() for this, since it returns a new array rather than modifying the original array. You can loop over the array yourself, removing elements that don't match the condition.

You need to do the loop in descending order of index, because removing an element shifts the indexes of all the remaining elements down and you'll end up skipping the next element if you do it in increasing order. This also means you can't use a built-in function like .forEach().

function filterRangeInPlace(array, min, max) {
  for (let i = array.length-1; i >= 0; i--) {
    if (array[i] < min || array[i] > max) {
      array.splice(i, 1);
    }
  }
}

let arr = [5, 3, 8, 1];
filterRangeInPlace(arr, 1, 4);
console.log(arr);
Barmar
  • 741,623
  • 53
  • 500
  • 612