Creating, Extending, and Best Practices - Textnotes

Creating, Extending, and Best Practices

Learn how to use interfaces in TypeScript to define object structures. This module explains how to create interfaces, extend them, understand interface vs type differences, and follow best practices for scalable applications.

1. Creating Interfaces

Interfaces are used to define the structure of an object. They specify what properties and methods an object must have.

Basic Interface Example


interface User {
id: number;
name: string;
email: string;
}

Using an Interface


let user: User = {
id: 1,
name: "Muni",
email: "muni@example.com"
};

If any required property is missing or has the wrong type, TypeScript throws a compile-time error.

Optional Properties in Interfaces


interface Employee {
id: number;
name: string;
department?: string;
}

Optional properties are useful when some values may not always be available.

2. Extending Interfaces

Interfaces can extend other interfaces to reuse and expand existing definitions.

Interface Extension Example


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

interface Developer extends Person {
skills: string[];
}

Using the Extended Interface


let dev: Developer = {
name: "Muni",
age: 35,
skills: ["TypeScript", "Node.js"]
};

Interface extension helps maintain clean and reusable code structures.

3. Interface vs Type

Both interfaces and type aliases are used to define shapes of data, but they have key differences.

Interfaces are mainly used to define object shapes and support declaration merging. Type aliases are more flexible and can define unions, intersections, and primitive types.

Interface Example


interface Product {
id: number;
name: string;
}

Type Alias Example


type Product = {
id: number;
name: string;
};

Key Differences

Interfaces can be extended using the extends keyword and support declaration merging. Type aliases cannot be merged but are better suited for union and intersection types.

In large applications, interfaces are preferred for public APIs and object contracts, while type aliases are often used for complex type compositions.

4. Best Practices

Use interfaces for defining object structures and class contracts. Prefer interfaces when designing APIs and shared models.

Use type aliases when working with unions, intersections, or primitive combinations.

Keep interfaces small and focused. Avoid creating large interfaces with too many responsibilities.

Name interfaces clearly to reflect their purpose. Avoid unnecessary prefixes.

Use readonly properties in interfaces when values should not be modified.

Example:


interface Config {
readonly apiUrl: string;
}

Conclusion

Interfaces are a core feature of TypeScript that help enforce consistent object structures and improve maintainability. Understanding how to create, extend, and choose between interfaces and type aliases is essential for professional TypeScript development.