Types

Types in TypeScript allow you to define custom data structures and enforce specific constraints on the data. They are similar to interfaces but offer additional features.

Example Type:

type User = {
    firstName: string;
    lastName: string;
    age: number;
};

1. Unions

Unions allow you to specify that a value can be one of several types. This is useful when a variable or parameter can accept multiple data types.

Example:

type StringOrNumber = string | number;

function printId(id: StringOrNumber) {
    console.log(`ID: ${id}`);
}

printId(101);     // Output: ID: 101
printId("202");   // Output: ID: 202

2. Intersection

Intersection types combine multiple types into one. This allows you to create a type that has all properties of the individual types.

Example:

type Employee = {
    name: string;
    startDate: Date;
};

type Manager = {
    name: string;
    department: string;
};

type TeamLead = Employee & Manager;

const teamLead: TeamLead = {
    name: "harkirat",
    startDate: new Date(),
    department: "Software developer"
};

In this example, TeamLead is an intersection of Employee and Manager, meaning it must have all properties defined in both types.

3. Type Aliases

Type aliases allow you to create custom names for types, making your code more readable and maintainable.

Example:

type Point = {
    x: number;
    y: number;
};

type Rectangle = {
    topLeft: Point;
    bottomRight: Point;
};

const rect: Rectangle = {
    topLeft: { x: 0, y: 0 },
    bottomRight: { x: 10, y: 10 }
};

4. Literal Types

Literal types allow you to specify exact values that a variable can have.

Example:

type Color = "red" | "green" | "blue";

function printColor(color: Color) {
    console.log(`Selected color: ${color}`);
}

printColor("red");   // Output: Selected color: red

Summary

• Types in TypeScript allow you to define custom data structures and enforce specific constraints on the data.

• Unions and intersections provide flexibility in specifying variable types and combining multiple types.

• Type aliases improve code readability by creating custom names for complex types.

• Literal types allow you to specify exact values that variables can have, enhancing type safety and expressiveness in your code.