0Pricing
TypeScript Academy · Lección

keyof y tipos de acceso indexado

Acceda dinámicamente a los tipos de propiedades de objetos con keyof y T[K].

keyof y tipos de acceso indexado es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Bienvenida

`keyof` produce una unión de los nombres de las propiedades de un tipo de objeto. Los tipos de acceso indexado (`T[K]`) recuperan el tipo correspondiente a una clave de propiedad específica.

Conceptos básicos de keyof

`keyof T` devuelve una unión de todos los tipos de nombres de propiedades de `T`.
interface User { id: number; name: string; email: string; }
type UserKeys = keyof User; // 'id' | 'name' | 'email'

Acceso indexado: T[K]

Use `T[K]` para obtener el tipo de la propiedad `K` en el tipo `T`.
type IdType = User['id'];   // number
type NameType = User['name']; // string

Acceso dinámico a propiedades

Combine `keyof` y genéricos para crear funciones de acceso a propiedades con seguridad de tipos.
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const name = getProperty(user, 'name'); // string

keyof con typeof

Use `typeof` sobre un valor y, después, `keyof` para obtener sus nombres de propiedades sin declarar una interfaz.
const config = { host: 'localhost', port: 3000 };
type ConfigKey = keyof typeof config; // 'host' | 'port'

Unión de tipos indexados

Indexe un tipo con una unión de claves para obtener la unión de sus tipos de valores.
type NumericValues = User['id' | 'age']; // number | number = number

keyof en arrays

`keyof` aplicado a un tipo de array devuelve los tipos de índice del array y los nombres de sus métodos.
type ArrKey = keyof string[]; // number | 'length' | 'push' | ...
type Element = string[][number]; // string

Acceso indexado recursivo

Encadene tipos de acceso indexado para objetos anidados.
type Address = { city: string; zip: string };
type Profile = { address: Address };
type City = Profile['address']['city']; // string

Restricciones con keyof

Use `K extends keyof T` como restricción genérica para garantizar que `K` sea una clave válida de `T`.
function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
  obj[key] = value;
}

Los tipos mapeados usan keyof

Los tipos mapeados iteran sobre `keyof T` para transformar tipos de objetos.
type Readonly2<T> = { readonly [K in keyof T]: T[K] };

keyof en tipos condicionales

`keyof` es muy potente en tipos condicionales para extraer grupos de claves específicos.
type StringKeys<T> = { [K in keyof T]: T[K] extends string ? K : never }[keyof T];

Comprobación rápida

¿Qué devuelve `User['name']` si `interface User { name: string }`?

Recapitulación

`keyof` extrae los nombres de propiedades como un tipo unión. `T[K]` recupera el tipo correspondiente a una clave. Juntos permiten crear accesos a propiedades con seguridad de tipos, tipos mapeados y utilidades de tipos condicionales.

Preguntas frecuentes

¿La lección «keyof y tipos de acceso indexado» es gratis?

Sí — el texto completo de «keyof y tipos de acceso indexado» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «keyof y tipos de acceso indexado»?

Acceda dinámicamente a los tipos de propiedades de objetos con keyof y T[K]. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «keyof y tipos de acceso indexado»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. keyof y tipos de acceso indexado
  2. Restricciones genéricas: reducción de parámetros de tipo
  3. Tipos condicionales: T extends U ? X : Y
  4. Tipos condicionales distributivos
← Volver a TypeScript Academy