User-defined type guard là gì?

Question

Accepted Answer

Một **user-defined type guard** là hàm có kiểu trả về là một **type predicate** (`x is T`). Khi nó trả về `true`, compiler narrow đối số thành `T` trong code gọi hàm — cho phép bạn đóng gói các kiểm tra runtime tùy chỉnh.

```ts
interface Cat { meow(): void; }
interface Dog { bark(): void; }

// điều kỳ diệu nằm ở kiểu trả về `pet is Cat`, không chỉ là `boolean`
function isCat(pet: Cat | Dog): pet is Cat {
  return "meow" in pet;
}

function speak(pet: Cat | Dog) {
  if (isCat(pet)) {
    pet.meow(); // ✅ được narrow thành Cat
  } else {
    pet.bark(); // ✅ được narrow thành Dog
  }
}
```

Nếu không có predicate `pet is Cat`, việc `isCat` trả về `boolean` sẽ *không* narrow `pet` — compiler vẫn nhìn thấy `Cat | Dog` bên trong `if`. Chính predicate là thứ chỉ dạy cho nó điều đó.

## Kiểm tra dữ liệu bên ngoài kiểu 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; // ✅ được type an toàn là User
```

## Lưu ý

Compiler **tin tưởng** predicate của bạn — nếu logic trong thân hàm sai, bạn sẽ có một narrowing không an toàn. Đối với các shape phức tạp, một schema validator (zod) sẽ tự tạo các guard chính xác cho bạn.

## Tại sao điều này quan trọng

Type guard cho phép bạn biến các kiểm tra runtime bất kỳ thành các hàm narrowing có thể tái sử dụng — thiết yếu để kiểm tra dữ liệu `unknown` tại ranh giới API và để phân biệt các thành viên của một union khi một kiểm tra `typeof`/`in` đơn giản là chưa đủ.