Using Generic Constraints in TypeScript for Type Safety

When working with TypeScript, generics offer a way to create reusable code components. However, sometimes, we encounter situations where we need to ensure that the generic type adheres to certain contracts or has certain functionalities. For these scenarios, TypeScript offers the use of generic constraints.

Consider a scenario where you want to print the properties of different objects like houses or cars, but not every object might have a print method. How can you ensure that the object you pass indeed has a print method?

The Power of Constraints

Using constraints, you can make sure that the generic type adheres to a specific structure. Let’s delve into an example to understand this concept better.

First, you’d create an interface, in our case Printable, that declares the methods or properties you expect the type to have:

interface Printable {
    print(): void;
}

With the Printable interface, we’ve specified that any type that wants to be printable must have a print method.

Next, when declaring a generic function, we use the extends keyword to enforce that the type argument passed in adheres to our Printable interface:

function printHousesOrCars<T extends Printable>(arr: T[]): void {
    for (let i = 0; i < arr.length; i++) {
        arr[i].print();
    }
}

With the above function printHousesOrCars, we can now be certain that any type T we pass into this function has a print method. This provides us with type safety and ensures that our code won’t break unexpectedly due to a missing method.

Wrapping Up

Constraints in generics are powerful tools that allow developers to ensure that the types they work with adhere to certain contracts. They provide an additional layer of safety, ensuring that our generic functions and classes are used correctly.

,