Kaip veikia tipo išvada?

Question

IT Interview Practice · 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.

Išvada funkcijose ir atgaliniuose skambučiuose

let vs const plėtimasis

Kada anotavieti grynai

Kodėl tai svarbu

Susiję klausimai