Kados tipe inference bisa gumana?

Question

Accepted Answer

**Type inference** yaiku TypeScript nggoleki tipe kanthi otomatis saka konteks, dadi sampeyan ora kudu ngandeni kabeh. Iku nggoleki saka nilai awal, return statement, lan panggunaan.

```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 ing fungsi lan 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
```

Iku **contextual typing** yaiku sebabe callback jarang kudu parameter annotation — TypeScript ngerti `map` ing `number[]` ngirim `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` nggoleki tipe *literal* amarga ora bisa diganti; `let` nggedhekake jang tipe umum. Iki penting kanggo union:

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

## Kapan ngandeni

- Parameter fungsi (ora bisa dinggoleki).
- Nalika inference kuwat banget/tipis (cth., sampeyan pengen `string` dudu literale).
- Container kosong: `const xs = []` nggoleki `any[]` — annotate dadi `number[]`.

## Mengapa penting

Inference njaga TypeScript kode kaya ringkes kaya JavaScript nalika tetep sepenuhnya ketik.

Mangerti *kapan* kita ngangkat (lan kapan ngedhekake) ngidini sampeyan ngandeni mung nang ngendi utawa bener-bener mbantu.