splice(i, 1) removes one item starting at index i and mutates the array, which is fast but surprising in shared state. The immutable form copies the prefix and suffix around the removed index using slice and the spread operator, so callers can rely on the original array surviving. Pick the mutable form only when you own the array and the mutation is the explicit intent (a queue you are draining, for example). For React state, props, or any data passed across module boundaries, default to the immutable variant so equality checks like prev !== next keep working.

Plain index assignment is the obvious mutable form, fine for a fresh local array but dangerous on data you do not own. The slice/spread variant builds a new array and is supported everywhere. The newest option, Array.prototype.with(i, v), returns a copy with index i replaced and reads more declaratively, but it requires Node 20 or a modern browser. When i is out of range, with throws a RangeError, while the slice form silently appends to the end, so handle that case explicitly if your input range is uncertain.

splice(i, 0, item) is the canonical in-place insert: zero items removed, one item inserted at i. The immutable form mirrors the remove/update recipes, with the new item slotted between the prefix and the suffix. For multi-item inserts, spread the new items in place of a single value so you do not pay an extra copy. Note that you can attach extra properties or methods to an array (e.g. arr.label = 'fruits') since arrays are objects, but those properties do not survive slice, concat, or [...arr], so prefer a wrapping object when you need them to persist.

filter is the right default: declarative, immutable, and obvious to read. Note that you pass the predicate that decides which items to KEEP, so negate it when the natural phrasing is "remove these". When you must mutate in place (memory-tight loops, very large arrays), iterate backwards so removing index i does not change the index of the next item to inspect. A forward loop with splice skips elements right after a removal and produces silently wrong output. Both forms are linear time; the immutable version trades a copy for safety, which is almost always the right call.