Jak działa wnioskowanie typów?

Question

Accepted Answer

**Wnioskowanie typów** to mechanizm, w którym TypeScript automatycznie określa typy na podstawie kontekstu, więc nie musisz adnotować wszystkiego. Wnioskuje z wartości początkowych, instrukcji return i sposobu użycia.

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

## Wnioskowanie w funkcjach i callbackach

```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 **typowanie kontekstowe** jest powodem, dla którego callbacki rzadko wymagają adnotacji parametrów — TypeScript wie, że `map` na `number[]` przekazuje `number`.

## let vs const — rozszerzanie typów

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

`const` wnioskuje typ *literalny*, ponieważ wartość nigdy się nie zmieni; `let` rozszerza do ogólnego typu. To ma znaczenie dla unii typów:

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

## Kiedy i tak warto adnotować

- Parametry funkcji (nie można ich wnioskować).
- Gdy wnioskowanie jest zbyt szerokie lub zbyt wąskie (np. chcesz `string`, a nie typ literalny).
- Puste kontenery: `const xs = []` wnioskuje `any[]` — adnotuj jako `number[]`.

## Dlaczego to ważne

Wnioskowanie sprawia, że kod TypeScript jest prawie tak zwięzły jak JavaScript, pozostając w pełni typowany.

Zrozumienie *kiedy* się aktywuje (i kiedy się rozszerza) pozwala adnotować tylko tam, gdzie rzeczywiście pomaga.