Looping through array and removing items, without breaking for loop

Why should you reverse your loops?

Running in reverse isn't just for palindromes. When you slice and dice an array with .splice(), elements after the splice see a change in their index. Loitering at the rear resolves this, as those indices were already curated.

Your forward march needs some tuning

Absolutely need to march forward in your for loop? Remember to play with the index and tweak the array length dynamically:

for (let i = 0; i < array.length; i++) {
  if (isUnwanted(array[i])) {
    array.splice(i, 1);
    i--; // Pulling an Uno reverse card on index
  }
}


This tactical retreat ensures you don't plain overlook an element post extermination.

Filter: Your non-mutative robot cleaner

.filter() is you instructing a fully obedient robot 🤖 to handpick everything that isn't dirty:

const cleanArray = array.filter(item => !isUnwanted(item));


This dutiful bot gives you a freshly minted array, leaving the soggy sandwich in the original untouched. Ideal when immutability is a hallmark of respect.

Wherefore art thou chosen?

• If you have a hulking dataset clogging your memory or snoring on speed is a worry, opt for reverse iteration. Modifying the original spell saves time and space. Comes in handy in the cafeteria when short on both.
• If you've pledged allegiance to the Functional Programming banner or wish for an arena sans the old, go for the .filter(). The old guardsmen remain unscathed, and the filtered make a new colony. Perfect during audits or when a population boom is prophesied.

Looping intricacies that sound like Greek

Conditional intricacies

Sometimes your elimination logic moonlights as Schrodinger's cat:

let count = 0;
array.forEach((item, index) => {
  if (complexLogic(item, index, count)) {
    array.splice(index - count, 1);
    count++; // Keeping count like a meticulous librarian
  }
});


Note our librarian count, keeping a beady eye on the book-removals.

ES6-ifying your dictionary

Say cheers to concise syntax with arrow functions:

array = array.filter(item => !isUnwanted(item));


Speak another language with lesser words.

The perils of the loop and their taming

A ticking time bomb

.splice() in loops is akin to a friendly cat with a timed bomb. Each removal rings the bell in O(n), triggering a reindex. Seek refuge in batch exodus or a fresh generation when outrunning the clock.

Undefined phantoms

Eliminate with the delete sword and you birth undefined ghosts:

delete array[index]; // 'I see dead spots!'


.splice() or .filter() are your blessed exorcists here.

Not breaking the code law

The devil's in the edge cases. Keep an eye on both ends and test a bouquet of scenarios - empty arrays, arrays filled till the brim, or those flaunting a proud chaos of both. No room for rebellion.

Beyond loops: Pro strategies

Push over Splice

How about pushing the keepers to a new home instead of chasing the intruders?

let safeHouse = [];
for (let item of array) {
  if (!isUnwanted(item)) safeHouse.push(item);
}


Clean, simplistic, and fends off the spooky index adjustments.

Batman and Robin: Spread and Filter

Your new can be as good as gold in one line:

let goldenArray = [...array].filter(item => !isUnwanted(item));


Clone and mint, all in a day's work.

Pearls of wisdom from the lopsided world of loops

Know thy tool is half the battle won. Seek the method that heals your ache, factoring in mutability, speed, and eloquence.

Welcome the modern era

New in town, arrow functions and the spread syntax open a world of possibilities with a briefer, powerful coding style. Adopt them, breed them, let them prosper.

Don't Re-invent the Wheel

Why manual when automatic does the trick? JavaScript's built-in array methods offer a smoother ride. Intuitive and robust, they save you the blushes from tripping over in public.