Switch Statement

A switch statement is a control flow construct that evaluates a single expression and executes specific blocks of code based on strict equality (===) matching against predefined case clauses. In TypeScript, switch statements integrate directly with the compiler’s control flow analysis to provide automatic type narrowing and compile-time exhaustiveness checking.

switch (expression) {
  case value1:
    // Statements execute if expression === value1
    break;
  case value2:
    // Statements execute if expression === value2
    break;
  default:
    // Statements execute if no cases match
}

Execution Mechanics

• Strict Equality: TypeScript evaluates the expression once and compares it to each case value using strict equality (===). The TypeScript compiler will throw a type error if the type of a case value is not comparable to the type of the switch expression (meaning the types must have some overlap; they do not strictly need to be assignable).
• Fallthrough: If a case block does not terminate with a break, return, or throw statement, execution automatically “falls through” to the subsequent case block, bypassing its evaluation. TypeScript provides the noFallthroughCasesInSwitch compiler flag to emit an error when a non-empty case block lacks a termination statement.
• Lexical Scoping: By default, the entire switch statement shares a single lexical scope. Declaring a block-scoped variable (let or const) in one case makes it visible (though potentially uninitialized) to all other cases, preventing redeclaration. To isolate scope, wrap the case execution statements in a block {}.

const numericValue = 1;

switch (numericValue) {
  case 1: {
    const scopedVariable = true; // Isolated to this block
    break;
  }
  case 2: {
    const scopedVariable = false; // Valid redeclaration due to block scoping
    break;
  }
}

TypeScript Control Flow Analysis

TypeScript applies specific compile-time behaviors to switch statements when evaluating union types, literal types, or enums.

Type Narrowing

Within a matched case block, TypeScript narrows the type of the evaluated expression to the specific literal type or enum member matched by that case.

function processInput(input: string | number) {
  switch (typeof input) {
    case "string":
      // 'input' is narrowed to type 'string'
      input.toUpperCase(); 
      break;
    case "number":
      // 'input' is narrowed to type 'number'
      input.toFixed(2);
      break;
  }
}

Exhaustiveness Checking

When switching on a finite union type, TypeScript can enforce that all possible variants are explicitly handled. This is achieved by utilizing the never type in the default clause. If a union member is added later and not handled by a case, the compiler will fail to assign the unhandled type to never, resulting in a build error.

type State = "idle" | "loading" | "success";

function handleState(state: State) {
  switch (state) {
    case "idle":
      break;
    case "loading":
      break;
    case "success":
      break;
    default:
      // If a new State is added (e.g., "error"), 'state' will not be 'never' here,
      // triggering a compile-time error on the assignment below.
      const _exhaustiveCheck: never = state;
      return _exhaustiveCheck;
  }
}

Master TypeScript with Deep Grasping Methodology!

Learn More