Generics

Generics

Welcome to the next lesson! In this lesson, you’ll learn about generics, a powerful feature in TypeScript that allows you to create reusable and type-safe components. Let’s get started!

Generics let you write reusable code that works with any type. They act as placeholders for types that you can specify when you use them.

Example: A generic function:

Task: Write a generic function that takes an argument and returns it unchanged.

function identity<T>(value: T): T {
  return value;
}

console.log(identity<string>("Hello")); 
// Output: Hello
console.log(identity<number>(42)); 
// Output: 42

Generics help you:

• Write reusable code: Functions and classes can work with different types.
• Ensure type safety: You can enforce specific types without sacrificing flexibility.
• Reduce redundancy: Avoid writing separate versions of the same function or class for different types.

Tip: Use generics to write more flexible and maintainable code.

You can use generics to create flexible functions. Example:

Task: Write a generic function that merges two objects and returns the result.

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

let merged = merge({ name: "Alice" }, { age: 25 });
console.log(merged); 
// Output: { name: "Alice", age: 25 }

Generics can be used in classes to make them reusable for different types. Example:

class Box<T> {
  private contents: T;

  constructor(contents: T) {
    this.contents = contents;
  }

  getContents(): T {
    return this.contents;
  }
}

let stringBox = new Box<string>("Hello");
console.log(stringBox.getContents()); 
// Output: Hello

let numberBox = new Box<number>(42);
console.log(numberBox.getContents()); 
// Output: 42

Interfaces can also use generics to enforce structure for different types. Example:

Task: Define a generic interface and create an object that implements it.

interface Pair<T, U> {
  first: T;
  second: U;
}

let coordinates: Pair<number, number> = { first: 10, second: 20 };
console.log(coordinates); 
// Output: { first: 10, second: 20 }

You can add constraints to generics to ensure they work only with specific types. Example:

function printLength<T extends { length: number }>(item: T): void {
  console.log(`Length: ${item.length}`);
}

printLength("Hello"); 
// Output: Length: 5
printLength([1, 2, 3]); 
// Output: Length: 3
// printLength(42); 
// Error: Argument of type 'number' is not assignable to parameter of type '{ length: number }'.

You can specify default types for generics if no type is provided. Example:

Task: Create a generic function with a default type and test it with different types.

function wrap<T = string>(value: T): T[] {
  return [value];
}

console.log(wrap("Hello")); // Output: ["Hello"]
console.log(wrap(42)); // Output: [42]

Congratulations! You’ve learned how to use generics in TypeScript to create reusable, type-safe functions, classes, and interfaces. Generics are a powerful tool for writing flexible and scalable code. In the next lesson, we’ll explore advanced types, such as mapped and conditional types. Let’s keep coding!