Como funciona a inferência de tipos?

Question

Accepted Answer

**Inferência de tipos** é TypeScript descobrindo tipos automaticamente a partir do contexto, para que você não tenha que anotar tudo. Infere a partir de valores iniciais, instruções de retorno e uso.

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

## Inferência em funções e callbacks

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

Esta **tipagem contextual** é por que callbacks raramente precisam de anotações de parâmetro — TypeScript sabe que `map` em um `number[]` passa um `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` infere o tipo *literal* porque nunca pode mudar; `let` amplia para o tipo geral. Isso importa para unions:

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

## Quando anotar mesmo assim

- Parâmetros de função (não podem ser inferidos).
- Quando a inferência é muito ampla/restrita (ex: você quer `string` e não o literal).
- Containers vazios: `const xs = []` infere `any[]` — anote como `number[]`.

## Por que isso importa

A inferência mantém o código TypeScript quase tão conciso quanto JavaScript enquanto permanece totalmente tipado.

Entender *quando* ela entra em ação (e quando se amplia) permite que você anote apenas onde realmente ajuda.