Kako deluje tipska sklepanja?

Question

Accepted Answer

**Tipska sklepanja** so TypeScript samodejno ugotavljanja tipov iz konteksta, zato vam ni treba označevati vsega. Sklepa iz začetnih vrednosti, stavkov return in porabe.

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

## Sklepanja v funkcijah in povratnih klicev

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

To **kontekstno tipiziranje** je razlog, da povratni klici le redko potrebujejo opombe parametrov — TypeScript ve, da `map` na `number[]` prosledi `number`.

## let v primerjavi s const razširitvijo

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

`const` sklepa *dobesedni* tip, ker se nikoli ne more spremeniti; `let` se razširi na splošni tip. To je pomembno za unije:

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

## Kdaj vseeno označiti

- Parametri funkcije (ni mogoče sklepati).
- Ko je sklepanje preširoko/premajhno (npr. želite `string`, ne dobesedne vrednosti).
- Prazni vsebniki: `const xs = []` sklepa `any[]` — označite kot `number[]`.

## Zakaj je to pomembno

Sklepanja vzdržujejo TypeScript kodo skoraj tako jedrnato kot JavaScript, medtem ko ostaja v celoti tipizirana.

Razumevanje, *kdaj* se aktivira (in kdaj se razširi), vam omogoči, da označite samo tam, kjer res pomaga.