टाइपस्क्रिप्ट में एक्सटेंडेड कीवर्ड एक प्रकार का स्विस आर्मी चाकू है। इसका उपयोग कई संदर्भों में किया जाता है, जिसमें वंशानुक्रम, जेनेरिक और सशर्त प्रकार शामिल हैं। एक्सटेंड का प्रभावी ढंग से उपयोग करने के तरीके को समझने से अधिक मजबूत, पुन: प्रयोज्य और प्रकार-सुरक्षित कोड प्राप्त हो सकता है।

विस्तार का उपयोग करके वंशानुक्रम

एक्सटेंड के प्राथमिक उपयोगों में से एक इनहेरिटेंस में है, जो आपको नए इंटरफेस या कक्षाएं बनाने की अनुमति देता है जो मौजूदा इंटरफेस पर आधारित होते हैं।

interface User {
  firstName: string;
  lastName: string;
  email: string;
}

interface StaffUser extends User {
  roles: string[];
  department: string;
}

const regularUser: User = {
  firstName: "John",
  lastName: "Doe",
  email: "[email protected]"
};

const staffMember: StaffUser = {
  firstName: "Jane",
  lastName: "Smith",
  email: "[email protected]",
  roles: ["Manager", "Developer"],
  department: "Engineering"
};

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

वर्ग विरासत

विस्तारित कीवर्ड का उपयोग क्लास इनहेरिटेंस के लिए भी किया जाता है:

class Animal {
  constructor(public name: string) {}

  makeSound(): void {
    console.log("Some generic animal sound");
  }
}

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    super(name);
  }

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

  fetch(): void {
    console.log(`${this.name} is fetching the ball!`);
  }
}

const myDog = new Dog("Buddy", "Golden Retriever");
myDog.makeSound(); // Output: Woof! Woof!
myDog.fetch(); // Output: Buddy is fetching the ball!

यहां, कुत्ता पशु का विस्तार करता है, उसके गुणों और तरीकों को विरासत में लेता है, और अपना खुद का भी जोड़ता है।

जेनेरिक में बाधाएँ टाइप करें

एक्सटेंड्स कीवर्ड जेनेरिक के साथ काम करते समय महत्वपूर्ण है, जो हमें उन प्रकारों को सीमित करने की अनुमति देता है जिनका उपयोग जेनेरिक फ़ंक्शन या क्लास के साथ किया जा सकता है।

interface Printable {
  print(): void;
}

function printObject(obj: T) {
  obj.print();
}

class Book implements Printable {
  print() {
    console.log("Printing a book.");
  }
}

class Magazine implements Printable {
  print() {
    console.log("Printing a magazine.");
  }
}

const myBook = new Book();
const myMagazine = new Magazine();

printObject(myBook);      // Output: Printing a book.
printObject(myMagazine);  // Output: Printing a magazine.
// printObject(42);       // Error, number doesn't have a 'print' method

1. इंटरफ़ेस प्रिंट करने योग्य: यहां, हम प्रिंट करने योग्य नामक एक इंटरफ़ेस परिभाषित करते हैं। यह इंटरफ़ेस एक अनुबंध घोषित करता है जिसे लागू करने वाले किसी भी वर्ग को इसका पालन करना होगा। अनुबंध निर्दिष्ट करता है कि प्रिंट करने योग्य को लागू करने वाले किसी भी वर्ग को प्रिंट नामक एक विधि प्रदान करनी होगी जो कोई तर्क नहीं लेती है और शून्य लौटाती है
2. फ़ंक्शन प्रिंटऑब्जेक्ट(obj: T): यह प्रिंटऑब्जेक्ट नाम का एक सामान्य फ़ंक्शन है। यह ओबीजे नामक एक एकल तर्क लेता है, जो प्रकार टी है। टाइप पैरामीटर टी उन प्रकारों तक सीमित है जो प्रिंट करने योग्य इंटरफ़ेस को विस्तारित (कार्यान्वयन) करते हैं, जिसे इस फ़ंक्शन के तर्क के रूप में उपयोग किया जा सकता है।
3. क्लास बुक प्रिंट करने योग्य को लागू करता है और क्लास मैगज़ीन प्रिंट करने योग्य को लागू करता है: यहां, हम दो वर्गों, बुक और मैगज़ीन को परिभाषित करते हैं, जो दोनों प्रिंट करने योग्य इंटरफ़ेस को लागू करते हैं। इसका मतलब यह है कि इन वर्गों को प्रिंट करने योग्य इंटरफ़ेस के अनुबंध के अनुसार एक प्रिंट विधि प्रदान करनी होगी।
4. स्थिरांक myBook = नई पुस्तक(); और const myMagazine = new Magazine();: हम पुस्तक और पत्रिका कक्षाओं के उदाहरण बनाते हैं।
5. प्रिंटऑब्जेक्ट(मायबुक); और printObject(myMagazine);: हम पुस्तक और पत्रिका के उदाहरणों के साथ printObject फ़ंक्शन को कॉल करते हैं। चूँकि पुस्तक और पत्रिका दोनों वर्ग प्रिंट करने योग्य इंटरफ़ेस को लागू करते हैं, वे टी एक्सटेंड्स प्रिंट करने योग्य प्रकार पैरामीटर की बाधा को पूरा करते हैं। फ़ंक्शन के अंदर, उपयुक्त वर्ग की प्रिंट विधि को कॉल किया जाता है, जिसके परिणामस्वरूप अपेक्षित आउटपुट मिलता है।
6. // printObject(42);: यदि हम printObject को ऐसे प्रकार से कॉल करने का प्रयास करते हैं जो प्रिंट करने योग्य इंटरफ़ेस को लागू नहीं करता है, जैसे संख्या 42, तो टाइपस्क्रिप्ट एक त्रुटि उत्पन्न करेगा। ऐसा इसलिए है क्योंकि प्रकार की बाधा संतुष्ट नहीं है, क्योंकि प्रिंट करने योग्य इंटरफ़ेस के अनुसार संख्या में प्रिंट विधि नहीं है।

संक्षेप में, फ़ंक्शन प्रिंटऑब्जेक्ट(ओबीजे: टी) के संदर्भ में एक्सटेंडेड कीवर्ड का उपयोग यह सुनिश्चित करने के लिए किया जाता है कि तर्क के रूप में उपयोग किया जाने वाला प्रकार टी प्रिंटेबल इंटरफ़ेस द्वारा परिभाषित अनुबंध का पालन करता है। यह सुनिश्चित करता है कि प्रिंटऑब्जेक्ट फ़ंक्शन के साथ केवल प्रिंट विधि वाले प्रकारों का उपयोग किया जा सकता है, जो फ़ंक्शन के उपयोग के लिए एक विशिष्ट व्यवहार और अनुबंध को लागू करता है।

सशर्त प्रकार

T extends U ? X : Y

• T वह प्रकार है जिसकी जाँच की जा रही है
• U वह शर्त प्रकार है जिसके विरुद्ध T की जाँच की जा रही है।
• एक्स वह प्रकार है जिसका सशर्त प्रकार मूल्यांकन करता है यदि टी यू का विस्तार करता है (उसे सौंपा जा सकता है)।
• Y वह प्रकार है जिसका सशर्त प्रकार मूल्यांकन करता है यदि T, U का विस्तार नहीं करता है

type ExtractNumber = T extends number ? T : never;

type NumberOrNever = ExtractNumber; // number
type StringOrNever = ExtractNumber; // never

यहां, ExtractNumber प्रकार एक प्रकार का पैरामीटर T लेता है। सशर्त प्रकार यह जांचता है कि T संख्या प्रकार का विस्तार करता है या नहीं। यदि ऐसा होता है, तो प्रकार T (जो कि संख्या प्रकार है) में परिवर्तित हो जाता है। यदि ऐसा नहीं होता है, तो प्रकार कभी नहीं का समाधान करता है।

यूनियन प्रकारों के साथ कीवर्ड का विस्तार होता है

अब, आइए अभिव्यक्ति ए | पर विचार करें बी | सी, ए का विस्तार करता है। यह पहली बार में उल्टा लग सकता है, लेकिन टाइपस्क्रिप्ट में, यह स्थिति वास्तव में गलत है। उसकी वजह यहाँ है:

1. टाइपस्क्रिप्ट में, जब आप बाईं ओर यूनियन प्रकार के साथ एक्सटेंड का उपयोग करते हैं, तो यह पूछने के बराबर है: "क्या इस यूनियन में हर संभव प्रकार दाईं ओर के प्रकार के लिए असाइन किया जा सकता है?"
2. दूसरे शब्दों में, ए | बी | C का विस्तार A पूछ रहा है: "क्या A को A को सौंपा जा सकता है, और क्या B को A को सौंपा जा सकता है, और क्या C को A को सौंपा जा सकता है?"
3. हालांकि ए को निश्चित रूप से ए को सौंपा जा सकता है, बी और सी को ए को सौंपा नहीं जा सकता (जब तक कि वे ए के उपप्रकार न हों), इसलिए समग्र परिणाम गलत है।

type Fruit = "apple" | "banana" | "cherry";
type CitrusFruit = "lemon" | "orange";

type IsCitrus = T extends CitrusFruit ? true : false;

type Test1 = IsCitrus; // true
type Test2 = IsCitrus; // false
type Test3 = IsCitrus; // false

इस उदाहरण में, IsCitrus गलत है क्योंकि फ्रूट यूनियन में सभी फल CitrusFruit नहीं हैं।

सर्वोत्तम अभ्यास और युक्तियाँ

• सार्थक संबंधों के लिए उपयोग का विस्तार: वंशानुक्रम का उपयोग केवल तभी करें जब प्रकारों के बीच स्पष्ट "is-a" संबंध हो।
• विरासत की तुलना में रचना को प्राथमिकता दें: कई मामलों में, संरचना (इंटरफ़ेस और प्रकार के प्रतिच्छेदन का उपयोग करके) वर्ग विरासत की तुलना में अधिक लचीली हो सकती है।
• गहरी विरासत श्रृंखलाओं से सावधान रहें: गहरी विरासत से कोड को समझना और बनाए रखना कठिन हो सकता है।
• लचीली एपीआई के लिए सशर्त प्रकारों का लाभ उठाएं: इनपुट प्रकारों के आधार पर अनुकूलित एपीआई बनाने के लिए विस्तार के साथ सशर्त प्रकारों का उपयोग करें।
• पुन: प्रयोज्य, प्रकार-सुरक्षित फ़ंक्शन बनाने के लिए जेनेरिक में उपयोग का विस्तार: यह आपको ऐसे फ़ंक्शन लिखने की अनुमति देता है जो प्रकार की सुरक्षा बनाए रखते हुए विभिन्न प्रकारों के साथ काम करते हैं