TypeScript Interface and Types

Introduction

Creating and using functions is a fundamental aspect of any programming language, and TypeScript is no different. Today, we are going to explore Interfaces and Types in TypeScript. While TypeScript shares a similar syntax with JavaScript, it introduces type safety and additional features that improve code maintainability and readability.

Interfaces in TypeScript

An interface in TypeScript is a syntactical contract that an entity must adhere to. It defines a standard structure that implementing classes or objects must follow. However, it does not contain any implementation details.

Key Features of Interfaces:

• Defines the structure of an object.

• Only contains property and method declarations, without implementations.

• Can be implemented by classes or extended by other interfaces.

Example of an Interface:

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

interface Manager {
    department: string;
}

In the above example, we have two interfaces: User and Manager, defining the required properties.

Implementing Interfaces in Objects:

let employee: User = {
    name: "John Doe",
    age: 30
};

The employee object strictly follows the User interface, ensuring type safety.

Extending Interfaces:

Interfaces can be extended to create new interfaces with additional properties.

interface TeamLead extends User, Manager {}

let teamLead: TeamLead = {
    name: "Alice",
    age: 35,
    department: "Engineering"
};

Here, TeamLead extends both User and Manager, so any object following TeamLead must include properties from both.

Types in TypeScript

The Type System in TypeScript describes the various types used in the language. These types can be categorized into three main sections:

1. Any Type

The any type allows a variable to hold values of any type. While it provides flexibility, it negates TypeScript's type-checking benefits.

let randomValue: any = "Hello";
randomValue = 42;
randomValue = true;

2. Built-In Types

TypeScript includes built-in types such as:

• string

• number

• boolean

• null

• undefined

• void

Example:

let username: string = "Nehal";
let userAge: number = 24;
let isActive: boolean = true;

3. User-Defined Types

Apart from built-in types, TypeScript allows defining custom types using type aliases.

Using Type Aliases:

type Employee = {
    name: string;
    age: number;
    position: string;
};

let dev: Employee = {
    name: "Nehal",
    age: 24,
    position: "Software Developer"
};

Combining Types (Union & Intersection):

• Union Types: A variable can hold multiple types.

let id: string | number;
id = 101;
id = "A102";

• Intersection Types: Combines multiple types.

type Manager = {
    department: string;
};

type TeamLead = User & Manager;

let lead: TeamLead = {
    name: "Sophia",
    age: 40,
    department: "IT"
};

Conclusion

Understanding Interfaces and Types in TypeScript is crucial for writing clean, maintainable, and scalable code.

• Interfaces define object structure and can be extended or implemented.

• Types allow flexibility in defining custom types, including unions and intersections.

By leveraging TypeScript’s powerful type system, developers can improve code quality and prevent potential runtime errors. Happy coding!