¿Cómo funciona la inferencia de tipos?

Question

Accepted Answer

La **inferencia de tipos** es TypeScript deduciendo tipos automáticamente a partir del contexto, para que no tengas que anotar todo. Infiere a partir de los valores iniciales, las sentencias de retorno y el 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 }
```

## Inferencia en funciones y 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 **tipado contextual** es la razón por la que los callbacks rara vez necesitan anotaciones de parámetros — TypeScript sabe que `map` sobre un `number[]` pasa un `number`.

## Ampliación (widening) con let frente a const

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

`const` infiere el tipo *literal* porque nunca puede cambiar; `let` se amplía al tipo general. Esto importa para las uniones:

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

## Cuándo anotar de todos modos

- Parámetros de función (no se pueden inferir).
- Cuando la inferencia es demasiado amplia/estrecha (por ejemplo, quieres `string` y no el literal).
- Contenedores vacíos: `const xs = []` infiere `any[]` — anótalo como `number[]`.

## Por qué es importante

La inferencia mantiene el código TypeScript casi tan conciso como JavaScript a la vez que permanece completamente tipado.

Entender *cuándo* entra en juego (y cuándo amplía) te permite anotar solo donde realmente ayuda.