Control Structure in Javascript Exercise Solutions | KalviGavani

• (a) for loop
• (b) while loop
• (c) if-else statement ✓
• (d) do-while loop

• (a) The condition is checked after the loop body executes
• (b) The condition is checked before the loop body executes ✓
• (c) The condition is never checked
• (d) The loop always runs at least once

• (a) for loop
• (b) while loop
• (c) do-while loop ✓
• (d) switch statement

• (a) Skips the current iteration
• (b) Terminates the loop and transfers control to the statement after the loop ✓
• (c) Restarts the loop from the beginning
• (d) Pauses the loop execution

• (a) switch (expression) { case value: statements; } ✓
• (b) switch { expression: case value; }
• (c) switch (case) { value: expression; }
• (d) switch expression { value: case; }

• (a) Condition
• (b) Update expression
• (c) Initialisation ✓
• (d) Loop body

• (a) switch statement
• (b) for loop
• (c) if-else statement ✓
• (d) while loop

• (a) 0 1 2
• (b) 1 2 3 ✓
• (c) 1 2 3 4
• (d) 0 1 2 3

A control structure is a programming construct that determines the order in which statements are executed in a program. JavaScript provides three types of control structures: sequential (default top-to-bottom flow), selection (if, if-else, switch), and iteration (for, while, do-while). Control structures allow programs to make decisions and repeat actions.

1. Sequential Structure — Statements execute one after another in order. 2. Selection Structure — The program chooses a path based on a condition (if, if-else, if-else-if ladder, switch). 3. Iteration Structure — A block of code repeats as long as a condition is true (for, while, do-while).

The if-else statement is a selection control structure that provides two alternative paths. If the condition following if evaluates to true, the if block executes; otherwise, the else block executes. It is used when a program needs to choose between two mutually exclusive actions.

The switch statement is a multi-way branch selection structure. It evaluates an expression and matches its value against one or more case labels. When a match is found, the statements under that case execute. A default case handles situations where no case matches. Each case typically ends with a break to prevent fall-through.

The break statement is a control flow statement that immediately terminates the innermost loop or switch statement and transfers control to the statement following the terminated loop or switch. It is commonly used inside switch cases to prevent fall-through and inside loops to exit when a specific condition is met.

The if-else-if ladder allows a program to test multiple conditions sequentially. Each condition is evaluated in order; the block associated with the first true condition executes, and the remaining conditions are skipped.

let marks = 75;

if (marks >= 90) {
  console.log("Grade A");
} else if (marks >= 75) {
  console.log("Grade B");
} else if (marks >= 60) {
  console.log("Grade C");
} else {
  console.log("Grade D");
}
// Output: Grade B

Here, marks >= 90 is false, so it moves to the next condition. marks >= 75 is true, so "Grade B" is printed and the remaining else-if and else blocks are skipped.

The for loop is an entry-controlled iteration structure where initialisation, condition, and update are specified in a single line. It is used when the number of iterations is known in advance.

Syntax:

for (initialisation; condition; update) {
  // loop body
}

Example — Print numbers 1 to 5:

for (let i = 1; i <= 5; i++) {
  console.log(i);
}
// Output: 1 2 3 4 5

• let i = 1 — initialisation (runs once)
• i <= 5 — condition (checked before each iteration)
• i++ — update (runs after each iteration)

The switch statement evaluates an expression and matches its value against case labels. When a match is found, the corresponding block executes. The break prevents fall-through to the next case, and default handles unmatched values.

let day = 3;

switch (day) {
  case 1:
    console.log("Monday");
    break;
  case 2:
    console.log("Tuesday");
    break;
  case 3:
    console.log("Wednesday");
    break;
  case 4:
    console.log("Thursday");
    break;
  case 5:
    console.log("Friday");
    break;
  default:
    console.log("Weekend");
}
// Output: Wednesday

A nested if is an if statement placed inside another if or else block. It is used when a second condition must be checked only after the first condition is true.

let age = 20;
let hasID = true;

if (age >= 18) {
  if (hasID) {
    console.log("Eligible to vote");
  } else {
    console.log("Bring your ID");
  }
} else {
  console.log("Not eligible to vote");
}
// Output: Eligible to vote

The outer if checks age, and only if age is 18+ does the inner if check for ID.

JavaScript supports three categories of control structures:

a) Sequential Structure: Statements execute in order, one after another, from top to bottom. This is the default flow of any program.

let a = 10;
let b = 20;
let sum = a + b;
console.log(sum); // 30

b) Selection Structure: Allows the program to choose between alternative paths based on conditions.

Simple if:

let num = 10;
if (num > 0) {
  console.log("Positive number");
}

if-else:

let age = 16;
if (age >= 18) {
  console.log("Adult");
} else {
  console.log("Minor");
}
// Output: Minor

if-else-if ladder:

let score = 82;
if (score >= 90) {
  console.log("A+");
} else if (score >= 80) {
  console.log("A");
} else if (score >= 70) {
  console.log("B");
} else {
  console.log("C");
}
// Output: A

switch:

let colour = "red";
switch (colour) {
  case "red":
    console.log("Stop");
    break;
  case "yellow":
    console.log("Ready");
    break;
  case "green":
    console.log("Go");
    break;
  default:
    console.log("Invalid colour");
}
// Output: Stop

c) Iteration Structure: Repeats a block of code as long as a condition is true.

for loop:

for (let i = 1; i <= 5; i++) {
  console.log(i);
}
// Output: 1 2 3 4 5

while loop:

let i = 1;
while (i <= 5) {
  console.log(i);
  i++;
}
// Output: 1 2 3 4 5

do-while loop:

let j = 1;
do {
  console.log(j);
  j++;
} while (j <= 5);
// Output: 1 2 3 4 5

The factorial of n (written as n!) is the product of all positive integers from 1 to n. Example: 5! = 5 x 4 x 3 x 2 x 1 = 120.

a) Using for loop:

let n = 5;
let fact = 1;
for (let i = 1; i <= n; i++) {
  fact = fact * i;
}
console.log(n + "! = " + fact);
// Output: 5! = 120

b) Using while loop:

let n = 5;
let fact = 1;
let i = 1;
while (i <= n) {
  fact = fact * i;
  i++;
}
console.log(n + "! = " + fact);
// Output: 5! = 120

c) Using do-while loop:

let n = 5;
let fact = 1;
let i = 1;
do {
  fact = fact * i;
  i++;
} while (i <= n);
console.log(n + "! = " + fact);
// Output: 5! = 120

In all three approaches, the variable fact is initialised to 1 (since 0! = 1 and multiplying by 1 is the identity). The loop multiplies fact by each integer from 1 to n. Note: the do-while loop will produce 1 even if n = 0, which is correct since 0! = 1.

break Statement: The break statement immediately terminates the innermost loop or switch and transfers control to the statement after it.

Example — break in a loop:

for (let i = 1; i <= 10; i++) {
  if (i === 5) {
    break;
  }
  console.log(i);
}
// Output: 1 2 3 4

When i equals 5, break exits the loop entirely. Numbers 5 through 10 are never printed.

Example — break in switch:

let day = "Tuesday";
switch (day) {
  case "Monday":
    console.log("Start of week");
    break;
  case "Tuesday":
    console.log("Second day");
    break;
  default:
    console.log("Other day");
}
// Output: Second day

Without break, execution would "fall through" to subsequent cases, which is usually unintended.

continue Statement: The continue statement skips the remaining code in the current iteration and jumps to the next iteration of the loop.

Example — continue in a loop:

for (let i = 1; i <= 10; i++) {
  if (i % 2 !== 0) {
    continue;
  }
  console.log(i);
}
// Output: 2 4 6 8 10

When i is odd, continue skips the console.log and moves to the next iteration. Only even numbers are printed.

Key Differences: