TypeScript 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;
  }
}

Tired of Poor TypeScript Skills? Fix That With Deep Grasping!Learn More

Methods

Functions

Constructors

Classes

Generics

Type Definitions

Decorators

Accessors

Fields

Variables

Parameters

Modules

Namespaces

Enums

Destructuring

Error Handling

Control Flow

Loops

Built-In Object Types

Primitive & Special Types

Comments & Directives

Type Operators

Access Operators

Conditional & Sequence Operators

Logical Operators

Comparison Operators

Unary Operators

Assignment Operators

Arithmetic Operators

Bitwise Operators

TypeScript Switch Statement

Execution Mechanics

TypeScript Control Flow Analysis

Type Narrowing

Exhaustiveness Checking

​Execution Mechanics

​TypeScript Control Flow Analysis

​Type Narrowing

​Exhaustiveness Checking

Execution Mechanics

TypeScript Control Flow Analysis

Type Narrowing

Exhaustiveness Checking