Bagaimana kesimpulan jenis berfungsi?

Question

Accepted Answer

**Type inference** adalah TypeScript yang menentukan jenis secara otomatis dari konteks, jadi Anda tidak perlu memberi anotasi pada semuanya. Ia menyimpulkan dari nilai awal, pernyataan return, dan penggunaan.

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

## Kesimpulan dalam fungsi dan callback

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

**Pengetikan kontekstual** ini adalah alasan mengapa callback jarang memerlukan anotasi parameter — TypeScript tahu bahwa `map` pada `number[]` melewati `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` menyimpulkan jenis *literal* karena tidak dapat berubah; `let` meluas ke jenis umum. Ini penting untuk union:

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

## Kapan tetap anotasi

- Parameter fungsi (tidak dapat disimpulkan).
- Ketika kesimpulan terlalu lebar/sempit (mis. Anda menginginkan `string` bukan literal).
- Kontainer kosong: `const xs = []` menyimpulkan `any[]` — anotasi sebagai `number[]`.

## Mengapa ini penting

Kesimpulan membuat kode TypeScript hampir sesingkat JavaScript sambil tetap sepenuhnya ketik.

Memahami *kapan* ia dimulai (dan kapan diperluas) memungkinkan Anda memberi anotasi hanya di mana itu benar-benar membantu.