Typescript Generic Constraints: Apply constraints to generics for more precise type definitions.

In TypeScript, generic constraints allow you to enforce certain rules on generic types, making your type definitions more precise and your code safer.

Constraints are specified using the extends keyword, which restricts what types can be used as generic arguments.

Here are some examples of how to use generic constraints in TypeScript:

1. Basic Constraints with extends

You can constrain a generic type to extend a specific type, ensuring that only types compatible with that constraint are accepted.

1// A generic function that only accepts objects with a `name` property
2function printName<T extends { name: string }>(obj: T): void {
3  console.log(obj.name);
4}
5
6printName({ name: "Alice" }); // ✅ Works
7printName({ name: "Bob", age: 25 }); // ✅ Works
8// printName({ age: 25 }); // ❌ Error: Property 'name' is missing
9

In this example, T is constrained to types that have a name property of type string.

2. Constraining to a Union of Types

You can restrict a generic to a specific set of types by using union types in the constraint.

1function getLength<T extends string | any[]>(input: T): number {
2  return input.length;
3}
4
5getLength("hello"); // ✅ Works, returns 5
6getLength([1, 2, 3]); // ✅ Works, returns 3
7// getLength(123); // ❌ Error: Type 'number' is not assignable to type 'string | any[]'

Here, T can only be a string or an array (any[]), both of which have a length property.

3. Constraining to Class Instances

You can use classes as constraints to ensure the generic type is an instance of a particular class.

1class Animal {
2  sound() {
3    console.log("Some sound");
4  }
5}
6
7class Dog extends Animal {
8  bark() {
9    console.log("Woof!");
10  }
11}
12
13function makeSound<T extends Animal>(animal: T): void {
14  animal.sound();
15}
16
17makeSound(new Dog()); // ✅ Works
18// makeSound({} as string); // ❌ Error: Type 'string' is not assignable to type 'Animal'
19

In this example, T is constrained to be of type Animal or any subclass of Animal, so you can call sound() on animal.

4. Multiple Constraints with &

You can apply multiple constraints by combining them with &. This requires the generic type to satisfy all specified constraints.

1interface Identifiable {
2  id: number;
3}
4
5interface Nameable {
6  name: string;
7}
8
9function printPersonInfo<T extends Identifiable & Nameable>(person: T): void {
10  console.log(`ID: ${person.id}, Name: ${person.name}`);
11}
12
13printPersonInfo({ id: 1, name: "Alice" }); // ✅ Works
14// printPersonInfo({ id: 1 }); // ❌ Error: Property 'name' is missing
15// printPersonInfo({ name: "Alice" }); // ❌ Error: Property 'id' is missing
16

Here, T is constrained to types that have both id and name properties.

5. Using keyof to Constrain to Keys of a Type

You can use keyof to constrain a generic type to be one of the keys of another type.

1type Person = {
2  id: number;
3  name: string;
4  age: number;
5};
6
7function getProperty<T extends keyof Person>(key: T): string {
8  return `Property name: ${key}`;
9}
10
11getProperty("name"); // ✅ Works
12getProperty("age"); // ✅ Works
13// getProperty("address"); // ❌ Error: Type '"address"' is not assignable to parameter of type 'keyof Person'
14

Here, T is constrained to be one of the keys of the Person type (id, name, or age), so you can't pass a key that doesn't exist on Person.

6. Default Values with Constraints

You can set a default type with a constraint to avoid having to specify the type in every call.

1function createEntity<T extends { id: number } = { id: number }>(entity: T): T {
2  console.log(entity.id);
3  return entity;
4}
5
6createEntity({ id: 1, name: "Alice" }); // ✅ Works with inferred type
7createEntity<{ id: number; age: number }>({ id: 2, age: 30 }); // ✅ Works with explicit type
8

In this example, if no type argument is provided, T defaults to { id: number }.

PHP Date and Time: Date and time handling with DateTime class

Mapped Types: Transform types using the mapped type feature.