Control structures in JavaScript

JavaScript is one of the most popular programming languages today. It’s what makes websites interactive, creates web applications, and can even be used for backend development. To write useful programs in JavaScript, you need to understand control structures—tools that help you decide the order in which your code runs.

This guide will explain JavaScript control structures in a simple way, covering conditional statements, loops, and error handling. Let’s get started!

What Are Control Structures?

Control structures help you control the flow of your program. Without them, your program would just run each line of code one after another. This isn’t enough for most tasks, where you need your program to make decisions, repeat certain actions, or stop at the right time. Control structures make this possible.

1. Making Decisions with Conditional Statements

Conditional statements allow you to run specific parts of your code depending on whether certain conditions are true or false.

if...else Statements

The if statement checks if something is true. If it is, the code inside the if block runs. If it’s false, you can use else or else if to provide alternatives.

let score = 85;

if (score >= 90) {
  console.log("Excellent!");
} else if (score >= 70) {
  console.log("Good job!");
} else {
  console.log("Keep trying!");
}

If the score is 90 or more, it will log “Excellent!”
Else if the score is between 70 and 89, it will log “Good job!”
Else it will log “Keep trying!”

Switch Statements

The switch statement is another way to make decisions, especially when you’re checking one value against many possibilities.

let day = 2;

switch (day) {
  case 1:
    console.log("Monday");
    break;
  case 2:
    console.log("Tuesday");
    break;
  case 3:
    console.log("Wednesday");
    break;
  default:
    console.log("Unknown day");
}

Each case matches a possible value of day.
The break stops the code from running into the next case.
The default is used if no cases match.

2. Repeating Actions with Loops

Loops help you run the same code multiple times. They’re useful when you want to process lists of items, repeat actions, or automate repetitive tasks.

for Loop

A for loop is great when you know exactly how many times you want to repeat something.

for (let i = 0; i < 5; i++) {
  console.log(`Iteration ${i}`);
}

let i = 0 starts the counter at 0.
i < 5 keeps the loop running while i is less than 5.
i++ increases the counter by 1 after each loop.

while Loop

The while loop repeats a block of code as long as a condition is true.

let count = 0;

while (count < 3) {
  console.log(`Count: ${count}`);
  count++;
}

This loop will run until count reaches 3. Be careful with while loops—they can cause infinite loops if the condition never becomes false.

do...while Loop

The do...while loop is similar to the while loop, but it always runs the code at least once before checking the condition.

let num = 5;

do {
  console.log(`Number: ${num}`);
  num--;
} while (num > 0);

for...of Loop

The for...of loop is used to go through the items in an array or other iterable objects.

let fruits = ["apple", "banana", "cherry"];

for (let fruit of fruits) {
  console.log(fruit);
}

This loop will print each fruit in the fruits array.

for...in Loop

The for...in loop is for objects. It goes through each key in an object.

let user = { name: "Alice", age: 25, city: "New York" };

for (let key in user) {
  console.log(`${key}: ${user[key]}`);
}

This loop will print the keys (name, age, city) and their values.

3. Handling Errors with try...catch

When something goes wrong in your code (like dividing by zero or missing data), JavaScript can throw an error. The try...catch block helps you handle these errors without breaking your program.

try {
  let result = 10 / 0; // This is fine, but unexpected logic
  console.log(result);

  throw new Error("Custom error message!");
} catch (error) {
  console.error("Error caught:", error.message);
} finally {
  console.log("Execution completed.");
}

try runs code that might throw an error.
catch runs if an error happens, letting you respond gracefully.
finally always runs, whether there’s an error or not.

4. Using Functions for Better Control

Functions let you group code into reusable blocks. You can also combine them with control structures to organize your program’s logic.

function categorizeNumber(num) {
  if (num > 0) {
    return "Positive";
  } else if (num < 0) {
    return "Negative";
  } else {
    return "Zero";
  }
}

console.log(categorizeNumber(10)); // Positive

Best Practices for Control Structures

Keep It Simple: Don’t write overly complicated conditions or loops. Break them into smaller pieces if needed.
```
let canDrive = age > 18 && hasLicense && isSober;
if (canDrive) {
  console.log("You can drive!");
}
```
Avoid Nested Loops: Nested loops can be hard to follow. Try using separate functions or breaking the problem into smaller parts.
Use Comments Wisely: Comments should explain why you wrote something, not just what it does.
Choose the Right Tool: Use for...of for arrays, for...in for objects, and pick between while or for loops based on your needs.

Conclusion

Control structures are an essential part of programming in JavaScript. They help you decide what your code should do, how it should repeat actions, and how to handle problems. By learning how to use conditional statements, loops, and error handling, you can create programs that are smarter and more efficient.

The best way to get better is by practicing! Try writing small programs using these control structures, and soon they’ll feel like second nature. Happy coding! 😊

Control structures in JavaScript | Any Notes BCA