Jak fungujetype inference?

Question

Accepted Answer

**Type inference** je TypeScript automaticky zjišťující typy z kontextu, takže nemusíte anotovat všechno. Odvozuje ze počátečních hodnot, return statements a použití.

```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 v funkcích a callbackech

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

Toto **kontextové typování** je důvod, proč callbacky zřídka potřebují anotace parametrů — TypeScript ví, že `map` na `number[]` předává `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` odvodí *literálný* typ, protože se nikdy nemůže změnit; `let` se rozšíří na obecný typ. To je důležité pro unie:

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

## Kdy stejně anotovat

- Parametry funkcí (nelze odvodit).
- Když je inference příliš široká/úzká (např. chcete `string` ne literál).
- Prázdné kontejnery: `const xs = []` odvodí `any[]` — anotujte jako `number[]`.

## Proč to důležité

Inference uchovává kód TypeScript skoro stejně stručný jako JavaScript a přitom zůstává plně typovaný.

Rozvoje, kdy se aktivuje (a kdy se rozšíří), vám umožňuje anotovat pouze tam, kde to opravdu pomáhá.