Loopageddon: How a Time-Traveling Robot Mastered JavaScript Loops (And Saved the Universe)

In the year 3023, a rogue AI named Z3R0 accidentally traps humanity in an infinite time loop. To fix this, Dr. Chronos, a eccentric scientist, builds Loop-Bot 9000, a robot programmed to learn JavaScript loops and break the cycle. Here’s their journey…

Chapter 1: The for Loop – A Precision Strike

Scene: Loop-Bot’s first mission: Destroy 5 energy cores powering the time loop.

Dr. Chronos: Loop-Bot, you need to attack exactly 5 times. No more, no less. Use a for loop, it’s like a laser-guided missile for repetition!

for (let attack = 1; attack <= 5; attack++) {  
  console.log(`Energy Core ${attack} destroyed!`);  
}  

// Output:
// Energy Core 1 destroyed!   
// Energy Core 2 destroyed!   
// Energy Core 3 destroyed!   
// Energy Core 4 destroyed!   
// Energy Core 5 destroyed!

What Happened?

1. Initialization: let attack = 1 → The loop starts with attack set to 1, targeting the first energy core.

2. Condition Check: attack <= 5 → Before each iteration, the loop checks if attack is 5 or less; if true, the loop continues.

3. Execution: Inside the loop, console.log prints the destruction message for the current core.

4. Increment: attack++ → After each iteration, attack increases by 1, moving to the next core.

5. Loop Ends: When attack reaches 6, the condition attack <= 5 becomes false, and the loop stops.

Loop-Bot: Cores eliminated. Time stability at 20%.

Chapter 2: The while Loop – The Relentless Guardian

Scene: Z3R0 spawns infinite drones. Loop-Bot must fight until none remain.

Dr. Chronos: We don’t know how many drones there are. Use a while loop, it’ll run as long as drones exist!

let drones = 100; // Z3R0's army  

while (drones > 0) {  
  console.log(`${drones} drones remaining!`);  
  drones--; // Loop-Bot destroys one drone per loop  
}  

// Output:
// 100 drones remaining!  
// 99 drones remaining!   
// 98 drones remaining!   
// ...  
// 2 drones remaining!  
// 1 drone remaining!

What Happened?

1. Initialization: let drones = 100 → The loop starts with 100 drones.

2. Condition Check: drones > 0 → Before each iteration, it checks if drones are still present. If true, the loop continues.

3. Execution: Inside the loop, console.log prints the number of remaining drones.

4. Decrement: drones-- → After each iteration, the drone count decreases by 1.

5. Loop Ends: When drones reaches 0, the condition drones > 0 becomes false, stopping the loop.

Loop-Bot: Drones neutralized. Time stability at 50%.

Chapter 3: The do...while Loop – The Reckless Gambit

Scene: Loop-Bot must hack Z3R0’s firewall. Even if it fails once, it must try again.

Dr. Chronos: Use a do...while! It runs at least once, even if the condition is false. Perfect for risky hacks!

let attempt = 0;  

do {  
  console.log(`Hacking attempt ${attempt}...`);  
  attempt++;  
} while (attempt < 3); // Ensures the loop runs at least once and stops after 3 attempts  

// Output:
// Hacking attempt 0...
// Hacking attempt 1... 
// Hacking attempt 2...

What Happened?

1. Initialization: let attempt = 0 → The loop starts with attempt set to 0.

2. First Execution: The do block runs once before any condition is checked, ensuring at least one attempt.

3. Increment: attempt++ → The attempt count increases by 1 in each iteration.

4. Condition Check: while (attempt < 3) → After each attempt, the condition is evaluated. If true, the loop repeats.

5. Loop Ends: When attempt reaches 3, the condition becomes false, stopping further execution.

Chapter 4: The break & continue – The Great Escape

Scene: Loop-Bot is trapped in Z3R0’s labyrinth. It must skip traps (continue) and find the exit (break).

Dr. Chronos: Use continue to skip lava pits and break to escape when you find the exit!

for (let step = 1; step <= 10; step++) {  
  if (step === 3 || step === 7) {  
    console.log("Lava pit! Skipping step", step);  
    continue; // Skip this iteration  
  }  
  if (step === 5) {  
    console.log("Exit found! Breaking the loop.");  
    break; // Exit the loop  
  }  
  console.log("Walking step", step);  
}  

// Output:
// Walking step 1
// Walking step 2
// Lava pit! Skipping step 3
// Walking step 4
// Exit found! Breaking the loop.

What Happened?

1. continue skips step 3, but step 7 is never reached because the loop exits before that.

2. break stops the loop at step 5, preventing any further iterations.

3. The loop prints steps 1, 2, skips step 3, prints step 4, and then exits at step 5.

Loop-Bot: Labyrinth escaped. Time stability at 100%.

Epilogue: The Loop is Broken

Z3R0’s time loop collapses. Humanity is saved. Dr. Chronos celebrates with a cup of holographic coffee.

Dr. Chronos: Loops aren’t just for code, Loop-Bot. They’re for doing the impossible, one iteration at a time.

Loop-Bot: Directive complete. Awaiting next adventure…