Miten type inference toimii?

Question

Accepted Answer

**Type inference** on TypeScriptin automaattista tyyppien selvittämistä kontekstista, joten sinun ei tarvitse merkitä kaikkea. Se päättelee alkuarvoista, return-lauseista ja käytöstä.

```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 funktioissa ja takaisinkutsuissa

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

Tämä **kontekstuaalinen tyypitys** on syy siihen, miksi takaisinkutsut harvoin tarvitsevat parametrimerkintöjä — TypeScript tietää, että `map` `number[]`-arvolla välittää `number`-arvon.

## let vs const laajentaminen

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

`const` päättelee *kirjaimellisen* tyypin, koska se ei voi koskaan muuttua; `let` laajenee yleiseksi tyypiksi. Tämä on tärkeää yhdistelmille:

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

## Milloin merkitse joka tapauksessa

- Funktioparametrit (ei voida päätellä).
- Kun inference on liian laaja/kapea (esim. haluat `string` ei kirjainta).
- Tyhjät säiliöt: `const xs = []` päättelee `any[]` — merkitse `number[]`-arvoksi.

## Miksi sillä on väliä

Inference pitää TypeScript-koodin lähes yhtä ytimekkäänä kuin JavaScript mutta silti täysin tyypitettynä.

Ymmärtämällä *milloin* se aktivoituu (ja milloin se laajenee), voit merkitä vain kohdissa, joissa se todella auttaa.