Records & Index Signatures

An index signature ( { [k: string]: V } ) types an object as a dictionary with any number of keys, while Record<K, V> is the built-in utility for an object whose keys are K and values are V — both are how you give types to key-value maps.

Learn Records & Index Signatures in our free TypeScript course — an interactive lesson with runnable examples, a practice exercise and a quick reference.

Part of the free TypeScript course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

What You'll Learn

💡 Real-World Analogy

Think of a hotel's room-key board. An index signature is a board with unlimited unlabeled hooks: any room number can hang a key (any string key, any value). A Record<union, V> is a board pre-printed with exactly the rooms that exist — every slot is named and must be filled. And noUncheckedIndexedAccess is the honest sign reminding you that reaching for a room that doesn't exist gets you an empty hook (undefined), not a key.

1. Index Signatures: Open Dictionaries

When you don't know the keys in advance — a scores-by-name map, feature flags, a cache — an index signature types it. { [name: string]: number } means "any string key maps to a number." You can read and write any key, iterate with Object.entries , and you can even combine an index signature with a few known fixed properties, as long as their types are compatible.

2. Record<K, V> and keyof

Record<K, V> builds a key-value object type in one expression. With a union of literal keys — Record<"admin" | "user", boolean> — every listed key is required, making it ideal for fixed maps. With Record<string, V> it behaves like an open index signature. The keyof operator pulls the key union back out of any object type.

3. noUncheckedIndexedAccess : Honest Lookups

By default, TypeScript optimistically types a dictionary lookup as the value type — even though, at runtime, a missing key is undefined . That gap causes real "cannot read property of undefined" crashes. The noUncheckedIndexedAccess compiler flag closes it by typing every index access as V | undefined , forcing you to check or default first. It's strongly recommended whenever you work with dictionaries.

🎯 Your Turn

Build a word-count dictionary, defaulting a missing count to 0 . Fill in the blank marked ___ with the right operator, then run it.

Common Errors (and the fix)

• ❌ "Cannot read properties of undefined" from a dictionary lookup. ✅ Enable noUncheckedIndexedAccess and default with ?? fallback before using the value.
• ❌ "Property 'admin' is missing" on a fixed Record<union, V> . ✅ Provide every key in the union, or switch to an open Record<string, V> .
• ❌ Mixing known fields with an incompatible index signature — TS requires the fixed property's type to be assignable to the index value type. ✅ Align the types or split into separate shapes.
• ❌ Iterating with for...in and hitting prototype keys . ✅ Use Object.keys / Object.entries , which only see own enumerable keys.

Pro Tips

• 💡 Use Record<Union, V> for exhaustive maps — a color-per-status or handler-per-event table where every key must be present.
• 💡 Turn on noUncheckedIndexedAccess for any code that reads dictionaries by dynamic keys — it eliminates a whole class of undefined crashes.
• 💡 Derive key unions with keyof typeof obj so a function only accepts keys that actually exist on a specific object.
• 💡 Reach for Map when keys aren't strings, order matters, or you delete entries often — objects shine for static, string-keyed data.

📚 Keep learning

• TypeScript Handbook — Index Signatures
• TypeScript Handbook — Record<Keys, Type>
• TSConfig Reference — noUncheckedIndexedAccess

Frequently Asked Questions

Mini-Challenge: groupBy

No blanks this time — just a brief and a starting outline. Build the grouping function yourself, run it, and check your output against the example in the comments.

🎉 Lesson Complete

• ✅ An index signature { [k: string]: V } types an open dictionary
• ✅ Record<K, V> builds key-value object types concisely
• ✅ Record<union, V> requires all keys; Record<string, V> is open
• ✅ keyof extracts the union of an object type's keys
• ✅ noUncheckedIndexedAccess makes lookups V | undefined — handle the gap
• ✅ Next lesson: Template Literal Types — string types built from other types

Practice quiz

Continue this course

• Previous: readonly & as const
• Next: Template Literal Types