टाइपस्क्रिप्ट में, इंटरफ़ेस एक शक्तिशाली उपकरण है जिसका उपयोग किसी ऑब्जेक्ट के आकार को परिभाषित करने के लिए किया जाता है। वे टाइप-चेकिंग लागू करते हैं, यह सुनिश्चित करते हुए कि आपके द्वारा बनाई गई वस्तुएं एक विशिष्ट संरचना का पालन करती हैं। यहां उन विभिन्न मामलों पर एक नजर डाली गई है जहां इंटरफेस का आमतौर पर उपयोग किया जाता है, उदाहरणों के साथ:

1. वस्तु आकार को परिभाषित करना

इंटरफ़ेस का उपयोग अक्सर किसी ऑब्जेक्ट की संरचना को परिभाषित करने के लिए किया जाता है। यह सुनिश्चित करता है कि इंटरफ़ेस का पालन करने वाली किसी भी वस्तु में विशिष्ट गुण होंगे।

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

const user: User = {
  name: "John Doe",
  age: 30,
  email: "[email protected]"
};

2. वैकल्पिक गुण

इंटरफ़ेस आपको ? का उपयोग करके वैकल्पिक गुणों को परिभाषित करने की अनुमति देता है। प्रतीक। इसका मतलब यह है कि वस्तु में वे गुण हो भी सकते हैं और नहीं भी।

interface Product {
  id: number;
  name: string;
  description?: string; // Optional property
}

const product: Product = {
  id: 1,
  name: "Laptop"
};

3. केवल पढ़ने योग्य गुण

आप गुणों को केवल पढ़ने योग्य के रूप में परिभाषित कर सकते हैं, जिसका अर्थ है कि प्रारंभ होने के बाद उन्हें बदला नहीं जा सकता है।

interface Config {
  readonly apiUrl: string;
  timeout: number;
}

const config: Config = {
  apiUrl: "https://api.example.com",
  timeout: 5000
};

// config.apiUrl = "https://newapi.example.com"; // Error: Cannot assign to 'apiUrl' because it is a read-only property.

4. फ़ंक्शन प्रकार

इंटरफ़ेस का उपयोग फ़ंक्शन के आकार को परिभाषित करने, पैरामीटर प्रकार और रिटर्न प्रकार निर्दिष्ट करने के लिए किया जा सकता है।

interface Login {
  (username: string, password: string): boolean;
}

const login: Login = (username, password) => {
  return username === "admin" && password === "admin123";
};

console.log(login("admin", "admin123")); // true

5. इंटरफ़ेस का विस्तार

इंटरफ़ेस अन्य इंटरफ़ेस का विस्तार कर सकते हैं, जिससे मौजूदा प्रकारों को मिलाकर जटिल प्रकार के निर्माण की अनुमति मिलती है।

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

interface Employee extends Person {
  employeeId: number;
  department: string;
}

const employee: Employee = {
  name: "Alice",
  age: 28,
  employeeId: 12345,
  department: "Engineering"
};

6. कक्षाओं में इंटरफेस लागू करना

कक्षाएं इंटरफ़ेस लागू कर सकती हैं, यह सुनिश्चित करते हुए कि वे इंटरफ़ेस की संरचना का पालन करती हैं।

interface Animal {
  name: string;
  makeSound(): void;
}

class Dog implements Animal {
  name: string;

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

  makeSound() {
    console.log("Woof! Woof!");
  }
}

const dog = new Dog("Buddy");
dog.makeSound(); // Woof! Woof!

7. अनुक्रमणीय प्रकार

इंटरफ़ेस उन वस्तुओं का वर्णन कर सकते हैं जिनमें एक विशिष्ट प्रकार की गतिशील कुंजियों वाले गुण होते हैं।

interface StringArray {
  [index: number]: string;
}

const myArray: StringArray = ["Hello", "World"];
console.log(myArray[0]); // Hello

8. हाइब्रिड प्रकार

इंटरफ़ेस उन वस्तुओं को परिभाषित कर सकते हैं जो एक फ़ंक्शन के रूप में और गुणों के साथ एक ऑब्जेक्ट के रूप में कार्य करते हैं।

interface Counter {
  (start: number): void;
  interval: number;
  reset(): void;
}

const counter: Counter = (function (start: number) {
  console.log("Counter started at", start);
} as Counter);

counter.interval = 1000;
counter.reset = () => {
  console.log("Counter reset");
};

counter(10);
console.log(counter.interval); // 1000
counter.reset();

9. इंटरफ़ेस मर्जिंग

टाइपस्क्रिप्ट आपको एक ही इंटरफ़ेस की कई घोषणाओं को मर्ज करने की अनुमति देता है, जो बड़े कोडबेस या लाइब्रेरी के साथ काम करते समय उपयोगी होता है।

interface Box {
  height: number;
  width: number;
}

interface Box {
  color: string;
}

const myBox: Box = {
  height: 20,
  width: 15,
  color: "blue"
};

टाइपस्क्रिप्ट में इंटरफेस ऑब्जेक्ट आकृतियों को परिभाषित करने और लागू करने के लिए एक लचीला और शक्तिशाली तरीका प्रदान करते हैं, जो मजबूत टाइप-चेकिंग और स्पष्ट, रखरखाव योग्य कोड को सक्षम करते हैं।