Czym jest strażnik typu zdefiniowany przez użytkownika?

Question

Accepted Answer

**Strażnik typu zdefiniowany przez użytkownika** to funkcja, której typ zwracanej wartości to **predykat typu** (`x is T`). Gdy zwróci `true`, kompilator zawęża argument do `T` w kodzie wywołującym — pozwala to na hermetyzację niestandardowych sprawdzeń czasu wykonania.

```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 predykatu `pet is Cat`, zwrócenie przez `isCat` wartości `boolean` *nie zawęziłoby* `pet` — kompilator nadal widział by `Cat | Dog` wewnątrz `if`. Predykat jest tym, co go tego uczy.

## Walidacja nieznanych danych z zewnątrz

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

## Zastrzeżenie

Kompilator **ufa** twojemu predykatowi — jeśli logika w treści jest błędna, otrzymujesz niebezpieczne zawężenie. Dla złożonych struktur validator schematu (zod) generuje dla ciebie poprawne strażniki.

## Dlaczego to ważne

Strażniki typów pozwalają zamieniać dowolne sprawdzenia czasu wykonania na wielokrotnie używane funkcje zawęźające — niezbędne do walidacji danych `unknown` na granicach API i do rozróżnienia członków unii, gdy sam prosty check `typeof`/`in` nie wystarczy.