> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# 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.
```text theme={"dark"}
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 `{}`.
```typescript theme={"dark"}
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.
```typescript theme={"dark"}
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.
```typescript theme={"dark"}
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
