Overview

Generics in TypeScript are a powerful feature that allow developers to create components that can work with any data type, not just one. This capability is crucial for building reusable, type-safe code, as it enables functions, classes, and interfaces to operate on a variety of data types while still maintaining strict type checking at compile time. Understanding and applying generics can significantly enhance code quality and developer productivity.

Key Concepts

1. Type Safety: Generics provide a way to ensure type safety without sacrificing the flexibility of working with any data type.
2. Code Reusability: By using generics, developers can write more generalized, reusable code components that work with multiple data types.
3. Compile-Time Type Checking: Generics improve type checking at compile time, helping to catch errors early in the development process.

Common Interview Questions

Basic Level

1. What are generics in TypeScript?
2. Can you write a simple generic function in TypeScript?

Intermediate Level

3. How do generics enhance type safety in TypeScript applications?

Advanced Level

4. Can you describe a scenario where generics can significantly reduce code duplication?

Detailed Answers

1. What are generics in TypeScript?

Answer: Generics are a feature in TypeScript that allows the creation of components that can work over a variety of types rather than a single one. This enables users to capture the type(s) passed to components (like functions, interfaces, or classes) at the time of invocation, ensuring type safety without losing the flexibility of using any type.

Key Points:
- Generics provide type safety without compromising flexibility.
- They enable functions, interfaces, and classes to work with any data type.
- The type is specified at the time of calling or using the component.

Example:

// A simple generic function that returns an array of a specific type
function identity<T>(arg: T): T {
    return arg;
}

let outputString = identity<string>("myString");
let outputNumber = identity<number>(100);

2. Can you write a simple generic function in TypeScript?

Answer: Yes, a simple generic function can be written by specifying a type variable in angle brackets after the function name, and then using that type variable as the type for arguments, return values, or both.

Key Points:
- The type variable allows the function to be used with different types.
- Type variables can be used to enforce type relationships between the function's parameters and its return type.
- Generics increase code reusability by abstracting over types.

Example:

// A generic function to return an array containing one element
function wrapInArray<T>(value: T): T[] {
    return [value];
}

let stringArray = wrapInArray("hello");  // string[]
let numberArray = wrapInArray(123);      // number[]

3. How do generics enhance type safety in TypeScript applications?

Answer: Generics enhance type safety by enabling developers to write flexible, reusable components while still maintaining strict type checking. By using generics, a function or component can accept various types, but the use of these types is consistent across the component, preventing type mismatches that could lead to runtime errors.

Key Points:
- Generics allow for strict type checking at compile time.
- They prevent type mismatches and common type-related runtime errors.
- Generic types are checked when the component is used, not when it's defined.

Example:

// A generic function to compare two values of the same type
function isEqual<T>(a: T, b: T): boolean {
    return a === b;
}

isEqual<number>(1, 2); // Correct usage
isEqual<string>("a", "b"); // Correct usage
isEqual<number>(1, "b"); // Error: Type 'string' is not assignable to type 'number'.

4. Can you describe a scenario where generics can significantly reduce code duplication?

Answer: A common scenario where generics reduce code duplication is in the implementation of data structures like arrays, stacks, queues, and linked lists. Without generics, separate implementations of these structures would be required for each data type. With generics, a single implementation can work with any data type, vastly reducing code duplication.

Key Points:
- Generics enable the creation of type-agnostic data structures.
- They reduce the need for multiple implementations of the same logic.
- Generics make it easier to maintain and update code by centralizing common logic.

Example:

// A generic class for a simple stack data structure
class Stack<T> {
    private items: T[] = [];

    push(item: T) {
        this.items.push(item);
    }

    pop(): T | undefined {
        return this.items.pop();
    }
}

let numberStack = new Stack<number>();
numberStack.push(1);
let stringStack = new Stack<string>();
stringStack.push("hello");

In this guide, we covered the basics of generics in TypeScript, showing how they enhance type safety, promote code reusability, and provide compile-time type checking. Through examples, we demonstrated how generics can be applied in functions, classes, and interfaces, highlighting their importance in writing flexible, yet type-safe code.