TypeScript Medio · Teoría
22 lecciones originales con ejemplos breves, puntos clave y referencias para profundizar.
Un parámetro de tipo conserva relaciones entre entradas y salidas sin sustituirlas por any. TypeScript suele inferirlo desde los argumentos.
function primero<T>(valores: readonly T[]): T | undefined { return valores[0]; }extends limita los tipos admisibles y permite usar miembros conocidos dentro de la implementación.
function longitud<T extends { length: number }>(valor: T): number { return valor.length; }Un parámetro genérico puede tener un tipo predeterminado cuando la inferencia y los argumentos explícitos no aportan otro.
type Resultado<T = string> = { valor: T; correcto: boolean };keyof T produce una unión de claves conocidas y permite relacionar una clave con el objeto al que pertenece.
function leer<T, K extends keyof T>(objeto: T, clave: K): T[K] { return objeto[clave]; }En una posición de tipo, typeof obtiene el tipo estático de un valor declarado. No es la misma operación que el typeof de runtime usado para narrowing.
const configuracion = { modo: "seguro", intentos: 3 };
type Configuracion = typeof configuracion;T[K] consulta el tipo asociado a una clave. Con uniones de claves obtiene la unión de los valores correspondientes.
type Usuario = { id: string; activo: boolean };
type Identificador = Usuario["id"];A & B exige satisfacer simultáneamente ambas estructuras. No es una operación que mezcle objetos en runtime.
type ConId = { id: string };
type Auditable = { actualizado: number };
type Registro = ConId & Auditable;Una propiedad literal común permite distinguir variantes y conservar los datos específicos de cada estado.
type Resultado = { tipo: "ok"; valor: number } | { tipo: "error"; mensaje: string };never representa un estado imposible. Asignar la variante restante a never hace que una nueva alternativa rompa el build hasta tratarla.
function imposible(valor: never): never { throw new Error(String(valor)); }Una función que retorna valor is Tipo comunica al checker un narrowing probado por lógica de runtime escrita por el programa.
function esTexto(valor: unknown): valor is string { return typeof valor === "string"; }Una firma asserts condicion o asserts valor is Tipo indica que el retorno normal garantiza una condición; el fallo debe interrumpir el flujo.
function exigirTexto(valor: unknown): asserts valor is string { if (typeof valor !== "string") throw new Error("texto esperado"); }Las firmas de overload describen llamadas públicas y una implementación compatible las resuelve. La firma de implementación no es directamente invocable desde fuera.
function convertir(valor: string): number;
function convertir(valor: number): string;
function convertir(valor: string | number) { return typeof valor === "string" ? Number(valor) : String(valor); }Una clase genérica relaciona el estado y los métodos de cada instancia con un tipo elegido o inferido.
class Caja<T> { constructor(public valor: T) {} map<U>(f: (valor: T) => U): Caja<U> { return new Caja(f(this.valor)); } }Una clase abstracta puede compartir implementación y exigir miembros a subclases, pero no puede instanciarse directamente.
abstract class Figura { abstract area(): number; describir() { return `Área: ${this.area()}`; } }Partial, Required, Pick, Omit, Record y Readonly transforman contratos existentes de forma declarativa.
type Usuario = { id: string; nombre: string; activo: boolean };
type Resumen = Pick<Usuario, "id" | "nombre">;Un mapped type recorre keyof para producir propiedades y puede añadir o retirar readonly y opcionalidad.
type Opcional<T> = { [K in keyof T]?: T[K] };T extends U ? X : Y elige un tipo según una relación de asignabilidad. Con T genérico puede distribuir sobre uniones.
type Elemento<T> = T extends readonly (infer U)[] ? U : T;Los template literal types forman cadenas a partir de literales y uniones, útiles para eventos y claves derivadas.
type Evento = `usuario:${"creado" | "eliminado"}`;Promise<T> describe el resultado futuro y Awaited<T> desenvuelve recursivamente promesas y thenables según la semántica de await.
async function cargar(): Promise<number> { return 7; }
type Dato = Awaited<ReturnType<typeof cargar>>;Un valor es compatible si ofrece al menos los miembros requeridos con tipos compatibles. La procedencia nominal no suele importar.
interface Nombrado { nombre: string }
const completo = { nombre: "Ada", edad: 36 };
const breve: Nombrado = completo;satisfies comprueba compatibilidad sin reemplazar el tipo inferido; as const conserva literales y añade readonly de forma superficial.
const rutas = { inicio: "/", perfil: "/yo" } as const satisfies Record<string, string>;import type y export type hacen explícitas dependencias borradas al emitir. verbatimModuleSyntax preserva la intención; module/moduleResolution deben ajustarse al host real.
import type { Usuario } from "./modelos";
export type { Usuario };