TypeScript para principiantes: por qué (y cuándo) usarlo sobre JavaScript

Si ya conoces JavaScript, en algún momento te vas a topar con proyectos que en lugar de archivos .js usan .ts. No es un lenguaje nuevo que tengas que aprender desde cero: TypeScript es JavaScript con una capa añadida encima, y esa capa es un sistema de tipos. Todo el JavaScript que ya sabes escribir sigue siendo válido en TypeScript.

La pregunta real no es "¿qué es TypeScript?" sino "¿qué problema resuelve que JavaScript no resuelve?". Y la respuesta corta es: te avisa de errores antes de ejecutar el código, no después.

El problema que TypeScript viene a resolver

JavaScript es un lenguaje de tipado dinámico: una variable puede contener un número en una línea y un string en la siguiente, y el intérprete no se queja hasta que ese cambio provoca un error en tiempo de ejecución. Eso está bien para scripts pequeños, pero en un proyecto de miles de líneas con varios desarrolladores tocando el mismo código, ese margen de error se paga caro: funciones que reciben un objeto con una propiedad que no existe, valores undefined que viajan silenciosamente por la aplicación hasta explotar tres capas más abajo.

TypeScript añade un sistema de tipado estático opcional: declaras qué tipo de dato espera cada variable, parámetro o valor de retorno, y un compilador revisa esas declaraciones antes de que el código llegue a ejecutarse. Si algo no encaja, TypeScript te lo dice en el editor, con la línea exacta señalada, en lugar de dejarte descubrirlo con un usuario real en producción.

La misma función, con y sin tipos

Nada explica esto mejor que ver el mismo código en los dos lenguajes. Aquí tienes una función que calcula el total de un carrito de la compra, primero en JavaScript puro y después con las anotaciones de tipos de TypeScript:

function calcularTotal(items) {
  return items.reduce((total, item) => {
    return total + item.precio * item.cantidad;
  }, 0);
}

// Esto compila y falla en tiempo de ejecución
calcularTotal([{ precio: "10", cantidad: 2 }]);
// "1010" en vez de 20 (concatenación de strings)

// Esto también compila y explota
calcularTotal(null);
// TypeError: Cannot read properties of null

interface ItemCarrito {
  precio: number;
  cantidad: number;
}

function calcularTotal(items: ItemCarrito[]): number {
  return items.reduce((total, item) => {
    return total + item.precio * item.cantidad;
  }, 0);
}

// Error de compilación, antes de ejecutar nada:
// Type 'string' is not assignable to type 'number'
calcularTotal([{ precio: "10", cantidad: 2 }]);

// Error de compilación:
// Argument of type 'null' is not assignable
calcularTotal(null);

La lógica de la función es idéntica en los dos casos. La diferencia está en interface ItemCarrito y en las anotaciones : ItemCarrito[] y : number: le dicen a TypeScript exactamente qué forma debe tener cada dato. Con esa información, el compilador detecta los dos errores del ejemplo antes de que el código se ejecute una sola vez, algo que en JavaScript puro solo descubrirías probando manualmente cada caso o con un test.

¿Cuándo merece la pena usarlo?

TypeScript no es gratis: añade un paso de compilación, una curva de aprendizaje para el sistema de tipos, y en proyectos muy pequeños puede sentirse como burocracia innecesaria. La regla práctica que suele funcionar es esta:

• Sí, úsalo en cualquier proyecto que vaya a crecer, tenga más de una persona tocando el código, o vaya a mantenerse durante meses. Prácticamente todos los frameworks modernos (Angular por defecto, React y Vue con soporte de primera clase) están pensados para trabajar bien con TypeScript.
• Puede esperar si estás haciendo un script rápido de un solo uso, un prototipo desechable, o si todavía estás aprendiendo los fundamentos de JavaScript. Añadir tipos antes de dominar el lenguaje base solo suma fricción.

En la práctica, la mayoría de ofertas de trabajo para frontend y muchas de backend con Node.js ya piden TypeScript como requisito o "muy valorado", así que aprenderlo deja de ser opcional bastante pronto en cualquier carrera como desarrollador.

Tipos básicos que vas a usar todo el rato

No necesitas memorizar el sistema de tipos entero para empezar. Con estos cubres el 90% de los casos del día a día:

let nombre: string = "Ana";
let edad: number = 28;
let activo: boolean = true;
let etiquetas: string[] = ["dev", "backend"];

// Tipo unión: puede ser uno de varios tipos
let id: string | number = "abc123";

// Tipo opcional en un objeto
interface Usuario {
  nombre: string;
  email: string;
  telefono?: string; // el "?" lo hace opcional
}

// any desactiva el chequeo de tipos — úsalo lo mínimo posible
let cualquierCosa: any = "esto puede ser lo que sea";

Un consejo desde ya: evita any salvo que de verdad no tengas alternativa. Usarlo por todas partes anula la ventaja principal de TypeScript, que es precisamente que el compilador sepa qué forma tiene cada dato.

Cómo empezar sin agobiarte

No necesitas convertir un proyecto entero de golpe. TypeScript permite adopción gradual: puedes tener archivos .js y .ts conviviendo en el mismo proyecto y migrar poco a poco. Para probarlo sin instalar nada, el TypeScript Playground oficial te deja escribir código y ver cómo se compila a JavaScript en tiempo real, en el navegador.

El sistema de tipos de TypeScript da para mucho más (genéricos, tipos condicionales, utilidades como Partial o Pick), pero con lo de aquí ya puedes leer la mayoría del código TypeScript que te vas a encontrar y empezar a escribir el tuyo con confianza. El resto se aprende según lo vayas necesitando, igual que pasa con cualquier herramienta nueva.