# How to Use Logical AND (&&) in a TypeScript Switch Case Statement

> Learn how to use logical AND (&&) in TypeScript switch case statements. Discover how the compiler evaluates these expressions for precise control flow.

- Repository: [Microsoft/TypeScript](https://github.com/microsoft/typescript)
- Tags: how-to-guide
- Published: 2026-02-14

---

**In TypeScript, a logical AND (`&&`) expression is valid inside a `case` clause because the compiler evaluates it as a single expression and compares the result to the switch value using strict equality (`===`).**

The TypeScript compiler processes `switch` statements by evaluating the switch expression once and comparing it against each `case` clause using the strict equality algorithm. According to the microsoft/TypeScript source code, the parser handles logical AND operators within `case` expressions through the `CaseClause` AST node, while the type checker validates compatibility between expression types.

## How TypeScript Processes Case Expressions

In the TypeScript compiler architecture, a `switch` statement evaluates its expression once, and each `case` clause contains a single expression compared to that value using **strict equality (`===`)**.

According to the source code in [`src/compiler/parser.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/parser.ts), the `parseCaseClause` function (lines 7012–7031) creates a `CaseClause` node whose `expression` property holds the parsed expression. The **scanner** recognizes the `&&` token as `AmpersandAmpersandToken` in [`src/compiler/scanner.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/scanner.ts) (line 262), allowing the parser to handle logical AND operations within case expressions. The AST visitor in [`src/compiler/visitorPublic.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/visitorPublic.ts) (lines 1713–1714) walks these nodes during transformation.

## Type Checking Logical AND in Cases

The TypeScript type checker validates that the `case` expression's type is compatible with the type of the `switch` expression. In [`src/compiler/checker.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/checker.ts), the `getTypeOfSwitchClause` function (lines 28451–28477) performs this validation.

When you write `case (a && b):`, the compiler treats this as a normal expression: it evaluates `a && b`, yields either `a` (if falsy) or `b` (if `a` is truthy), and then performs the `===` comparison against the switch value. The `CaseClause` interface is defined in [`src/compiler/types.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/types.ts) (lines 3481–3497), which specifies that the expression property can hold any valid expression, including logical operations.

## Recommended Patterns for Logical Conditions

### Direct Logical AND Comparison

Use this pattern when the switch value itself should match the result of an `&&` expression. This is rare but valid:

```typescript
switch (value) {
  case (cond1 && cond2):
    // Matches when value === (cond1 && cond2)
    break;
}

```

### Switch on True (Conditional Switch)

The most common pattern for evaluating arbitrary boolean conditions uses `switch (true)`. This forces each `case` expression to be compared against the boolean `true`:

```typescript
switch (true) {
  case cond1 && cond2:
    // Executes when both conditions are truthy
    break;
  case cond3:
    // Executes when cond3 is truthy
    break;
}

```

### Stacked Cases for Multiple Values

When logic requires handling multiple discrete values without logical operators, stack the cases:

```typescript
switch (value) {
  case 'a':
  case 'b':
    // Handles both 'a' and 'b'
    break;
}

```

## Complete Code Examples

### Using && for Direct Comparison

```typescript
const flag = true;
const value = 42;

switch (value) {
  case (flag && 42):      // Evaluates to 42 → matches
    console.log('matched via &&');
    break;
  default:
    console.log('no match');
}

```

The expression `flag && 42` evaluates to `42` because `flag` is truthy. The comparison `value === 42` succeeds.

### Conditional Switch with Multiple Conditions

```typescript
function handle(input: string) {
  const isNumber = /^\d+$/.test(input);
  const isHex    = /^0x[0-9a-f]+$/i.test(input);

  switch (true) {
    case isNumber && isHex:        // Both true → hex number like "0xFF"
      console.log('hex number');
      break;
    case isNumber && !isHex:       // Numeric but not hex
      console.log('decimal number');
      break;
    case input === 'quit':
      console.log('quit command');
      break;
    default:
      console.log('unrecognized');
  }
}

```

Each `case` evaluates a boolean expression; the first truthy match executes.

### Fallback with Stacked Cases

```typescript
const day = 'Saturday';

switch (day) {
  case 'Saturday':
  case 'Sunday':
    console.log('weekend');
    break;
  default:
    console.log('weekday');
}

```

## Summary

- TypeScript `case` clauses accept any single expression, including logical AND (`&&`) operations, as implemented in [`src/compiler/parser.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/parser.ts) (lines 7012–7031).
- The compiler evaluates the expression and compares it to the switch value using strict equality (`===`), verified by `getTypeOfSwitchClause` in [`src/compiler/checker.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/checker.ts) (lines 28451–28477).
- The `switch (true)` pattern provides the most readable approach for testing multiple boolean conditions with logical operators.
- For multiple discrete values, prefer stacked `case` labels over logical operators for clarity and type safety.

## Frequently Asked Questions

### Can you use logical operators in TypeScript switch cases?

Yes. The TypeScript parser explicitly supports logical operators like `&&` and `||` within `case` expressions. In [`src/compiler/scanner.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/scanner.ts) (line 262), the `&&` token is recognized as `AmpersandAmpersandToken`, and the parser handles it as part of the expression in `parseCaseClause` (lines 7012–7031). The expression evaluates to a single value that undergoes strict equality comparison.

### Why does the `switch (true)` pattern work with logical AND?

The `switch (true)` pattern works because each `case` expression is evaluated and compared to `true` using strict equality. When you write `case (cond1 && cond2):`, the logical AND returns either a falsy value or the second operand. If both conditions are truthy, the result equals `true`, causing the case to match. This pattern leverages the `CaseClause` AST node defined in [`src/compiler/types.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/types.ts) (lines 3481–3497).

### What is the difference between `case (a && b)` and `case a: case b:`?

`case (a && b)` evaluates the logical AND as an expression and compares the result to the switch value, matching only when `switchValue === (a && b)`. In contrast, `case a:` followed by `case b:` creates fall-through behavior where the code executes if the switch value equals `a` OR equals `b`. The latter handles discrete values, while the former evaluates truthiness and returns the last evaluated operand.

### Is there a performance impact when using && in switch cases?

No. The TypeScript compiler produces JavaScript that evaluates the expression at runtime using standard ECMAScript semantics. The presence of `&&` in a `case` expression does not trigger additional compiler overhead beyond the normal expression parsing handled by `parseCaseClause` in [`src/compiler/parser.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/parser.ts) and type checking in `getTypeOfSwitchClause` within [`src/compiler/checker.ts`](https://github.com/microsoft/TypeScript/blob/main/src/compiler/checker.ts).