การยืนยันประเภท (Type Assertions) คืออะไร และเมื่อใดจึงเป็นอันตราย?

Question

Accepted Answer

**การยืนยันประเภท** บอก compiler ว่า "เชื่อใจฉัน ค่านี้เป็นประเภท X" โดยใช้ `as` มันไม่มี**การแปลงหรือการตรวจสอบในเวลาทำงาน** — มันเพียงเปลี่ยนวิธีที่ compiler ปฏิบัติต่อค่า

```ts
const el = document.getElementById("app") as HTMLInputElement;
el.value = "hi"; // compiler now allows .value (it assumed HTMLInputElement)

const data = JSON.parse(str) as User; // assert the parsed shape
```

## เหตุใดจึงเป็นอันตราย

การยืนยันจะสร้างสิ่งที่ compiler พิจารณา — หากคุณผิด คุณจะได้รับ runtime crash โดยไม่มีคำเตือน:

```ts
const x = "hello" as unknown as number; // double assertion — compiler stops complaining
x.toFixed(2); // 💥 runtime error: x.toFixed is not a function
```

การยืนยันจะไม่*ทำให้*ค่านั้นเป็นประเภทดังกล่าว มันเพียงแค่ปิดเครื่องตรวจสอบ คุณได้นำความรับผิดชอบในเรื่องความถูกต้องออกจาก compiler

## ทางเลือกที่ปลอดภัยกว่า

```ts
// 1. type guard — actually verify at runtime
if (typeof input === "string") { /* input is string, proven */ }

// 2. validation library (zod) for external data
const user = UserSchema.parse(data); // throws if shape is wrong
```

## `as const` นั้นต่างกัน

```ts
const point = { x: 1 } as const; // not a risky cast — narrows to literal/readonly
```

## เหตุใดจึงสำคัญ

การยืนยันบางครั้งจำเป็น (DOM APIs การจำกัด `unknown` ที่คุณตรวจสอบแล้ว) แต่แต่ละอันคือสถานที่ที่ compiler ไม่สามารถปกป้องคุณได้

นำทางด้วยประเภท guards หรือ schema validation สำหรับข้อมูลที่ไม่น่าเชื่อถือ และถือว่าทุก `as` เป็นสิ่งเล็กน้อย โดยเจตนา "ฉันรู้ดีกว่า" ที่คุณต้องแน่ใจ

เหตุใดจึงเป็นอันตราย

ทางเลือกที่ปลอดภัยกว่า

as const นั้นต่างกัน

เหตุใดจึงสำคัญ

`as const` นั้นต่างกัน