Mikä on käyttäjän määrittämä type guard?

Question

Accepted Answer

**user-defined type guard** on funktio, jonka paluutyyppi on **type predicate** (`x is T`). Kun se palauttaa `true`, kääntäjä kaventaa argumentin arvoon `T` kutsuvassa koodissa — antaen sinun kapselloida mukautettuja runtime-tarkistuksia.

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

Ilman `pet is Cat` -predikaattia, `isCat` joka palauttaa `boolean` *ei* kaventaisi `pet`:ia — kääntäjä silti näkisi `Cat | Dog` `if`-lohkossa. Predikaatti on se, joka opettaa sen.

## Tuntemattomien ulkoisten tietojen validointi

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

## Varoitus

Kääntäjä **luottaa** predikaattiisi — jos rungon logiikka on väärä, saat turvattoman kaventamisen. Monimutkaisille muodoille schema validator (zod) luo oikeita guard-funktioita sinulle.

## Miksi sillä on merkitystä

Type guard-funktiot mahdollistavat mielivaltaisten runtime-tarkistusten muuntamisen uudelleenkäytettäviksi kaventamisfunktioiksi — oleelliset `unknown`-tietojen validoinnille API-rajoilla ja union-jäsenten erottamiselle, kun yksinkertainen `typeof`/`in`-tarkistus ei yksinään riitä.