Hvad er type narrowing, og hvordan udfører compileren det?

Question

Accepted Answer

**Narrowing** er den måde, hvorpå TypeScript forfiner en bred type (som f.eks. en union) til en mere specifik type inden for en kodegren, baseret på køretidskontroller. Compileren sporer kontrolflowet og opdaterer typen i overensstemmelse hermed.

```ts
function process(x: string | number) {
  if (typeof x === "string") {
    x.toUpperCase(); // ✅ here x is narrowed to string
  } else {
    x.toFixed(2);    // ✅ here x must be number
  }
}
```

## Værktøjerne til at indsnævre typer

```ts
typeof x === "string"          // typeof guard — for primitives
x instanceof Date              // instanceof — for classes
"role" in obj                  // in operator — property existence
Array.isArray(x)               // built-in guards
if (x) { ... }                  // truthiness narrows out null/undefined/0/""
if (x === null) { ... }         // equality narrowing
```

## Diskriminerede unioner indsnævrer rent

```ts
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape) {
  switch (s.kind) {            // the discriminant
    case "circle": return Math.PI * s.r ** 2;  // s is the circle variant
    case "square": return s.side ** 2;          // s is the square variant
  }
}
```

Efterkontrol af det delte literale felt (`kind`) fortæller compileren præcis, hvilken variant du har, hvilket låser op for denne variants egenskaber.

## Brugerdefinerede guards udvider indsnævringen

```ts
function isUser(x: unknown): x is User { return !!x && typeof (x as any).name === "string"; }
```

## Hvorfor det betyder noget

Narrowing er det, der gør uniontyper *brugbare* — det giver dig mulighed for at få sikker adgang til typspecifikke medlemmer kun efter at have bevist typen, og omdanner køretidskontroller til garantier på kompileringstidspunktet.

Det er den daglige mekanisme bag håndtering af `string | number`, `T | null` og tagged state.