Block Scope in Conditionals and Loops in JavaScript

Block Scope in Conditionals and Loops in JavaScript

if, for, while, and switch all involve blocks. Here is how let and const behave in each.

if...else

if (condition) {
  const result = computeA();
  let temp = result * 2;
} else {
  const result = computeB(); // OK, separate block
}
console.log(result); // ReferenceError (block-scoped)
``
Each branch of `if...else` is its own block. `result` in the `if` and `result` in the `else` are separate variables.

### `for` Loops

```js
for (let i = 0; i < 3; i++) {
  const item = items[i]; // block-scoped to this iteration
  console.log(item);
}
console.log(i);    // ReferenceError
console.log(item); // ReferenceError
``
`i` and `item` are both block-scoped. `let i` creates a fresh binding per iteration.

### `for...of` and `for...in`

```js
for (const item of [1, 2, 3]) {
  console.log(item); // 1, 2, 3
}
for (const key in { a: 1, b: 2 }) {
  console.log(key); // "a", "b"
}
``
`const` works here because each iteration is a fresh binding that does not change within the iteration.

### `while` and `do...while`

```js
let count = 0;
while (count < 3) {
  const item = `item ${count}`; // block-scoped to this iteration
  count++;
}
console.log(item); // ReferenceError
``
### `switch`

```js
switch (x) {
  case 1: {
    const y = 1; // block-scoped to this case
    break;
  }
  case 2: {
    const y = 2; // OK, separate block
    break;
  }
}
``
Without braces, all cases share one block scope, and re-declaring `let` or `const` throws. Wrap each case in braces to give it its own scope.

### `try...catch`

```js
try {
  const data = JSON.parse(json); // block-scoped to try
} catch (err) {
  // err is block-scoped to catch
  console.log(err.message);
}
console.log(data); // ReferenceError
console.log(err);  // ReferenceError
``
### The Takeaway

`if`, `for`, `while`, `switch`, and `try...catch` all create blocks. `let` and `const` inside them are block-scoped. Each `if`/`else` branch and each `switch` case (with braces) is a separate scope. `const` works in `for...of`/`for...in` (fresh binding per iteration). Wrap `switch` cases in braces to avoid re-declaration errors.