Kaip veikia tipo išvada?

Question

Accepted Answer

**Type inference** yra TypeScript automatinė tipų išvada iš konteksto, todėl jums nereikia visos anotacijos. Ji išvada iš pradinių reikšmių, return pareiškimų ir naudojimo.

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

## Išvada funkcijose ir atgaliniuose skambučiuose

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

Šis **kontekstinis tipizavimas** yra priežastis, kodėl grįžtamieji skambučiai retai reikalauja parametrų anotacijų — TypeScript žino, kad `map` ant `number[]` praeina `number`.

## let vs const plėtimasis

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

`const` išvada *esminio* tipo, nes jis niekada negali keistis; `let` išplečia bendrą tipą. Tai svarbu sąjungoms:

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

## Kada anotavieti grynai

- Funkcijos parametrai (negali būti išvesti).
- Kai išvada per plati/siaura (pvz., norite `string` o ne esminio).
- Tuščias konteineris: `const xs = []` išvada `any[]` — anotavite kaip `number[]`.

## Kodėl tai svarbu

Išvada leidžia TypeScript kodu būti beveik toks glaustus kaip JavaScript, bet visiškai tipuotas.

Suprasti *kada* jis pradeda (ir kada išplečiasi) leidžia jums anotavinti tik ten, kur tai iš tikrųjų padeda.