keyof and indexed access types

keyof: the union of a type’s keys

keyof T produces a union of the literal types of T’s property keys:

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

type UserKey = keyof User;
//   ^? type UserKey = "id" | "name" | "age"

This union is derived — add a property to User and UserKey updates automatically. It is the building block for any operation that must iterate or constrain over a type’s own keys.

T[K]: indexed access

T[K] looks up the type stored at key K in T. The key must be a valid key of T (or you get an error):

type Name = User["name"];
//   ^? type Name = string
type Age = User["age"];
//   ^? type Age = number

type Bad = User["nope"];
// Error: Property 'nope' does not exist on type 'User'.

Indexing is by type, not by value: User["name"] is using the string literal type "name" as the index, not a runtime string. This is why it works on types that have no runtime existence.

Indexing with a union of keys → union of value types

When you need to say “the value at any of these keys”, you do not write a separate union by hand — you index by the key union and let the checker derive it. This is where keyof and T[K] compose into a real single-source-of-truth tool.

Index with a union of keys and you get the union of the corresponding value types:

type IdOrAge = User["id" | "age"];
//   ^? type IdOrAge = string | number

type AllValues = User[keyof User];
//   ^? type AllValues = string | number   ("id"→string, "name"→string, "age"→number)

T[keyof T] — “index by every key” — is the idiom for “the union of all value types in T”. Duplicate value types collapse (string | string | number = string | number). This is a frequent senior tool: deriving an allowed-values union from a config object, or the payload-type union from a discriminated union’s members.

type Action =
  | { type: "add"; n: number }
  | { type: "clear" };

type ActionType = Action["type"];
//   ^? type ActionType = "add" | "clear"   — the tag union, derived from the variants

Notice this works straight on a union type: Action["type"] reads type from each member and unions the results. That keeps the discriminant tags from the previous lesson as a single source of truth.

number-indexing arrays and tuples → element type

Arrays and tuples are indexed by number. So T[number] is the element type:

type Names = string[];
type Element = Names[number];
//   ^? type Element = string

const roles = ["admin", "editor", "viewer"] as const;
type Role = typeof roles[number];
//   ^? type Role = "admin" | "editor" | "viewer"

The as const + [number] combo is the canonical way to derive a literal union from a runtime array, so the array of values and its type stay in lockstep. For tuples, [number] gives the union of all positions, while a literal index gives one slot:

type Pair = [string, number];
type First = Pair[0];
//   ^? type First = string
type Either = Pair[number];
//   ^? type Either = string | number

Pitfall: keyof on index-signature types

When a type has an index signature, keyof returns the signature key type, not a finite literal union:

type Dict = { [key: string]: number };
type K1 = keyof Dict;
//   ^? type K1 = string | number
//      (string index signatures also admit number keys, because JS coerces numeric keys to strings)

type NumDict = { [key: number]: boolean };
type K2 = keyof NumDict;
//   ^? type K2 = number

This surprises people: keyof a string-indexed type is string | number, not string, because a numeric property access like dict[0] is legal (JS turns it into dict["0"]). If you later try to constrain a generic K extends keyof Dict expecting precise keys, you instead get the broad string | number and lose the precision you wanted. Prefer a concrete object type (or Record<SpecificUnion, V>) when you need a finite key union.

Why this bridges to mapped types

Indexed access answers “what type is at this key”. The natural next question — “transform every key” — is mapped types (unit 04): { [K in keyof T]: ... } iterates the keyof T union and uses T[K] to read each value type. Everything you do with mapped types is built on the two operators in this lesson, so internalising keyof and T[K] now pays off directly there.