type inference ทำงานอย่างไร

Question

IT Interview Practice · Accepted Answer

**Type inference** คือการที่ TypeScript คิดออกประเภทอัตโนมัติจากบริบท ดังนั้นคุณไม่จำเป็นต้องใส่ประเมาณไว้ทุกอย่าง มันอนุมานมาจากค่าเริ่มต้น return statements และการใช้งาน

```ts
let x = 10;          // inferred: number
let s = "hi";        // inferred: string
const arr = [1, 2];  // inferred: number[]
const obj = { a: 1, b: "x" }; // inferred: { a: number; b: string }
```

## Inference ในฟังก์ชันและ callbacks

```ts
function double(n: number) { return n * 2; } // return inferred as number

[1, 2, 3].map(n => n * 2); // `n` inferred as number from the array — no annotation needed
```

**contextual typing** นี้เป็นเหตุผลว่าทำไม callbacks จึงไม่ค่อยต้องการ parameter annotations — TypeScript รู้ว่า `map` บน `number[]` ผ่าน `number` มา

## let vs const widening

```ts
let a = "hello";     // widened to string (let can be reassigned)
const b = "hello";   // narrowed to the literal type "hello"
```

`const` อนุมานประเภท *literal* เพราะมันไม่สามารถเปลี่ยนได้; `let` ขยายไปยังประเภททั่วไป นี่เป็นสิ่งสำคัญสำหรับ unions:

```ts
const dir = "up";              // type "up"
let dir2 = "up";               // type string
```

## เมื่อใดควร annotate

- Function parameters (ไม่สามารถอนุมานได้).
- เมื่อ inference กว้างเกินไป/แคบเกินไป (เช่น คุณต้องการ `string` ไม่ใช่ literal).
- Empty containers: `const xs = []` อนุมาน `any[]` — ใส่ `number[]` ไว้

## ทำไมนี่จึงสำคัญ

Inference ทำให้โค้ด TypeScript กระชับเกือบเท่ากับ JavaScript ในขณะที่ยังคงพิมพ์ได้อย่างสมบูรณ์

การเข้าใจว่า *เมื่อใด* มันเกิดขึ้น (และเมื่อใดที่มันขยาย) ช่วยให้คุณใส่ประเมาณเพียงตรงที่มันช่วยได้จริง

Inference ในฟังก์ชันและ callbacks

let vs const widening

เมื่อใดควร annotate

ทำไมนี่จึงสำคัญ

คำถามที่เกี่ยวข้อง