Mastering TypeScript Generics

Generics are one of TypeScript's most powerful features. They enable you to write reusable, type-safe code that works with any data type.

What Are Generics?

Generics allow you to create components that work with a variety of types rather than a single one:

function identity<T>(arg: T): T {
  return arg;
}
const num = identity(42);        // type: number const str = identity("hello");   // type: string

Generic Constraints

Use constraints to limit what types can be passed:

interface HasLength {
  length: number;
}
function logLength<T extends HasLength>(arg: T): T {   console.log(arg.length);   return arg; }
logLength("hello");     // OK logLength([1, 2, 3]);   // OK logLength(123);         // Error: number doesn't have length

Utility Types

TypeScript provides powerful built-in utility types:

// Partial - makes all properties optional
type PartialUser = Partial<User>;
// Required - makes all properties required type RequiredUser = Required<User>;
// Pick - select specific properties type UserName = Pick<User, 'name' | 'email'>;
// Omit - exclude specific properties type UserWithoutPassword = Omit<User, 'password'>;

Advanced Patterns

Conditional Types

type IsString<T> = T extends string ? true : false;
type A = IsString<string>;  // true type B = IsString<number>;  // false

Mapped Types

type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

Conclusion

Generics transform TypeScript from a simple type checker into a powerful tool for building type-safe abstractions. Master these patterns to write more maintainable code.