Apa itu user-defined type guard?

Question

Accepted Answer

A **user-defined type guard** adalah sebuah fungsi yang tipe kembaliannya adalah sebuah **type predicate** (`x is T`). Ketika ia mengembalikan `true`, kompiler mempersempit argumen ke `T` dalam kode yang memanggil — memungkinkan Anda untuk mengenkapsulasi pemeriksaan runtime khusus.

```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 predikat `pet is Cat`, `isCat` yang mengembalikan `boolean` *tidak akan* mempersempit `pet` — kompiler masih akan melihat `Cat | Dog` di dalam `if`. Predikat adalah apa yang mengajarkannya.

## Mengapa ini penting

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

## Caveat

Kompiler **mempercayai** predikat Anda — jika logika dalam fungsi salah, Anda mendapat penyempitan yang tidak aman. Untuk bentuk yang kompleks, sebuah schema validator (zod) menghasilkan guard yang benar untuk Anda.

## Validasi data eksternal yang tidak dikenal

Type guard memungkinkan Anda mengubah pemeriksaan runtime yang sembarangan menjadi fungsi penyempitan yang dapat digunakan kembali — penting untuk memvalidasi data `unknown` pada batasan API dan untuk membedakan anggota union ketika pemeriksaan sederhana `typeof`/`in` tidak cukup dengan sendirinya.