Can types be extended or intersected?

In TypeScript, types can indeed be extended and intersected, which allows for greater flexibility and reusability in your code. Understanding how to effectively use type extensions and intersections is crucial for building scalable applications. This response will explore both concepts in detail, providing practical examples, best practices, and common mistakes to avoid.

Type Extension

Type extension in TypeScript is achieved using interfaces or classes. When you extend a type, you create a new type that inherits properties from an existing type. This is particularly useful for creating more specific types based on a generic type.

Using Interfaces

Interfaces can be extended using the `extends` keyword. Here’s an example:

interface Person {
    name: string;
    age: number;
}

interface Employee extends Person {
    employeeId: number;
}

const employee: Employee = {
    name: "John Doe",
    age: 30,
    employeeId: 12345
};

In this example, the `Employee` interface extends the `Person` interface, inheriting its properties while adding a new property, `employeeId`.

Using Classes

Classes can also extend other classes, allowing for inheritance of methods and properties:

class Animal {
    name: string;
    constructor(name: string) {
        this.name = name;
    }
}

class Dog extends Animal {
    bark() {
        console.log("Woof! My name is " + this.name);
    }
}

const dog = new Dog("Buddy");
dog.bark(); // Outputs: Woof! My name is Buddy

Type Intersection

Type intersection allows you to combine multiple types into one. This is done using the `&` operator. It’s useful when you want to create a type that has properties from multiple sources.

Combining Types

Here’s an example of how to use intersection types:

interface Vehicle {
    wheels: number;
}

interface Electric {
    battery: number;
}

type ElectricCar = Vehicle & Electric;

const tesla: ElectricCar = {
    wheels: 4,
    battery: 100
};

In this example, the `ElectricCar` type combines the properties of both `Vehicle` and `Electric`, allowing for a more comprehensive type definition.

Best Practices

• Use interfaces for defining object shapes when you expect to extend them later.
• Favor intersection types when you need to combine multiple types into one, especially for utility types.
• Keep your type definitions clear and concise to improve readability and maintainability.

Common Mistakes

• Overusing type intersections can lead to complex types that are hard to understand.
• Not using `extends` properly can lead to unexpected behavior if properties are not inherited as intended.
• Failing to define all required properties in extended types can result in runtime errors.

By understanding and utilizing type extension and intersection effectively, you can create more robust and maintainable TypeScript applications. These features not only enhance code organization but also promote reusability, making your codebase easier to manage and scale.