Vad är en användardefinierad typkontroll?

Question

Accepted Answer

En **användardefinierad typkontroll** är en funktion vars returtyp är ett **typpredikat** (`x is T`). När den returnerar `true` begränsar kompilatorn argumentet till `T` i den anropande koden — vilket låter dig kapsla in anpassade körtidskontroller.

```ts
interface Cat { meow(): void; }
interface Dog { bark(): void; }

// the magic is the return type `pet is Cat`, not just `boolean`
function isCat(pet: Cat | Dog): pet is Cat {
  return "meow" in pet;
}

function speak(pet: Cat | Dog) {
  if (isCat(pet)) {
    pet.meow(); // ✅ narrowed to Cat
  } else {
    pet.bark(); // ✅ narrowed to Dog
  }
}
```

Utan predikatet `pet is Cat` skulle en `isCat` som returnerar `boolean` *inte* begränsa `pet` — kompilatorn skulle fortfarande se `Cat | Dog` inuti `if`-blocket. Predikatet är det som lär den detta.

## Validering av okänd extern data

```ts
interface User { id: number; name: string; }

function isUser(x: unknown): x is User {
  return (
    typeof x === "object" && x !== null &&
    typeof (x as any).id === "number" &&
    typeof (x as any).name === "string"
  );
}

const data: unknown = await res.json();
if (isUser(data)) data.name; // ✅ safely typed as User
```

## Varning

Kompilatorn **litar på** ditt predikat — om logiken i funktionskroppen är felaktig får du en osäker begränsning. För komplexa strukturer kan en schemavalidator (zod) generera korrekta kontroller åt dig.

## Varför det är viktigt

Typkontroller låter dig omvandla godtyckliga körtidskontroller till återanvändbara begränsningsfunktioner — väsentligt för validering av `unknown`-data vid API:er/gränser och för att särskilja medlemmar i en union när en enkel `typeof`/`in`-kontroll inte räcker till i sig.