TypeScript Tipos mapeados

Los tipos mapeados (Mapped Types) son una potente característica de TypeScript para crear nuevos tipos basados en tipos existentes.

Permiten a los desarrolladores modificar propiedades en lote, como hacer todas las propiedades opcionales, hacer todas las propiedades de solo lectura, etc.

Los tipos mapeados son la tecnología central para implementar los tipos de utilidad incorporados en TypeScript.


Diagrama SVG: principio de funcionamiento de los tipos mapeados Fondo Título Principio de funcionamiento de los tipos mapeados Tipo original Tipo original interface User { id: number; name: string; } Flecha Sintaxis de mapeo Sintaxis de mapeo { [P in keyof T]?: T[P] // Agregar el modificador opcional } Flecha Tipo resultante Tipo resultante type PartialUser = { id?: number; name?: string; } Parte inferior: explicación de los modificadores Modificadores de tipos mapeados Explicación de los modificadores Prefijo ? Añade el modificador opcional type Partial<T> Prefijo readonly Añade el modificador de solo lectura type Readonly<T> Prefijo -? Elimina el modificador opcional type Required<T> Palabra clave as Reasignar nombres de clave as `${P}` Indicador de flecha

¿Por qué se necesitan los tipos mapeados?

En el desarrollo real de TypeScript, a menudo necesitamos crear variantes basadas en tipos existentes.

Por ejemplo, necesitamos una versión donde todas las propiedades sean opcionales, o una versión donde todas las propiedades sean de solo lectura.

La forma tradicional es definir estos tipos manualmente, lo cual resulta tedioso y propenso a errores.

Los tipos mapeados ofrecen una forma declarativa de generar automáticamente estas variantes de tipos.

Explicación del concepto:Los tipos mapeados usankeyofyinla palabra clave para iterar sobre todas las claves del tipo existente y luego aplicar la misma conversión de tipo a cada clave.


Tipos mapeados básicos

Los tipos mapeados básicos crean nuevos tipos recorriendo todas las claves del tipo original.

Esta es la base para implementar tipos de utilidad como Partial, Readonly, etc.

Ejemplo

// Definir interfaz de usuario
interface User {
    // ID de usuario
    id: number;
    // Nombre de usuario
    name: string;
    // Correo electrónico del usuario
    email: string;
}

// Implementar el tipo de utilidad Partial
// Recorrer todas las claves de T, agregar el modificador opcional ?
type Partial<T> = {
    // P recorre todas las claves devueltas por keyof T
    // T[P] obtiene el tipo de valor de la clave correspondiente en el tipo original
    [P in keyof T]?: T[P];
};

// Usar el tipo Partial
type PartialUser = Partial<User>;

// El tipo PartialUser es equivalente a:
// { id?: number; name?: string; email?: string }

// Se pueden proporcionar solo algunas propiedades
var user: PartialUser = { name: "Alice" };

console.log(Usuario parcial: + JSON.stringify(user));

Resultado de la ejecución:

部分用户: {"name":"Alice"}

Explicación de sintaxis:[P in keyof T]Representa recorrer todas las claves del tipo T.?El modificador hace que la propiedad sea opcional.


Modificadores de propiedad

Los tipos mapeados admiten varios modificadores de propiedad para modificar las características de las propiedades.

Estos modificadores pueden combinarse para satisfacer diferentes necesidades de transformación de tipos.

Ejemplo

// Definir interfaz de usuario
interface User {
    // Nombre de usuario
    name: string;
    // Edad del usuario
    age: number;
}

// Usar mapeo readonly: convertir todas las propiedades en solo lectura
// Agregar el modificador readonly
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

// Usar mapeo opcional: convertir todas las propiedades en opcionales (versión básica)
type Optional<T> = {
    [P in keyof T]?: T[P];
};

// Usar mapeo -?: eliminar el modificador opcional (convertir en obligatorio)
-? elimina el modificador ? original.
type Required<T> = {
    [P in keyof T]-?: T[P];
};

// Probar el tipo de solo lectura
var readonlyUser: Readonly<User> = { name: "Alice", age: 25 };
// readonlyUser.age = 30; // Error: la propiedad de solo lectura no se puede modificar

// Probar tipo opcional
var optionalUser: Optional<User> = { name: "Bob" };

console.log("Solo lectura: " + JSON.stringify(readonlyUser));
console.log("Opcional: " + JSON.stringify(optionalUser));

Resultado de la ejecución:

只读: {"name":"Alice","age":25}
可选: {"name":"Bob"}

Explicación de los modificadores:?Añade opcional,-?elimina opcional;readonlyañade solo lectura,-readonlyelimina solo lectura.


Mapeo de nombres de clave

Los tipos mapeados también pueden usarasla palabra clave para reasignar los nombres de clave.

Esto es muy útil cuando se necesita modificar uniformemente el formato de los nombres de clave.

Ejemplo

// Definir interfaz de usuario
interface User {
    // ID de usuario
    id: number;
    // Nombre de usuario
    name: string;
    // Edad del usuario
    age: number;
}

// Usar la palabra clave as para reasignar los nombres de las claves
// Añadir un prefijo a todas las claves
type WithPrefix<T, Prefix extends string> = {
    // Usar tipos de literales de plantilla para renombrar claves
    // Capitalize convierte la primera letra en mayúscula
    [P in keyof T as `${Prefix}${Capitalize<string & P>}`]: T[P];
};

// Usar WithPrefix para añadir el prefijo "user"
type PrefixedUser = WithPrefix<User, "user">;

// El tipo convertido:
// { userId: number; userName: string; userAge: number }

// Usar el tipo con prefijo
var user: PrefixedUser = { userId: 1, userName: "Alice", userAge: 25 };

console.log("Con prefijo: " + JSON.stringify(user));

Resultado de la ejecución:

带前缀: {"userId":1,"userName":"Alice","userAge":25}

Tipos de plantilla literal:Usando`${Prefix}${Capitalize}`se pueden generar dinámicamente nuevos nombres de clave.


Filtrado de claves

Mediante la combinación de tipos condicionales y tipos mapeados, se puede implementar el filtrado de claves.

Esto es muy útil al implementar tipos de utilidad como Omit.

Ejemplo

// Definir interfaz de usuario
interface User {
    // ID de usuario
    id: number;
    // Nombre de usuario
    name: string;
    // Contraseña del usuario
    password: string;
    // Correo electrónico del usuario
    email: string;
}

// Implementar Omit: excluir las claves especificadas
// Usar tipos condicionales para filtrar claves
type Omit<T, K extends keyof T> = {
    // P recorre todas las claves de T
    // Si P es asignable a K (es decir, está en la lista de exclusión), devuelve never (no incluir)
    // De lo contrario, devuelve P (conserva la clave)
    [P in keyof T as P extends K ? never : P]: T[P];
};

// Usar Omit para excluir la clave password
type UserWithoutPassword = Omit<User, "password">;

// El tipo convertido:
// { id: number; name: string; email: string }

// Usar el tipo después de excluir password
var user: UserWithoutPassword = { id: 1, name: "Alice", email: "a@b.com" };

console.log("Sin contraseña: " + JSON.stringify(user));

Resultado de la ejecución:

无密码: {"id":1,"name":"Alice","email":"a@b.com"}

El tipo never:En los tipos mapeados, usar never como tipo de propiedad elimina esa propiedad por completo.


Mapeo condicional

Los tipos mapeados se pueden combinar con tipos condicionales para aplicar diferentes transformaciones según el tipo de la propiedad.

Esto hace que la transformación de tipos sea más flexible e inteligente.

Ejemplo

// Definir la interfaz de respuesta de API
interface APIResponse {
    // Datos de respuesta
    data: string;
    // Mensaje de error
    error: string;
    // Si está cargando
    isLoading: boolean;
    // Marca de tiempo
    timestamp: number;
}

// Convertir el tipo de función a () => void
// Recorre todas las propiedades y aplica una conversión condicional según el tipo de propiedad
type FunctionToVoid<T> = {
    // Si T[P] es un tipo de función, conviértelo en () => void
    // De lo contrario, conserva el tipo original
    [P in keyof T]: T[P] extends (...args: any[]) => any
        ? () => void
        : T[P];
};

// Usa el mapeo condicional
var response: FunctionToVoid<APIResponse> = {
    data: "hello",
    error: "",
    isLoading: false,
    timestamp: Date.now()
};

console.log("Respuesta: " + JSON.stringify(response));

Resultado de la ejecución:

响应: {"data":"hello","error":"","isLoading":false,"timestamp":...}

Casos de uso:El mapeo condicional se usa a menudo en escenarios como el manejo de respuestas de API, la limpieza de objetos de configuración, etc., donde se requiere un procesamiento diferente según el tipo.


Tipos mapeados incorporados

TypeScript incluye muchos tipos de utilidad implementados mediante tipos mapeados.

Estos tipos de utilidad satisfacen la mayoría de las necesidades del desarrollo diario.

Ejemplo

// Partial: hace que todas las propiedades sean opcionales
type P1 = Partial<{ a: string; b: number }>;
// Resultado: { a?: string; b?: number }

// Required: convierte todas las propiedades opcionales en requeridas
type R1 = Required<{ a?: string; b?: number }>;
// Resultado: { a: string; b: number }

// Readonly: convierte todas las propiedades en solo lectura
type RO1 = Readonly<{ a: string; b: number }>;
// Resultado: { readonly a: string; readonly b: number }

// Pick - selecciona las propiedades especificadas
type PK = Pick<{ a: string; b: number; c: boolean }, "a" | "b">;
// Resultado: { a: string; b: number }

// Omit - excluye las propiedades especificadas
type OM = Omit<{ a: string; b: number; c: boolean }, "c">;
// Resultado: { a: string; b: number }

// Probar Partial
console.log("Partial: " + JSON.stringify({} as P1));

// Probar Pick
console.log("Pick: " + JSON.stringify({ a: "x" } as PK));

Combinación de tipos de utilidad:Estos tipos de utilidad integrados se implementan basándose en tipos mapeados y tipos condicionales. Comprender su principio permite utilizarlos mejor.


Notas

  • La palabra clave keyof:Se utiliza para obtener el tipo de unión formado por todas las claves de un tipo.
  • La palabra clave in:Se utiliza para iterar sobre el tipo de unión de nombres de clave.
  • Posición de los modificadores:?yreadonlyAntes del nombre de la propiedad, indica agregar un modificador.
  • El modificador de signo menos:-?y-readonlySe utiliza para eliminar modificadores.
  • La palabra clave as:Se utiliza para reasignar nombres de clave; debe devolver un tipo literal de cadena o número.

Avanzado:Los tipos mapeados pueden combinarse con tipos condicionales y tipos de literales de plantilla para lograr conversiones de tipos complejas.


Resumen

Los tipos mapeados son una de las características más potentes del sistema de tipos de TypeScript.

  • keyof:Obtener todas las claves de un tipo.
  • in:Iterar sobre los nombres de clave para realizar el mapeo.
  • ?:Agregar el modificador opcional.
  • readonly:Agregar el modificador de solo lectura.
  • -?:Eliminar el modificador opcional.
  • as:Reasignar nombres de clave.

Mejores prácticas:El buen uso de los tipos mapeados puede reducir en gran medida las definiciones de tipos repetidas y mejorar la mantenibilidad del código.


Otras extensiones