Type inference hoạt động như thế nào?

Question

Accepted Answer

**Type inference** là việc TypeScript tự động suy ra kiểu dựa trên ngữ cảnh, nên bạn không phải annotate mọi thứ. Nó infer từ giá trị khởi tạo, câu lệnh return và cách sử dụng.

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

## Inference trong hàm và callback

```ts
function double(n: number) { return n * 2; } // kiểu trả về infer là number

[1, 2, 3].map(n => n * 2); // `n` được infer là number từ mảng — không cần annotation
```

**Contextual typing** này là lý do callback hiếm khi cần annotate tham số — TypeScript biết rằng `map` trên `number[]` truyền vào một `number`.

## Widening giữa let và const

```ts
let a = "hello";     // widen thành string (let có thể gán lại)
const b = "hello";   // narrow thành literal type "hello"
```

`const` infer ra *literal type* vì nó không bao giờ thay đổi; `let` widen thành kiểu tổng quát. Điều này quan trọng đối với union:

```ts
const dir = "up";              // kiểu "up"
let dir2 = "up";               // kiểu string
```

## Khi nào vẫn nên annotate

- Tham số của hàm (không thể infer).
- Khi inference quá rộng/hẹp (ví dụ bạn muốn `string` chứ không phải literal).
- Container rỗng: `const xs = []` infer ra `any[]` — hãy annotate là `number[]`.

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

Inference giữ cho code TypeScript gần như ngắn gọn như JavaScript trong khi vẫn được typed đầy đủ.

Hiểu *khi nào* nó kích hoạt (và khi nào nó widen) giúp bạn chỉ annotate ở nơi thực sự hữu ích.