Introducción a los tipos mapeados de TypeScript

Los tipos mapeados en TypeScript proporcionan una forma de crear nuevos tipos mediante la transformación de los existentes. Son una herramienta poderosa para manejar operaciones de tipos complejas y garantizar la seguridad de los tipos en aplicaciones TypeScript. Este artículo presenta los tipos mapeados, explica su sintaxis y proporciona ejemplos para demostrar su uso.

¿Qué son los tipos mapeados?

Los tipos mapeados permiten la creación de nuevos tipos mediante la aplicación de una transformación a cada propiedad de un tipo existente. Suelen utilizarse para modificar o ampliar tipos de forma flexible. La sintaxis básica de un tipo mapeado es:

type MappedType = {
  [K in keyof T]: NewType;
};

En esta sintaxis:

• T es el tipo original.
• K representa cada tecla en T.
• NewType es el nuevo tipo asignado a cada propiedad.

Ejemplo básico de tipos mapeados

A continuación se muestra un ejemplo simple de un tipo mapeado que convierte todas las propiedades de un tipo dado en de solo lectura:

type ReadOnly = {
  readonly [K in keyof T]: T[K];
};

type User = {
  name: string;
  age: number;
};

type ReadOnlyUser = ReadOnly;

En este ejemplo, el tipo mapeado ReadOnly transforma todas las propiedades del tipo User para que sean de solo lectura, lo que da como resultado un nuevo tipo ReadOnlyUser donde todas las propiedades son inmutables.

Tipos mapeados con transformaciones de tipos

Los tipos mapeados también se pueden utilizar para transformar tipos de formas más complejas. Por ejemplo, un tipo mapeado que hace que todas las propiedades sean opcionales:

type Partial = {
  [K in keyof T]?: T[K];
};

type User = {
  name: string;
  age: number;
};

type PartialUser = Partial;

En este ejemplo, el tipo mapeado Partial hace que todas las propiedades del tipo User sean opcionales, lo que da como resultado un nuevo tipo PartialUser donde cada propiedad es opcional.

Uso de tipos mapeados con tipos condicionales

Los tipos mapeados se pueden combinar con tipos condicionales para realizar operaciones de tipo más sofisticadas. Por ejemplo, crear un tipo que solo incluya propiedades de un tipo determinado:

type OnlyStrings = {
  [K in keyof T]: T[K] extends string ? T[K] : never;
};

type User = {
  name: string;
  age: number;
  email: string;
};

type StringProperties = OnlyStrings;

En este ejemplo, el tipo mapeado OnlyStrings filtra las propiedades que no son del tipo string, lo que genera un nuevo tipo StringProperties que incluye solo propiedades de cadena del tipo User.

Tipos de mapas avanzados

Los casos de uso avanzados para los tipos asignados incluyen la creación de tipos que modifican los tipos existentes en función de diversas condiciones. Por ejemplo, un tipo asignado que agrega un sufijo a cada nombre de propiedad:

type WithSuffix<T, S extends string> = {
  [K in keyof T as `${string & K}${S}`]: T[K];
};

type User = {
  name: string;
  age: number;
};

type UserWithSuffix = WithSuffix<User, "Prop">;

En este ejemplo, el tipo mapeado WithSuffix agrega un sufijo a cada nombre de propiedad del tipo User, lo que da como resultado un nuevo tipo UserWithSuffix donde los nombres de propiedad tienen el sufijo especificado.

Conclusión

Los tipos mapeados en TypeScript son una característica versátil que permite a los desarrolladores crear nuevos tipos mediante la transformación de los existentes. Al comprender y utilizar los tipos mapeados, los desarrolladores pueden gestionar transformaciones de tipos complejas y garantizar una mayor seguridad de tipos en su código TypeScript. Los tipos mapeados ofrecen potentes capacidades para mejorar y personalizar las definiciones de tipos en aplicaciones TypeScript.