keyof and indexed access types

keyof gives you the key union

keyof T evaluates to a union of T's public property names as literal types. For interface User { id: string; age: number }, keyof User is 'id' | 'age'. Because it is computed from the type, the union updates automatically when you add or remove a property — there is no separate list of names to keep in sync. For an object with string keys you get string, and for an array or tuple you also get the numeric index keys plus the inherited Array members.

Indexed access reads the value type

T[K] is the indexed access (or lookup) type: it asks "what is the type of the value at key K?" So User['id'] is string and User['age'] is number. The key can itself be a union — User['id' | 'age'] is string | number — and T[keyof T] therefore reads the union of all value types in T. This mirrors the runtime obj[key] expression, but at the type level.

A type-safe getter ties them together

The classic pairing is a generic get(obj, key): constrain the key parameter with K extends keyof T and declare the return type as T[K]. Now the compiler rejects keys that don't exist and infers the exact value type at the call site — get(user, 'age') is typed number, not a widened string | number. The two features are most powerful together: keyof to constrain the key, indexed access to describe the result.

Arrays: T[number] is the element type

Indexing a tuple or array type with the literal type number yields its element type: for type Nums = number[], Nums[number] is number, and for a tuple [string, boolean], T[number] is string | boolean. Combined with typeof over an as const array, (typeof arr)[number] extracts a union of the array's literal values — a common way to derive a union from a single source list.