Co je uživatelem definovaný type guard?

Question

Accepted Answer

**user-defined type guard** je funkce, jejíž návratový typ je **type predicate** (`x is T`). Když vrátí `true`, kompilátor zúží argument na `T` v kódu, který ji volá — umožňuje vám zapouzdřit vlastní kontroly v runtime.

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

Bez predikátu `pet is Cat` by funkce `isCat` vracející `boolean` *nezúžila* `pet` — kompilátor by stále viděl `Cat | Dog` uvnitř `if`. Predikát je to, co mu to naučí.

## Ověřování neznámých externích dat

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

## Varování

Kompilátor **důvěřuje** vašemu predikátu — je-li logika v těle chybná, dostanete nebezpečné zúžení. Pro složité tvary vám schema validator (zod) generuje správné guardy.

## Proč na tom záleží

Type guardy vám umožňují přeměnit libovolné kontroly runtime na opakovaně použitelné funkce zúžení — nezbytné pro ověřování `unknown` dat na hranicích API a pro rozlišování členů union, když jednoduchá kontrola `typeof`/`in` nestačí.