Apa iku type guard sing didefinisikake dhewe?

Question

Accepted Answer

A **user-defined type guard** adalah fungsi sing return type-ne yaiku **type predicate** (`x is T`). Nalika bali `true`, compiler mempersempit argument menyang `T` ing kode sing manggil — ngandharake sampeyan enkapsulasi custom runtime checks.

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

Tanpa predicate `pet is Cat`, `isCat` sing bali `boolean` ora bakal mempersempit `pet` — compiler isih bakal ndeleng `Cat | Dog` ing kode `if`. Predicate-ne sing ajari.

## Validasi data eksternal sing unknown

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

## Catetan

Compiler **percaya** menyang predicate sampeyan — yen logika ing badan-ne salah, sampeyan bakal entuk narrowing sing ora aman. Kanggo shapes sing rumit, schema validator (zod) ngasilake correct guards kanggo sampeyan.

## Luwih penting

Type guards ngandharake sampeyan ngowahi arbitrary runtime checks menyang reusable narrowing functions — penting kanggo validasi `unknown` data ing API/boundaries lan kanggo mbedakake members saka union nalika simple `typeof`/`in` check ora cukup dhewe.