टाइपस्क्रिप्ट में नाममात्र टाइपिंग या विदेशी पहचानकर्ताओं से अपने इंटरफ़ेस की सुरक्षा कैसे करें

हाल ही में, अपने घर की परियोजना की खराबी के कारणों का अध्ययन करते हुए, मैंने एक बार फिर एक गलती देखी जो अक्सर थकान के कारण दोहराती है। त्रुटि का सार यह है कि एक कोड ब्लॉक में कई पहचानकर्ता होने पर, जब मैं किसी फ़ंक्शन को कॉल करता हूं, तो मैं किसी अन्य प्रकार के ऑब्जेक्ट के पहचानकर्ता को पास करता हूं। इस लेख में मैं टाइपस्क्रिप्ट का उपयोग करके इस समस्या को हल करने के बारे में बात करूंगा।

सिद्धांत की बिट

टाइपस्क्रिप्ट संरचनात्मक टाइपिंग पर आधारित है, जो जावास्क्रिप्ट की बतख विचारधारा के साथ अच्छी तरह से फिट बैठता है। इस बारे में पर्याप्त संख्या में लेख लिखे गए हैं। मैं उन्हें नहीं दोहराऊंगा, मैं केवल नाममात्र टाइपिंग से मुख्य अंतर को रेखांकित करूंगा, जो अन्य भाषाओं में अधिक सामान्य है। आइए एक छोटा उदाहरण देखें।

class Car { id: number; numberOfWheels: number; move (x: number, y: number) { //   } } class Boat { id: number; move (x: number, y: number) { //   } } let car: Car = new Boat(); //  TypeScript   let boat: Boat = new Car(); //        

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

टाइपिंग आइडेंटिफ़ायर

सबसे पहले, हम पहचानकर्ताओं के लिए प्रकार निर्धारित करेंगे

 type CarId: number; type BoatId: number; 

और इन प्रकारों का उपयोग करके कक्षाओं को फिर से लिखना।

 class Car { id: CarId; numberOfWheels: number; move (x: number, y: number) { //   } } class Boat { id: BoatId; move (x: number, y: number) { //   } } 

आप देखेंगे कि स्थिति बहुत नहीं बदली है, क्योंकि हमारे पास अभी भी इस पर नियंत्रण नहीं है कि हमें पहचानकर्ता कहां से मिला है, और आप सही होंगे। लेकिन यह उदाहरण पहले से ही कुछ फायदे देता है।

1. कार्यक्रम के विकास के दौरान, पहचानकर्ता का प्रकार अचानक बदल सकता है। इसलिए, उदाहरण के लिए, परियोजना के लिए विशिष्ट एक निश्चित कार संख्यात्मक संख्या को स्ट्रिंग VIN नंबर से बदला जा सकता है। पहचानकर्ता के प्रकार को निर्दिष्ट किए बिना, आपको उन सभी स्थानों पर स्ट्रिंग के साथ संख्या को बदलना होगा जहां यह होता है। प्रकार के कार्य के साथ, परिवर्तन केवल एक ही स्थान पर करने की आवश्यकता होगी जहां प्रकार स्वयं निर्धारित किया जाता है।

   
   

2. फ़ंक्शन को कॉल करते समय, हम अपने कोड संपादक से संकेत प्राप्त करते हैं, किस प्रकार के पहचानकर्ता होने चाहिए। मान लीजिए कि हमारे पास निम्नलिखित कार्य हैं:

   
   

    function getCarById(id: CarId): Car { // ... } function getBoatById(id: BoatId): Boat { // ... } 

   
   

   तब हमें संपादक से एक संकेत मिलेगा कि हमें न केवल एक नंबर, बल्कि CarId या BoatId प्रसारित करना चाहिए।

   
   

सबसे सख्त टाइपिंग का अनुकरण करें

टाइपस्क्रिप्ट में कोई नाममात्र टाइपिंग नहीं है, लेकिन हम इसके व्यवहार का अनुकरण कर सकते हैं, जिससे किसी भी प्रकार को अद्वितीय बनाया जा सकता है। ऐसा करने के लिए, टाइप करने के लिए एक अद्वितीय गुण जोड़ें। इस ट्रिक को ब्रांडिंग शब्द के तहत अंग्रेजी-भाषा के लेखों में संदर्भित किया गया है, और यहाँ पर ऐसा दिखता है:

 type BoatId = number & { _type: 'BoatId'}; type CarId = number & { _type: 'CarId'}; 

यह बताते हुए कि हमारे प्रकार एक अद्वितीय मूल्य के साथ एक संपत्ति के साथ एक संख्या और एक वस्तु दोनों होने चाहिए, हमने संरचनात्मक टाइपिंग को समझने में अपने प्रकार को असंगत बना दिया। आइए देखें कि यह कैसे काम करता है।

 let carId: CarId; let boatId: BoatId; let car: Car; let boat: Boat; car = getCarById(carId); // OK car = getCarById(boatId); // ERROR boat = getBoatById(boatId); // OK boat = getBoatById(carId); // ERROR carId = 1; // ERROR boatId = 2; // ERROR car = getCarById(3); // ERROR boat = getBoatById(4); // ERROR 

अंतिम चार लाइनों को छोड़कर सब कुछ अच्छा लग रहा है। पहचानकर्ता बनाने के लिए, आपको एक सहायक फ़ंक्शन की आवश्यकता है:

 function makeCarIdFromVin(id: number): CarId { return vin as any; } 

इस पद्धति का नुकसान यह है कि यह फ़ंक्शन रनटाइम में रहेगा।

मजबूत टाइपिंग करना थोड़ा कम सख्त है

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

 interface Flavoring<FlavorT> { _type?: FlavorT; } export type Flavor<T, FlavorT> = T & Flavoring<FlavorT>; 

अब आप निम्नानुसार पहचानकर्ताओं के लिए प्रकार निर्धारित कर सकते हैं:

 type CarId = Flavor<number, “CarId”> type BoatId = Flavor<number, “BoatId”> 

चूंकि _type गुण वैकल्पिक है, आप एक अंतर्निहित रूपांतरण का उपयोग कर सकते हैं:

 let boatId: BoatId = 5; // OK let carId: CarId = 3; // OK 

और हम अभी भी पहचानकर्ताओं को नहीं मिला सकते हैं:

 let carId: CarId = boatId; // ERROR 

कौन सा विकल्प चुनना है

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

सूत्रों का कहना है

1. प्रारंभिक बिंदु stackoverflow.com
2. लेख की नि: शुल्क व्याख्या