TypeScript Type Aliases and Interfaces Explained

If tutorials available on this website are helpful for you, please whitelist this website in your ad blocker😭 or Donate to help us ❤️ pay for the web hosting to keep the website running.

अगर आप TypeScript use करते हो, तो आपको Type Aliases और Interfaces के बारे में ज़रूर जानना चाहिए। दोनो ही features TypeScript में types define करने के काम आते हैं, but कुछ subtle differences हैं जो समझना जरूरी है।

इस blog में, हम detail में देखेंगे कि Type Aliases और Interfaces क्या होते हैं, कब use करते हैं, और इनके बीच के फर्क को समझेंगे।

●●●

TypeScript Type Aliases

Type Aliases TypeScript में custom types बनाने के लिए use होते हैं , यह आपको types को एक नाम देने की flexibility देते हैं, जो complex types को बार - बार लिखने से बचाता है।

Syntax

Copy
type NewTypeName = ExistingType;

इसका मतलब है कि NewTypeName को हमने ExistingType के लिए एक alias बना दिया। अब हम NewTypeName को existing type के जगह पर use कर सकते हैं।

Example

Copy
type StringOrNumber = string | number;

let age: StringOrNumber = 25;
let name: StringOrNumber = "John";

StringOrNumber एक union type है जिसमे string या number allowed है।

Complex Type Alias Example

Copy
type User = {
    name: string;
    age: number;
    isAdmin: boolean;
};

let adminUser: User = {
    name: "Jane Doe",
    age: 28,
    isAdmin: true
};

यहां पर हमने एक complex object type alias बनाया जो User के नाम से जाना जाता है , इस object में teen properties हैं: name, age, और isAdmin.

●●●

TypeScript Interfaces

TypeScript में Interfaces भी एक तरह का type होता है जो object structure को define करता है। Interfaces को use करने का advantage यह है कि यह object-oriented style में type-checking provide करते हैं, और inheritance जैसे features को support करते हैं।

Syntax

Copy
interface InterfaceName {
    propertyName: Type;
}

Example : Simple Interface

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

let person1: Person = {
    name: "John",
    age: 30
};

यहां हमने एक Person interface define किया जो कि एक object का structure define करता है। name और age properties होनी चाहिए हर object में जो Person type का होगा।

TypeScript Interface Inheritance Example

Copy
interface Employee extends Person {
    employeeId: number;
}

let employee1: Employee = {
    name: "Sarah",
    age: 32,
    employeeId: 101
};

इस example में, Employee interface Person से extend करता है, मतलब Employee के पास name और age के साथ employeeId भी होगा।

●●●

TypeScript Type Aliases vs Interfaces

अब सवाल आता है कि Type Aliases और Interfaces में से कब क्या use करें? दोनो ही features type definition के लिए powerful हैं, लेकिन कुछ cases में आपको एक का दूसरे पर preference देना होगा।

Use Case : Type Aliases

1. Union or Intersection Types : अगर आपको union या intersection types define करना है, तो आपको Type Aliases use करना चाहिए।

Copy
type Status = "success" | "error" | "loading";

2. Primitive Values Alias : अगर आप primitive types को group करना चाहते हो, तो Type Alias better choice है।

Copy
type ID = number | string;

3. Complex Types : Nested or complex types को Type Alias में define करना ज़्यादा readable होता है।

Copy
type Callback = (value: number) => void;

TypeScript Use Case : Interfaces

1. Objects और Methods को Define करना : Interfaces काफी useful होते हैं जब आपको objects के structure और methods को define करना होता है।

Copy
interface Car {
    model: string;
    speed(): void;
}

2. Extending Interfaces : अगर आपको एक interface को inherit करना है, मतलब extend करके new properties या methods देने हैं, तो interfaces को prefer करना चाहिए।

Copy
interface Vehicle {
    wheels: number;
}

interface Bike extends Vehicle {
    handleType: string;
}

3. Classes के साथ काम करना : TypeScript में interfaces काफी useful होते हैं जब आप classes के structure को define करते हो।

●●●

Example : Type Alias & Interface

कभी-कभी आपको दोनो को mix करके भी use करना पड़ता है , यह flexibility TypeScript provide करता है।

Copy
type Role = "admin" | "user";

interface User {
    name: string;
    role: Role;
}

let user1: User = {
    name: "Alice",
    role: "admin"
};

यहां Role को type alias कि तरह define किया गया है, जबकि User को interface के रूप में use किया गया है।

●●●

Conclusion

दोनो Type Aliases और Interfaces TypeScript में types define करने के लिए powerful tools हैं। Type Aliases को आप तब use करें जब आपको union types या complex types banana हो।

वही Interfaces को तब use करें जब आपको object structures या inheritance define करना हो।

बाकि आपके use case पर depend करता है कि आपको कौनसा choose करना है ।