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
anyapaga la comprobación: todo vale. Es una salida de emergencia, no un tipo.unknownes “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/typepara objetos; uniones con estrechamiento; genéricos para código reutilizable.unknownpara lo que viene de afuera, y valida en ejecución;anysolo como último recurso.strict: true;tsc --noEmitcomprueba; Node.js ejecuta.tsborrando los tipos.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: Tipos sobre JavaScript
Resuelto
Elige una respuesta en cada pregunta.
¿Qué pasa con los tipos de TypeScript al ejecutar el programa?
¿Qué diferencia hay entre
anyyunknown?En TypeScript, ¿dos tipos con distinto nombre y las mismas propiedades son compatibles?
¿Se pueden tener tipos sin escribir archivos
.ts?
Ordena la salida: Tipos que desaparecen
Resuelto
Un archivo TypeScript ejecutado con Node.js. Ordena lo que aparecería en la terminal.
1// precio.ts, ejecutado con: node precio.ts2function conIva(precio: number, tasa = 0.5): number {3 return precio * (1 + tasa);4}5 6const p = conIva(100) satisfies number;7console.log(p);8console.log(typeof conIva);9console.log(conIva("50" as any));10 11type Moneda = "PEN" | "USD";12const m: Moneda = "PEN";13console.log(m.length);Consola, de arriba abajo
- 75
- 150
- 3
- function
Node.js borra los tipos y ejecuta el JavaScript que queda. Con as any se le miente al compilador: llega un texto, y la multiplicación lo convierte en número. Los tipos no protegen en tiempo de ejecución. type no genera ningún código: m es un texto normal.
Detective: Un texto donde va un número
Resuelto
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:6Paso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?