Saltar al contenido
Herramientas y ecosistema

TypeScript para quien ya sabe JS

Lección 5 de 614 min3 ejercicios

TypeScript es JavaScript con tipos: anotas qué forma tienen tus datos, y un comprobador te avisa, antes de ejecutar, cuando algo no encaja. No es otro lenguaje: todo lo que sabes de JavaScript sigue valiendo, y los tipos desaparecen al ejecutar. Hoy es el estándar de facto en proyectos medianos y grandes.

Tipos sobre lo que ya sabes

let nombre: string = "Ana";
let edad = 31;                       // inferido: number
const activo = true;                 // inferido: true (un literal, porque es const)
let etiquetas: string[] = ["js"];
let punto: [number, number] = [3, 4];    // tupla: largo y tipos fijos

function saludar(persona: string, formal = false): string {
  return formal ? `Buenos días, ${persona}` : `Hola, ${persona}`;
}

saludar("Luis");
// saludar(42);   // error: Argument of type 'number' is not assignable to parameter of type 'string'

No hace falta anotar todo: TypeScript infiere los tipos de las variables y de lo que devuelven las funciones. Se anotan, sobre todo, los parámetros.

Objetos: type e interface

interface Producto {
  id: number;
  nombre: string;
  precio: number;
  descripcion?: string;           // opcional
  readonly sku: string;           // no se puede reasignar
}

type Moneda = "PEN" | "USD" | "EUR";     // unión de literales

function formatear(p: Producto, moneda: Moneda = "PEN"): string {
  return `${p.nombre}: ${p.precio.toFixed(2)} ${moneda}`;
}

interface y type sirven casi para lo mismo con objetos; type además describe uniones, tuplas y combinaciones. Los tipos son estructurales: cualquier objeto con esas propiedades sirve, se llame como se llame.

Uniones y estrechamiento

Una unión (A | B) dice que un valor puede ser uno u otro. Antes de usar algo que solo tiene uno, hay que estrechar el tipo con una comprobación que TypeScript entiende:

type Resultado =
  | { ok: true; datos: Producto[] }
  | { ok: false; error: string };

function mostrar(r: Resultado) {
  if (r.ok) {
    console.log(r.datos.length);    // aquí TypeScript sabe que hay datos
  } else {
    console.log(r.error);           // y aquí, que hay error
  }
}

function largo(x: string | string[]) {
  return typeof x === "string" ? x.length : x.join("").length;
}

typeof, instanceof, in, comparar con un literal y Array.isArray estrechan el tipo.

Genéricos

Un genérico es un tipo con un “hueco” que se llena al usarlo, para escribir funciones y estructuras que sirven para cualquier tipo sin perder información:

function primero<T>(lista: T[]): T | undefined {
  return lista[0];
}

const n = primero([3, 1, 2]);         // number | undefined
const s = primero(["a", "b"]);        // string | undefined

interface Respuesta<T> {
  datos: T;
  pagina: number;
}
const r: Respuesta<Producto[]> = { datos: [], pagina: 1 };

any, unknown y los datos de afuera

  • any apaga la comprobación: todo vale. Es una salida de emergencia, no un tipo.
  • unknown es “no sé qué es”: obliga a comprobarlo antes de usarlo. Es lo correcto para datos de afuera.
const datos: unknown = await respuesta.json();
// datos.nombre;   // error: 'datos' is of type 'unknown'
if (typeof datos === "object" && datos !== null && "nombre" in datos) {
  console.log(datos.nombre);
}

Recuerda que los tipos no existen al ejecutar: lo que llega de una API, un formulario o un archivo puede ser cualquier cosa, aunque lo anotes como Producto. Para validar de verdad, una librería como Zod comprueba en ejecución y además te da el tipo.

Configurar y ejecutar

npm install -D typescript
npx tsc --init          # crea tsconfig.json
npx tsc --noEmit        # comprueba los tipos de todo el proyecto, sin generar archivos

En tsconfig.json, activa siempre "strict": true: es lo que hace que TypeScript atrape los errores importantes, como usar algo que puede ser undefined.

Para ejecutar: los empaquetadores (Vite) y los runtimes (Deno, Bun) entienden .ts directamente, y Node.js también, desde la versión 23.6, borrando los tipos:

node servidor.ts

Node no comprueba los tipos (para eso sigue tsc), y solo acepta la sintaxis que se puede borrar sin más: nada de enum, namespace con código ni parámetros de constructor con modificadores. Con "erasableSyntaxOnly": true en el tsconfig.json, TypeScript te avisa si usas algo de eso.

Tipos sin TypeScript: JSDoc

Si prefieres no compilar, puedes escribir los tipos en comentarios JSDoc dentro de archivos .js, y pedirle a TypeScript que los compruebe ("checkJs": true):

/**
 * @param {number} precio
 * @param {number} [porcentaje=0]
 * @returns {number}
 */
export function conDescuento(precio, porcentaje = 0) {
  return precio * (1 - porcentaje / 100);
}

Resumen

  • TypeScript = JavaScript + tipos que se comprueban antes de ejecutar y desaparecen después.
  • Anota los parámetros; el resto suele inferirse.
  • interface/type para objetos; uniones con estrechamiento; genéricos para código reutilizable.
  • unknown para lo que viene de afuera, y valida en ejecución; any solo como último recurso.
  • strict: true; tsc --noEmit comprueba; Node.js ejecuta .ts borrando los tipos.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Tipos sobre JavaScript

Elige una respuesta en cada pregunta.

  1. ¿Qué pasa con los tipos de TypeScript al ejecutar el programa?

  2. ¿Qué diferencia hay entre any y unknown?

  3. En TypeScript, ¿dos tipos con distinto nombre y las mismas propiedades son compatibles?

  4. ¿Se pueden tener tipos sin escribir archivos .ts?

Ordena la salida: Tipos que desaparecen

Un archivo TypeScript ejecutado con Node.js. Ordena lo que aparecería en la terminal.

// precio.ts, ejecutado con: node precio.tsfunction conIva(precio: number, tasa = 0.5): number {  return precio * (1 + tasa);} const p = conIva(100) satisfies number;console.log(p);console.log(typeof conIva);console.log(conIva("50" as any)); type Moneda = "PEN" | "USD";const m: Moneda = "PEN";console.log(m.length);

Consola, de arriba abajo

  1. 75
  2. 150
  3. 3
  4. function

Detective: Un texto donde va un número

TypeScript se queja antes de ejecutar. Encuentra la línea donde nace el problema y elige el arreglo.

Consola

src/total.ts:6:20 - error TS2322: Type 'string' is not assignable to type 'number'.

6 console.log(total([entrada, 3]));
                     ~~~~~~~

Found 1 error in src/total.ts:6

Paso 1: toca la línea de código que causa el error.

domina-js · JavaScript en español, gratis y paso a paso.