Hva er en brukerdefinert typevakt?

Question

Accepted Answer

En **brukerdefinert typevakt** er en funksjon hvis returtype er et **typepredikat** (`x is T`). Når den returnerer `true`, snevrer kompilatoren argumentet inn til `T` i den kode som kaller funksjonen — slik at du kan innkapsle egendefinerte kjøretidskontroller.

```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
  }
}
```

Uten predikatet `pet is Cat` ville `isCat` som returnerer `boolean` *ikke* snevre inn `pet` — kompilatoren ville fortsatt se `Cat | Dog` inne i `if`-uttrykket. Predikatet er det som lærer den dette.

## Validering av ukjent eksterne 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
```

## Forbehold

Kompilatoren **stoler på** predikatetditt — hvis logikken i kroppen er feil, får du en usikker innsnevrering. For komplekse strukturer genererer en schemavaldator (zod) riktige vakter for deg.

## Hvorfor det er viktig

Typevakter lar deg gjøre vilkårlige kjøretidskontroller om til gjenbrukbare innsnevrringsfunksjoner — essensielt for validering av `unknown`-data på API-grenser og for å skille medlemmer av en union når en enkel `typeof`/`in`-sjekk ikke er tilstrekkelig på egenhånd.