Utility types en TypeScript: la lista completa con ejemplos

Los utility types son tipos genéricos integrados en TypeScript que convierten un tipo en otro. En lugar de escribir un segundo tipo User con todos los campos opcionales, escribes Partial<User>; en lugar de copiar tres campos, Pick<User, "id" | "name">. Son globales, así que no hace falta importarlos.

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
}

type UserPatch = Partial<User>;                 // every field optional
type UserCard = Pick<User, "id" | "name">;      // only id and name
type PublicUser = Omit<User, "password">;       // everything but password
type UsersById = Record<number, PublicUser>;    // an object keyed by id

const patch: UserPatch = { email: "new@example.com" };
const card: UserCard = { id: 1, name: "Ada" };
const users: UsersById = {
  1: { id: 1, name: "Ada", email: "ada@example.com" },
};

console.log(patch, card, users[1].email);
// { email: 'new@example.com' } { id: 1, name: 'Ada' } ada@example.com

Cuando User cambia, los cuatro tipos derivados lo siguen. La librería estándar de TypeScript (lib.es5.d.ts) declara 22 utility types. Las secciones siguientes los recogen todos, agrupados según el tipo de tipo con el que trabajan, con un enlace a la página detallada cuando la hay.

Tipos objeto: Partial, Required, Readonly, Pick, Omit, Record

interface Config {
  host: string;
  port?: number;
  debug?: boolean;
}

const defaults: Required<Omit<Config, "host">> = { port: 8080, debug: false };

function withDefaults(config: Config): Readonly<Required<Config>> {
  return { ...defaults, ...config };
}

const cfg = withDefaults({ host: "localhost", debug: true });
console.log(cfg); // { port: 8080, debug: true, host: 'localhost' }
// cfg.port = 1 would be error TS2540: Cannot assign to 'port' because it is a read-only property.

Required<T> es lo contrario de Partial<T>; la página de Partial trata los dos, incluido el undefined explícito que deja pasar un spread como este.

Tipos unión: Exclude, Extract, NonNullable

type Status = "draft" | "review" | "published" | "archived";

type Live = Exclude<Status, "draft" | "archived">; // "review" | "published"
type Mixed = string | number | (() => void);
type Callable = Extract<Mixed, (...args: never[]) => unknown>; // () => void

function lookup(id: number): string | undefined {
  return id === 1 ? "Ada" : undefined;
}
type Found = NonNullable<ReturnType<typeof lookup>>; // string

const s: Live = "review";
const run: Callable = () => console.log("called");
const found: Found = lookup(1) ?? "nobody";
run();
console.log(s, found); // review Ada

Estos tres trabajan sobre uniones, no sobre objetos. Esa es la diferencia clave con Pick y Omit, que reciben un tipo objeto y una lista de sus claves.

Tipos de funciones y clases: Parameters, ReturnType y más

function createOrder(customer: string, items: string[], express = false) {
  return { customer, items, express, total: items.length * 10 };
}

type OrderArgs = Parameters<typeof createOrder>; // [customer: string, items: string[], express?: boolean | undefined]
type Order = ReturnType<typeof createOrder>;     // { customer: string; items: string[]; express: boolean; total: number }

const args: OrderArgs = ["Ada", ["book", "pen"]];
const order: Order = createOrder(...args);
console.log(order.total, order.express); // 20 false

class Point {
  constructor(public x: number, public y: number) {}
}
const coords: ConstructorParameters<typeof Point> = [3, 4];
const p: InstanceType<typeof Point> = new Point(...coords);
console.log(p); // Point { x: 3, y: 4 }

typeof createOrder hace falta porque estos utility types reciben un tipo, y createOrder es un valor. Con las clases pasa lo mismo: typeof Point es el tipo del constructor, mientras que Point a secas como tipo ya significa el tipo de la instancia.

NoInfer controla de dónde saca su tipo un genérico:

function pickColor<C extends string>(colors: C[], fallback: NoInfer<C>): C {
  return colors[0] ?? fallback;
}

console.log(pickColor(["red", "green"], "green")); // red
// @ts-expect-error: "blue" is not "red" | "green"
pickColor(["red", "green"], "blue");

Sin NoInfer, TypeScript inferiría C a partir de los dos argumentos y lo ampliaría a "red" | "green" | "blue", así que aceptaría la errata del valor por defecto.

Tipos de strings: Uppercase, Lowercase, Capitalize, Uncapitalize

Estos cuatro están integrados en el compilador en lugar de estar escritos en TypeScript, y son más útiles dentro de los template literal types, como `on${Capitalize<E>}` para nombres de handlers de eventos.

Promesas: Awaited

async function fetchUser(id: number) {
  return { id, name: "Ada" };
}

type Pending = ReturnType<typeof fetchUser>;           // Promise<{ id: number; name: string }>
type User = Awaited<ReturnType<typeof fetchUser>>;      // { id: number; name: string }

async function main() {
  const user: User = await fetchUser(1);
  const all: User[] = await Promise.all([fetchUser(2), fetchUser(3)]);
  console.log(user.name, all.map((u) => u.id)); // Ada [ 2, 3 ]
}
main();

Awaited<ReturnType<typeof fn>> es la forma estándar de nombrar el tipo del resultado de una función async sin declararlo aparte.

Combinar utility types

Los utility types se anidan. Algunas combinaciones aparecen tan a menudo que vale la pena sabérselas de memoria:

interface Post {
  id: number;
  title: string;
  body: string;
  tags: string[];
}

// Create: everything except the server-generated id
type NewPost = Omit<Post, "id">;
// Update: id required, everything else optional
type PostUpdate = Pick<Post, "id"> & Partial<Omit<Post, "id">>;
// A lookup table of read-only summaries
type PostIndex = Record<number, Readonly<Pick<Post, "id" | "title">>>;

const created: NewPost = { title: "Hello", body: "...", tags: [] };
const update: PostUpdate = { id: 1, title: "Hello again" };
const index: PostIndex = { 2: { id: 2, title: "Idea" } };
console.log(created.title, update, index[2]);
// Hello { id: 1, title: 'Hello again' } { id: 2, title: 'Idea' }

Un utility type anidado se lee de dentro hacia fuera: Readonly<Pick<Post, "id" | "title">> primero conserva dos propiedades y luego las hace de solo lectura. Con las mismas piezas se construye un helper PartialBy que hace opcionales solo algunas claves; la página de Partial lo desarrolla.

Los utility types no hacen nada en ejecución

Todos los utility types se borran al compilar. Un valor tipado como Omit<User, "password"> puede seguir llevando una contraseña en ejecución si el objeto del que salió la tenía:

interface User {
  name: string;
  password: string;
}

const full: User = { name: "Ada", password: "hunter2" };

const leaky: Omit<User, "password"> = full; // allowed: extra properties are fine
console.log(JSON.stringify(leaky)); // {"name":"Ada","password":"hunter2"}

const { password, ...safe } = full;          // this actually removes it
console.log(JSON.stringify(safe));  // {"name":"Ada"}

El tipo solo limita lo que tu código puede leer. Para quitar un campo de los datos, sácalo con una desestructuración como en las últimas líneas, y para impedir modificaciones en ejecución usa Object.freeze, no Readonly. Los tipos integrados son mapped types y conditional types de una línea, así que con las mismas herramientas puedes escribir los tuyos.