Course contentsShow
← TypeScript
Lesson 641 of 1,79615. Generic ConstraintsFree lesson

keyof Constraints in Real-World Helpers

Common patterns like path accessors, safe update functions, and object validators using keyof.

keyof Constraints in Real-World Helpers

What you'll learn: How to combine keyof constraints with generics to build powerful, type-safe utility functions that work safely with object properties.

The Pattern in Action

You've learned how keyof extracts object keys and how to constrain generics. Now let's see how they combine in real helper functions you'll actually write.

Path Accessors

function getNestedValue<T, K extends keyof T>(
  obj: T,
  key: K
): T[K] {
  return obj[key];
}

const user = { name: "Alice", age: 30 };
const userName = getNestedValue(user, "name"); // string
const userAge = getNestedValue(user, "age");   // number
// getNestedValue(user, "invalid"); // Error!

Safe Update Functions

function updateProperty<T, K extends keyof T>(
  obj: T,
  key: K,
  value: T[K]
): T {
  return { ...obj, [key]: value };
}

const updated = updateProperty(user, "age", 31); // ✓ type-safe
// updateProperty(user, "age", "31"); // Error: string not assignable to number

Object Validators

function hasProperty<T, K extends keyof T>(
  obj: T,
  key: K
): boolean {
  return key in obj && obj[key] !== undefined;
}

if (hasProperty(user, "name")) {
  // TypeScript knows user.name exists and has correct type
}

Why This Matters

These helpers are safe by construction. TypeScript ensures you can't pass invalid keys or mismatched value types. The keyof constraint acts as a gatekeeper, only allowing keys that actually exist on the object type.

Key Takeaway: Combining keyof constraints with generics lets you build flexible utilities that prevent typos, invalid keys, and type mismatches—common pitfalls in dynamic object manipulation.