Why Generic class with constraints in Typescript? - Purpose & Use Cases

The Big Idea

What if you could write one class that safely works with many types, without endless checks or duplicated code?

The Scenario

Imagine you want to create a class that works with different types of data, but only certain types that have specific properties or methods. Without constraints, you might try to write separate classes for each type or check types manually everywhere.

The Problem

This manual way is slow and error-prone because you have to duplicate code or add many checks. It's like writing the same recipe multiple times with slight changes, which wastes time and can cause mistakes.

The Solution

Using a generic class with constraints lets you write one flexible class that only accepts types meeting your rules. This keeps your code clean, safe, and reusable, like having one recipe that works perfectly for all allowed ingredients.

Before vs After

✗ Before

class DataHolder {
  data: any;
  constructor(data: any) {
    if (!('id' in data)) throw new Error('Missing id');
    this.data = data;
  }
}

✓ After

interface HasId { id: number; }
class DataHolder<T extends HasId> {
  data: T;
  constructor(data: T) {
    this.data = data;
  }
}

What It Enables

You can create powerful, reusable classes that work only with types having the properties you need, preventing bugs before they happen.

Real Life Example

Think of a user management system where you want a class to handle any user-like object, but only if it has an id property. Generic classes with constraints make this easy and safe.

Key Takeaways

Manual type checks slow you down and cause errors.

Generic classes with constraints enforce rules at compile time.

This leads to cleaner, safer, and reusable code.