Tienes una interfaz Producto con seis campos. El formulario de "crear producto" no lleva id porque lo genera el servidor. El de "editar" tiene que dejar todos los campos opcionales. Y la API pública no debe enseñar el precio de coste. Así que copias la interfaz tres veces, quitas una línea en una, pones un ? en cada campo de otra, y sigues adelante.
El problema llega un mes después, cuando añades un campo descuento a Producto y te olvidas de dos de las tres copias. Cada interfaz es válida por separado, así que el compilador no dice nada, y el fallo aparece cuando alguien edita un producto desde el formulario y el descuento no llega nunca.
En el post de genéricos usaste Partial de pasada y en el de union types viste cómo limitar los valores de un campo. Aquí juntamos todo eso en algo que se parece a lo que harás en un trabajo: mantener un único tipo y fabricar el resto a partir de él.
Está escrito pensando en TypeScript 7.0, la versión estable actual (se anunció en julio de 2026). Todo el código lo he compilado con TypeScript 7.0.2 en modo estricto y el programa final lo he ejecutado con Node.js; estas herramientas llevan años en el lenguaje, así que sirven igual en versiones anteriores. Si todavía no tienes TypeScript montado, el post de introducción explica la instalación paso a paso.
El problema: tres copias que se desincronizan
Este es el punto de partida, con el que probablemente te has encontrado ya. Una interfaz base y tres copias retocadas a mano:
type Categoria = "ropa" | "calzado" | "accesorios";
interface Producto {
id: number;
nombre: string;
precio: number;
categoria: Categoria;
etiquetas: string[];
precioCoste: number;
}
interface NuevoProducto {
nombre: string;
precio: number;
categoria: Categoria;
etiquetas: string[];
precioCoste: number;
}
interface CambiosProducto {
nombre?: string;
precio?: number;
categoria?: Categoria;
etiquetas?: string[];
precioCoste?: number;
}
interface ProductoPublico {
id: number;
nombre: string;
precio: number;
categoria: Categoria;
etiquetas: string[];
}
Son unas 20 líneas de copias para decir una sola cosa. Cualquier cambio en Producto te obliga a acordarte de tres sitios más, y nada te avisa si fallas en uno. Lo que queremos es decirle a TypeScript "NuevoProducto es Producto sin el id" y que el resto lo calcule él.
Para eso existen los utility types (tipos de utilidad). Son tipos que ya vienen incluidos en TypeScript y que reciben otro tipo como entrada y devuelven uno nuevo, igual que una función recibe un valor y devuelve otro. Se escriben con ángulos, como los genéricos que ya conoces, porque por dentro son exactamente eso. Vamos a ver los cinco que más vas a usar.
Partial: el formulario donde solo rellenas lo que cambia
Piensa en el formulario en papel para cambiar tus datos en el banco. Tiene todos los campos, pero solo rellenas el que cambia (el teléfono, por ejemplo) y dejas el resto en blanco. El banco entiende que lo que no has tocado se queda como estaba.
Eso es justo lo que necesita el formulario de editar un producto, y se escribe con Partial, que convierte todos los campos de un tipo en opcionales:
type CambiosProducto = Partial<Producto>;
const subirPrecio: CambiosProducto = { precio: 24.9 };
const soloNombre: CambiosProducto = { nombre: "Camiseta básica" };
const nada: CambiosProducto = {};
La interfaz CambiosProducto de 7 líneas se queda en una. Si mañana añades descuento a Producto, aparece solo en CambiosProducto sin que toques nada.
Ahora la función que aplica los cambios. Con el operador de propagación (...) mezclas el producto actual con lo que llega:
function actualizar(actual: Producto, cambios: Partial<Producto>): Producto {
return { ...actual, ...cambios };
}
Compila, funciona con el ejemplo de arriba y parece perfecta. Aquí es donde la mayoría se atasca, porque tiene un agujero que me costó pillar. Prueba a llamarla así:
const camiseta: Producto = {
id: 1, nombre: "Camiseta", precio: 19.9, categoria: "ropa",
etiquetas: ["algodón"], precioCoste: 6,
};
const editada = actualizar(camiseta, { precio: undefined });
console.log(editada.precio.toFixed(2));
TypeScript no se queja, porque un campo opcional acepta undefined. Pero en ejecución el undefined pisa el precio real, y el tipo te miente: dice que editada.precio es un número cuando no lo es.
TypeError: Cannot read properties of undefined (reading 'toFixed')
Esto pasa en la vida real cuando un formulario envía undefined en un campo que el usuario no ha tocado. La solución es una opción del compilador. En tu tsconfig.json, dentro de compilerOptions, añade esto:
"exactOptionalPropertyTypes": true
Con ella activada, "opcional" significa "puede faltar", no "puede valer undefined", y la llamada de antes deja de compilar:
error TS2379: Argument of type '{ precio: undefined; }' is not assignable to parameter of type 'Partial<Producto>' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties.
Types of property 'precio' are incompatible.
Type 'undefined' is not assignable to type 'number'.
No viene activada ni con strict, hay que pedirla aparte. Te recomiendo encenderla desde el principio en proyectos nuevos: activarla después en uno grande da bastante más guerra.
Omit y Pick: tapar campos o quedarte solo con algunos
Imagina que fotocopias una ficha de producto para dársela a un cliente. Hay dos formas de que no vea el precio de coste: tapar esa línea con un papel antes de fotocopiar, o recortar solo las líneas que quieres enseñar y pegarlas en una hoja nueva.
La primera es Omit (omitir) y la segunda es Pick (escoger). Los dos reciben el tipo original y la lista de campos, separados por | si son varios:
type NuevoProducto = Omit<Producto, "id">;
type ProductoPublico = Omit<Producto, "precioCoste">;
type ResumenProducto = Pick<Producto, "id" | "nombre" | "precio">;
Mi regla para elegir es sencilla: si quieres casi todos los campos y descartar uno o dos, Omit; si quieres solo uno o dos, Pick. Y Pick tiene un uso muy práctico que mucha gente no ve: tipar los parámetros de una función con lo mínimo que necesita. Esta función solo mira el precio y la categoría, así que no hace falta exigirle un producto entero:
const IVA = 0.21;
function precioConIva(p: Pick<Producto, "precio">): number {
return Math.round(p.precio * (1 + IVA) * 100) / 100;
}
console.log(precioConIva({ precio: 24.9 })); // 30.13
Puedes llamarla con un producto completo, con un ResumenProducto o con un objeto suelto que tenga el precio. Los 24,90 € con el 21% de IVA salen a 30,13 €.
Y ahora el error que a mí me tuvo un rato buscando. Omit no comprueba que el campo que le pides quitar exista. Si escribes mal el nombre, TypeScript no dice nada y no quita nada:
type PublicoMal = Omit<Producto, "preciocoste">; // la c va en mayúscula
const filtrado: PublicoMal = {
id: 1, nombre: "Camiseta", precio: 19.9, categoria: "ropa",
etiquetas: [], precioCoste: 6, // compila: el precio de coste sigue ahí
};
El tipo que debía esconder el precio de coste lo sigue exigiendo, y encima tu API lo enviaría al navegador. En un tutorial es un detalle; en una tienda real es filtrar tus márgenes a la competencia. Pick sí valida los nombres. Si te equivocas con él, el compilador lo dice y hasta te sugiere la corrección:
error TS2344: Type '"id" | "precioo"' does not satisfy the constraint 'keyof Producto'.
Type '"precioo"' is not assignable to type 'keyof Producto'. Did you mean '"precio"'?
❌ Error común:
Dar por hecho que Omit te protege de erratas. No lo hace, y el fallo es silencioso. Cuando uses Omit para ocultar datos sensibles, prueba con un objeto de ejemplo que incluya el campo y comprueba que el compilador ya no lo acepta. Y si el campo es realmente secreto, no confíes solo en el tipo: construye el objeto público a mano, como verás en el programa final, porque los tipos desaparecen al ejecutar.
Readonly: el catálogo que nadie debe tocar
En una tienda hay datos que se leen mucho y no se modifican por el camino: la tabla de precios de la temporada, la lista de categorías, la configuración. Si una función los cambia sin querer, el fallo aparece en otra parte del programa y cuesta rastrearlo. Readonly convierte todos los campos en solo lectura:
const fijo: Readonly<Producto> = {
id: 1, nombre: "Camiseta", precio: 19.9, categoria: "ropa",
etiquetas: ["algodón"], precioCoste: 6,
};
fijo.precio = 5;
error TS2540: Cannot assign to 'precio' because it is a read-only property.
Hasta aquí bien. Pero Readonly solo protege el primer nivel, y esto sí compila sin avisar:
fijo.etiquetas.push("oferta"); // compila, y modifica el producto
El campo etiquetas no se puede reasignar, pero la lista que contiene sí se puede cambiar. Si necesitas protegerla también, el tipo de ese campo tiene que ser readonly string[]. Es una de esas cosas que parece obvia después de que te muerda una vez.
Record: una tabla con las claves obligatorias
Ahora imagina que cada categoría tiene su propio tipo de IVA. En España casi todo lo que vende una tienda de ropa va al 21%, pero seguro que quieres tener la tabla preparada por si algún día una categoría cambia. Un objeto donde las claves son las categorías y los valores son números se tipa con Record (registro):
const IVA_POR_CATEGORIA: Record<Categoria, number> = {
ropa: 0.21,
calzado: 0.21,
accesorios: 0.21,
};
Lo bueno viene de combinarlo con el tipo Categoria, que es un union type como los de el post anterior. Si olvidas una clave, el compilador te la reclama:
const IVA_INCOMPLETO: Record<Categoria, number> = {
ropa: 0.21,
calzado: 0.21,
};
error TS2741: Property 'accesorios' is missing in type '{ ropa: number; calzado: number; }' but required in type 'Record<Categoria, number>'.
Y mejor todavía: el día que añadas "hogar" a Categoria, todos los Record<Categoria, ...> de tu proyecto dejarán de compilar hasta que decidas qué IVA le toca a esa categoría. Es el compilador haciendo de lista de tareas.
Hay una variante que verás mucho, Record<string, number>, donde las claves pueden ser cualquier texto. Es cómoda, pero pierdes justo esa comprobación: cualquier errata en la clave compila y el resultado de leer una clave que no existe parece un número cuando es undefined. Úsala solo cuando de verdad las claves no se conocen de antemano.
Juntarlo todo: un catálogo con un único tipo base
Los utility types se pueden anidar, y ahí es donde se nota el ahorro. Vamos a montar un catálogo pequeño donde Producto es la única interfaz escrita a mano, y todo lo demás sale de ella. Las ediciones aceptan cualquier campo menos el id, que no debe cambiar nunca: eso es Partial<Omit<Producto, "id">>.
type Categoria = "ropa" | "calzado" | "accesorios";
interface Producto {
id: number;
nombre: string;
precio: number;
categoria: Categoria;
etiquetas: string[];
precioCoste: number;
}
type NuevoProducto = Omit<Producto, "id">;
type CambiosProducto = Partial<NuevoProducto>;
type ProductoPublico = Omit<Producto, "precioCoste">;
const IVA: Record<Categoria, number> = {
ropa: 0.21,
calzado: 0.21,
accesorios: 0.21,
};
const catalogo: Producto[] = [];
let siguienteId = 1;
function crearProducto(datos: NuevoProducto): Producto {
const producto: Producto = { id: siguienteId++, ...datos };
catalogo.push(producto);
return producto;
}
function actualizarProducto(id: number, cambios: CambiosProducto): Producto {
const indice = catalogo.findIndex((p) => p.id === id);
if (indice === -1) {
throw new Error(`No existe el producto ${id}`);
}
const nuevo: Producto = { ...catalogo[indice], ...cambios };
catalogo[indice] = nuevo;
return nuevo;
}
function aPublico(producto: Producto): ProductoPublico {
const { precioCoste, ...publico } = producto;
return publico;
}
function precioConIva(p: Pick<Producto, "precio" | "categoria">): number {
return Math.round(p.precio * (1 + IVA[p.categoria]) * 100) / 100;
}
const camiseta = crearProducto({
nombre: "Camiseta", precio: 19.9, categoria: "ropa",
etiquetas: ["algodón"], precioCoste: 6,
});
actualizarProducto(camiseta.id, { precio: 24.9 });
const vista = aPublico(catalogo[0]);
console.log(vista);
console.log(precioConIva(vista), "€");
Si lo compilas con npx tsc y lo ejecutas con node catalogo.js, tienes esta salida:
{
id: 1,
nombre: 'Camiseta',
precio: 24.9,
categoria: 'ropa',
etiquetas: [ 'algodón' ]
}
30.13 €
Fíjate en una cosa: aPublico construye el objeto sin precioCoste de verdad, con desestructuración, y no se fía solo del tipo ProductoPublico, porque el tipo desaparece al compilar y el dato se enviaría igual.
Prueba ahora a añadir descuento: number a Producto y vuelve a compilar. Los errores aparecerán solo en los sitios donde falte ese dato (la llamada a crearProducto), y CambiosProducto, ProductoPublico y el resto se enteran sin que toques una línea. Es exactamente lo que no pasaba con las copias.
Cuándo no usar utility types
Con esto pasa como con los genéricos: cuando los descubres quieres aplicarlos a todo. Hay dos situaciones donde yo prefiero escribir la interfaz a mano.
La primera es cuando los tipos son parecidos hoy pero van a evolucionar por razones distintas. Si el tipo de la base de datos y el de la respuesta de tu API empiezan siendo iguales, derivar uno del otro los ata para siempre, y el día que la API necesite un campo calculado tendrás que desatarlos con dolor. Derivar tiene sentido cuando uno es realmente "el mismo con retoques".
La segunda es la legibilidad. Un Partial<Omit<Pick<...>>> de tres niveles ya cuesta leerlo, y quien venga después (tú dentro de dos meses, por ejemplo) no sabrá qué campos tiene. Ponle un nombre con type, como en el catálogo de arriba, y deja el cursor encima en tu editor para ver el tipo resultante. Si hasta eso te cuesta, escribe la interfaz entera.
Y una advertencia que ya salió en el post de genéricos: todo esto existe solo mientras compilas. Un utility type no valida lo que llega de un formulario o de una API, por mucho que el tipo diga que falta el id. Si un asistente de IA te genera una cadena de tipos anidados, pídele que te explique qué hace cada capa y compruébalo tú con el cursor encima; si no la entiendes, no la dejes en el proyecto.
Siguiente paso: borra una copia
Abre un proyecto tuyo, aunque sea pequeño, y busca dos interfaces que se parezcan mucho. Elige la más completa como base y reescribe la otra con Omit, Pick o Partial. Luego ejecuta npx tsc --noEmit para comprobar que todo sigue compilando.
Después añade un campo nuevo a la interfaz base y mira qué pasa con la derivada. Con esto ya puedes mantener un único tipo del que salen los demás, y cambiar un campo en un solo sitio.
Qué aprender ahora
Ya tienes un NuevoProducto bien tipado. El siguiente paso lógico es enviarlo a un servidor desde un formulario, y ahí es donde TypeScript y los datos de fuera tienen que ponerse de acuerdo.