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!

What Are Generics?

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

Why Use Generics?

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.

Generic Functions

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 }

Generic Classes

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

Generic Interfaces

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 }

Generic Constraints

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 }'.

Generic Default Values

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]

Great Job!

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!