Lección 77 — Inferencia y Anotaciones

🧠 Concepto

TypeScript se esfuerza por deducir los tipos automáticamente siempre que puede. A esto se le llama inferencia de tipos. Las anotaciones explícitas son opcionales cuando el tipo es obvio.

Inferencia básica

let nombre = 'Ana';      // TS infiere: string
let edad = 25;            // TS infiere: number
let esActivo = true;      // TS infiere: boolean
let frutas = ['manzana']; // TS infiere: string[]

Inferencia de retorno de función

function sumar(a: number, b: number) {
  return a + b;
  // TS infiere que retorna number
}

Inferencia con const

Cuando usas const, TS infiere el tipo literal, no el tipo general:

const NOMBRE = 'Ana';      // tipo: 'Ana' (literal), no string
const EDAD = 25;           // tipo: 25 (literal), no number

// Con let en cambio:
let nombre = 'Ana';        // tipo: string

Cuándo usar anotaciones explícitas

Aunque TS infiere muy bien, hay casos donde conviene anotar:

1. Parámetros de función: siempre deben anotarse (no hay inferencia desde el caller).
2. Retorno complejo: cuando quieres asegurar que la función retorna exactamente lo esperado.
3. Declaración sin valor inicial.
4. Variables que cambiarán a otro tipo (aunque esto suele ser mala práctica).

💻 Ejemplo

Anotaciones necesarias vs innecesarias

// ❌ Anotación redundante
let mensaje: string = 'Hola';

// ✅ Mejor (inferencia)
let mensaje = 'Hola';

// ✅ Anotación necesaria (parámetro)
function saludar(nombre: string): string {
  return `Hola ${nombre}`;
}

// ✅ Anotación útil (retorno explícito)
function operacionCompleja(a: number, b: number): number {
  return a * b + 10;
}

// ✅ Anotación necesaria (sin valor inicial)
let resultado: number;
resultado = 42;

Tipos literales con const

const ROL = 'admin';    // tipo: 'admin'
const PUERTO = 3000;    // tipo: 3000

// Útil para configuraciones fijas
type RolUsuario = 'admin' | 'usuario' | 'invitado';

function configurarRol(rol: RolUsuario): void {
  // ...
}

configurarRol('admin');      // ✅
configurarRol('superadmin'); // ❌ Error

📝 Ejercicio

Declara las siguientes variables sin anotar el tipo y deja que TS infiera:

1. ciudad con valor 'Madrid' → ¿qué tipo infiere?
2. poblacion con valor 3_200_000 → ¿qué tipo infiere?
3. esCapital con valor true → ¿qué tipo infiere?
4. datos con valor null → ¿qué tipo infiere?

Luego declara con const: PI = 3.1416. Inspecciona el tipo con el cursor en VS Code. ¿Qué diferencia notas respecto a let?

⚠️ Nota

TypeScript es más inteligente de lo que parece. Infiere tipos a través de condicionales, arrays, reducers y funciones complejas. Confía en la inferencia y solo anota cuando sea necesario.

🎯 Tip

VS Code te muestra el tipo inferido al pasar el cursor sobre una variable. Úsalo para entender qué está infiriendo TS y detectar posibles errores temprano.