You should only add to the result array in the if condition, not else. Use j as the index in the result, don't add or subtract it.

function removeAt(arr, index) {
  var j = 0;
  var arr2 = [];
  for (var i = 0; i < arr.length; i++) {
    if (i != index) {
      arr2[j] = arr[i];
      j++;
    }
  }
  return arr2
}

console.log(removeAt([1, 2, 3, 4, 5], 3))

Find the index of the array element you want to remove using indexOf, and then remove that index with splice.

The splice() method changes the contents of an array by removing existing elements and/or adding new elements.

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) { // only splice array when item is found
  array.splice(index, 1); // 2nd parameter means remove one item only
}

// array = [2, 9]
console.log(array);

The second parameter of splice is the number of elements to remove. Note that splice modifies the array in place and returns a new array containing the elements that have been removed.

For completeness, here are functions. The first function removes only a single occurrence (e.g., removing the first match of 5 from [2,5,9,1,5,8,5]), while the second function removes all occurrences:

function removeItemOnce(arr, value) {
  var index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

function removeItemAll(arr, value) {
  var i = 0;
  while (i < arr.length) {
    if (arr[i] === value) {
      arr.splice(i, 1);
    } else {
      ++i;
    }
  }
  return arr;
}
// Usage
console.log(removeItemOnce([2,5,9,1,5,8,5], 5))
console.log(removeItemAll([2,5,9,1,5,8,5], 5))

In TypeScript, these functions can stay type-safe with a type parameter:

function removeItem<T>(arr: Array<T>, value: T): Array<T> {
  const index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

When you delete an element, all the elements after it renumber: the n+1th element becomes nth element, etc. But you progress to the next n anyway. This is why you are skipping some elements.

In the first snippet, you pre-construct the list of indices to iterate over; but as the list shortens, some of the later indices will not exist any more.

In the second snippet, you compare with the actual length of the list on each iteration, so you never get an invalid index.

Also note that bool is not needed whenever you are evaluating a condition, as it is implicitly applied in such a context.

In order to do this correctly, you have two choices:

• iterate from end of the list backwards. If you delete an element, the elements in front of it do not get renumbered.

  for n in range(len(lst) - 1, -1, -1):
      if not lst[n]:
          lst.pop(n)
  

• using the while method, make sure to either increment n (moving n closer to the end of the list), or delete an element (moving the end of the list closer to n); never both at the same time. This will ensure no skipping.

  n = 0
  while n < len(lst):
      if not lst[n]:
          lst.pop(n)
      else:
          n += 1
  

The third option is to avoid the index loop altogether, and do it more pythonically, generating a new list using a comprehension with a filtering condition, or filter.

new_lst = list(filter(bool, lst))

or

new_lst = [e for e in lst if e]

or, if you really want to change the original list, replace its content like this:

lst[:] = filter(bool, lst)

You can use array_values for that like as

$array = [
    0 => 'apple',
    1 => 'banana',
    2 => 'orange',
    3 => 'grapes'
];

unset($array[1]);

print_r(array_values($array));

There is no pop method for NumPy arrays, but you could just use basic slicing (which would be efficient since it returns a view, not a copy):

In [104]: y = np.arange(5); y
Out[105]: array([0, 1, 2, 3, 4])

In [106]: last, y = y[-1], y[:-1]

In [107]: last, y
Out[107]: (4, array([0, 1, 2, 3]))

If there were a pop method it would return the last value in y and modify y.

Above,

last, y = y[-1], y[:-1]

assigns the last value to the variable last and modifies y.