0Pricing
TypeScript Academy · Aula

keyof e tipos de acesso indexado

Acesse dinamicamente os tipos das propriedades de objetos com keyof e T[K]

keyof e tipos de acesso indexado é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Boas-vindas

keyof produz uma união dos nomes das propriedades de um tipo de objeto. Os tipos de acesso indexado (T[K]) recuperam o tipo associado a uma chave de propriedade específica.

Fundamentos de keyof

keyof T retorna uma união de todos os tipos de nomes de propriedades de T.
interface User { id: number; name: string; email: string; }
type UserKeys = keyof User; // 'id' | 'name' | 'email'

Acesso indexado: T[K]

Use T[K] para obter o tipo da propriedade K no tipo T.
type IdType = User['id'];   // number
type NameType = User['name']; // string

Acesso dinâmico a propriedades

Combine keyof e genéricos para criar funções de acesso a propriedades com segurança 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 com typeof

Use typeof em um valor e, em seguida, keyof para obter os nomes de suas propriedades sem declarar uma interface.
const config = { host: 'localhost', port: 3000 };
type ConfigKey = keyof typeof config; // 'host' | 'port'

União de tipos indexados

Indexe um tipo com uma união de chaves para obter a união dos tipos de seus valores.
type NumericValues = User['id' | 'age']; // number | number = number

keyof em matrizes

keyof aplicado a um tipo de matriz retorna os tipos dos índices da matriz, além dos nomes dos métodos da matriz.
type ArrKey = keyof string[]; // number | 'length' | 'push' | ...
type Element = string[][number]; // string

Acesso indexado recursivo

Encadeie tipos de acesso indexado para objetos aninhados.
type Address = { city: string; zip: string };
type Profile = { address: Address };
type City = Profile['address']['city']; // string

Restrições com keyof

Use K extends keyof T como uma restrição genérica para garantir que K seja uma chave válida de T.
function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]): void {
  obj[key] = value;
}

Tipos mapeados usam keyof

Os tipos mapeados iteram sobre keyof T para transformar tipos de objeto.
type Readonly2<T> = { readonly [K in keyof T]: T[K] };

keyof em tipos condicionais

keyof é poderoso em tipos condicionais para extrair grupos específicos de chaves.
type StringKeys<T> = { [K in keyof T]: T[K] extends string ? K : never }[keyof T];

Verificação rápida

O que `User['name']` retorna quando `interface User { name: string }`?

Recapitulação

keyof extrai nomes de propriedades como um tipo união. T[K] recupera o tipo associado a uma chave. Juntos, eles viabilizam o acesso a propriedades com segurança de tipos, tipos mapeados e utilitários de tipos condicionais.

Perguntas Frequentes

A aula “keyof e tipos de acesso indexado” é grátis?

Sim — o texto completo de “keyof e tipos de acesso indexado” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “keyof e tipos de acesso indexado”?

Acesse dinamicamente os tipos das propriedades de objetos com keyof e T[K] Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “keyof e tipos de acesso indexado”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. keyof e tipos de acesso indexado
  2. Restrições genéricas: restringindo parâmetros de tipo
  3. Tipos condicionais: T extends U ? X : Y
  4. Tipos condicionais distributivos
← Voltar para TypeScript Academy