Tipos de índice de TypeScript y la palabra clave keyof

Los tipos de índice y keyof son herramientas potentes de TypeScript para manipular tipos de objetos.

Nos permiten acceder dinámicamente a las propiedades de los objetos y crear mapeos de tipos flexibles.


Diagrama SVG: Cómo funcionan los tipos de índice y keyof Fondo Título Cómo funcionan los tipos de índice y keyof Operador keyof Operador keyof type Keys = keyof User // "id" | "name" | "email" Flecha Tipos de acceso por índice Tipos de acceso por índice type Value = User["name"] // string Flecha Tipos mapeados Tipos mapeados type Partial<T> {[P in keyof T]?: T[P]} Parte inferior: Casos de uso Casos de uso de los tipos de índice Escenario 1 Acceso dinámico a propiedades Escenario 2 Operaciones de objetos con seguridad de tipos Escenario 3 Creación de tipos utilitarios genéricos Marcador de flecha

¿Por qué se necesitan los tipos de índice?

En JavaScript, a menudo necesitamos acceder dinámicamente a las propiedades de los objetos.

Por ejemplo, una función puede necesitar obtener todas las claves de un objeto, o acceder al tipo de valor correspondiente según la clave.

Los tipos de índice y keyof nos permiten expresar esta dinamicidad en el sistema de tipos, manteniendo al mismo tiempo la seguridad de tipos.

Concepto:Los tipos de índice son una clase de tipos que permiten acceder dinámicamente a las propiedades de los objetos; keyof se utiliza para obtener el tipo unión formado por todas las claves de un tipo de objeto.


Operador keyof

El operador keyof se utiliza para obtener el tipo unión formado por todas las claves de un tipo de objeto.

Ejemplo

// Definir el tipo de usuario
interface User {
    id: number;       // ID de usuario
    name: string;     // Nombre de usuario
    email: string;    // Correo electrónico
    age?: number;     // Edad (opcional)
}

// Usar keyof para obtener el tipo unión de todas las claves
// Resultado: "id" | "name" | "email" | "age"
type UserKeys = keyof User;

// Probar keyof
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user: User = {
    id: 1,
    name: "Alice",
    email: "alice@example.com"
};

// Obtener la propiedad name
const userName: string = getProperty(user, "name");
console.log("Nombre de usuario: " + userName);

Resultado de la ejecución:

用户名: Alice

Explicación:keyof devuelve el tipo unión literal de los nombres de las claves, no el tipo string.


Tipos de acceso por índice

Usando el tipo de acceso por índice (Index Access Type) se puede obtener el tipo de una propiedad de un objeto.

Ejemplo

// Definir el tipo de usuario
interface User {
    id: number;
    name: string;
    email: string;
}

// Usar el tipo de acceso por índice para obtener el tipo de la propiedad
type UserId = User["id"];      // number
type UserName = User["name"];  // string

// Se puede usar un tipo unión para acceder a múltiples claves
type UserIdAndName = User["id" | "name"];  // number | string

// Usar keyof para obtener la unión de todos los tipos de propiedades
type AllUserValues = User[keyof User];  // number | string

// Ejemplo de uso práctico
function getValue<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user: User = { id: 1, name: "Bob", email: "bob@test.com" };

// Obtener el tipo de id
const idValue: number = getValue(user, "id");
console.log("ID: " + idValue);

// Obtener el tipo de name
const nameValue: string = getValue(user, "name");
console.log("Name: " + nameValue);

Acceso por índice:Usando corchetes [] se puede acceder al tipo específico de una propiedad de un tipo de objeto, es muy potente y flexible.


Fundamentos de los tipos mapeados

Los tipos mapeados permiten crear nuevos tipos basados en tipos existentes, recorriendo todas sus claves.

Ejemplo

// Definir el tipo de usuario
interface User {
    id: number;
    name: string;
    email: string;
    age: number;
}

// Convertir todas las propiedades en opcionales
type PartialUser = Partial<User>;

// Convertir todas las propiedades en de solo lectura
type ReadonlyUser = Readonly<User>;

// Tipo mapeado personalizado: convertir todas las propiedades en opcionales y a tipo string
type Stringify<T> = {
    [P in keyof T]: string;
};

type StringifiedUser = Stringify<User>;

// Ejemplo de uso práctico
const partialUser: PartialUser = {
    id: 1,
    name: "Alice"
    // email y age son opcionales
};

const readonlyUser: ReadonlyUser = {
    id: 1,
    name: "Bob",
    email: "bob@test.com",
    age: 25
};
// readonlyUser.name = "Charlie"; // Error: solo lectura

console.log("Usuario parcial: " + partialUser.name);
console.log("Usuario de solo lectura: " + readonlyUser.name);

Tipos mapeados:Usar la sintaxis [P in keyof T] para recorrer todas las claves de un tipo es la base para crear tipos utilitarios.


Restringir los tipos de las claves

Usar keyof y restricciones genéricas para limitar las claves que acepta una función.

Ejemplo

// Definir el tipo de configuración
interface Config {
    apiUrl: string;
    timeout: number;
    retry: boolean;
}

// Solo se pueden obtener las claves existentes
function getConfigValue<T, K extends keyof T>(
    config: T,
    key: K
): T[K] {
    return config[key];
}

// Definir la configuración
const config: Config = {
    apiUrl: "https://api.example.com",
    timeout: 5000,
    retry: true
};

// Correcto: la clave existe
const url: string = getConfigValue(config, "apiUrl");
const timeoutVal: number = getConfigValue(config, "timeout");

// Error: la clave no existe (TypeScript mostrará un error)
// const invalid = getConfigValue(config, "unknown");

console.log("API URL: " + url);
console.log("Timeout: " + timeoutVal);

Restricción:K extends keyof T asegura que la clave pasada sea una clave existente en el objeto, previniendo errores en tiempo de ejecución.


Obtener solo propiedades de un tipo específico

Extraer claves de propiedades de un tipo específico de un tipo de objeto.

Ejemplo

// Definir un tipo mixto
interface Mixed {
    id: number;
    name: string;
    age: number;
    email: string;
    active: boolean;
}

// Extraer todas las claves de tipo string
type StringKeys<T> = {
    [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];

// Extraer todas las claves de tipo number
type NumberKeys<T> = {
    [K in keyof T]: T[K] extends number ? K : never;
}[keyof T];

// Prueba
type StringProps = StringKeys<Mixed>;  // "name" | "email"
type NumberProps = NumberKeys<Mixed>;  // "id" | "age"

// Aplicación práctica: obtener el valor de propiedades de tipo string
function getStringProps<T, K extends StringKeys<T>>(
    obj: T,
    keys: K[]
): T[K][] {
    return keys.map(key => obj[key]);
}

const mixed: Mixed = {
    id: 1,
    name: "Alice",
    age: 25,
    email: "alice@test.com",
    active: true
};

const strings = getStringProps(mixed, ["name", "email"]);
console.log("Propiedad string: " + strings.join(", "));

Tipos condicionales:Combinando tipos condicionales y tipos mapeados, se pueden implementar filtrados y extracciones de tipos complejos.


Iterar sobre tipos de arreglo

Usar tipos de índice para operar con arreglos y tuplas.

Ejemplo

// Definir un tipo de tupla
type Tuple = [string, number, boolean];

// Obtener el tipo del elemento de la tupla
type First = Tuple[0];   // string
type Second = Tuple[1];  // number
type Third = Tuple[2];   // boolean

// Usar number para obtener el tipo de todos los elementos
type AllElements = Tuple[number];  // string | number | boolean

// Obtener el tipo de los elementos del arreglo
type StringArray = string[];
type ArrayElement = StringArray[number];  // string

// Aplicación práctica: sobrecarga de funciones
function getElement<T extends any[]>(
    arr: T,
    index: number
): T[indexof T] | undefined {
    return index < arr.length ? arr[index] : undefined;
}

const tuple: Tuple = ["hello", 123, true];
const arr: string[] = ["a", "b", "c"];

console.log("Elemento de tupla + getElement(tuple, 0));
console.log("Elemento de arreglo + getElement(arr, 1));

Índice de tuplas:Las tuplas pueden usar índices numéricos, cada índice corresponde a un tipo de elemento específico, cosa que los arreglos no pueden hacer.


Notas

  • keyof devuelve un tipo unión:keyof devuelve el tipo unión literal de los nombres de las claves
  • Seguridad en el acceso por índice:Asegurarse de que la clave a la que se accede exista en el tipo objetivo
  • Restricciones genéricas:Usar extends keyof para restringir los parámetros genéricos
  • Los tipos mapeados requieren la palabra clave in:Los tipos mapeados usan la sintaxis [P in keyof T]

Mejores prácticas:Los tipos de índice son la piedra angular para crear tipos utilitarios genéricos; dominarlos puede mejorar enormemente la capacidad de manipulación de tipos.


Resumen

Los tipos de índice y keyof son componentes importantes del sistema de tipos de TypeScript.

  • keyof:Obtener todas las claves de un tipo de objeto
  • Acceso por índice:Obtener el tipo de una propiedad mediante una clave
  • Tipos mapeados:Crear nuevos tipos basados en tipos existentes
  • Seguridad de tipos:Asegurar la seguridad de tipos en el acceso dinámico a propiedades

Recomendación:Cuando necesites manipular propiedades de objetos, prioriza el uso de tipos de índice para mantener la seguridad de tipos.

Otras extensiones