टाइपप्रति टुपल प्रकार

टाइपस्क्रिप्ट टुपल्स पर करीब से नज़र डालें

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

एक सरल उदाहरण दिखाता है कि टाइपस्क्रिप्ट में टुपल्स को कैसे परिभाषित किया जाता है।

// This tuple is defined as a set
// of two numbers.
const scores: [number, number] = [1, 2];

// For comparison, this tuple consists
// of three elements, each of a different
// type. Not that the ordered nature of
// tuples in TS becomes very clear here.
const result: [string, number, boolean] = ["id", 101, false];

// And as a "nice-to-know", you can even
// provide lables for the tuple elements.
// This doesn't have any effect on the typesystem
// itself and only (may) improve documentation.
const output: [id: number, name: string] = [101, "Tom"];

वैकल्पिक तत्वों के साथ टुपल्स

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

एक और उदाहरण दर्शाता है कि मेरा क्या मतलब है।

// Similar to our previous example, but in this
// case the the tuple's last element doesn't have
// to be provided (or can be undefined at runtime).
type Tuple = [id: number, name?: string];

const a: Tuple = [101];
const b: Tuple = [42, "Tom"];

टाइपप्रति टुपल्स में बाकी तत्व

बाकी तत्वों के साथ, आपके पास एक बहुत शक्तिशाली प्रकार है जो किसी दिए गए प्रकार के टपल में सभी निम्नलिखित तत्वों को चिह्नित करता है। तो मान लें कि आपके पास दो तत्वों के साथ एक टुपल है और दूसरा एक बाकी तत्व के रूप में परिभाषित है, फिर आप इस टुपल वैरिएबल को रनटाइम पर 2 + n तत्व प्रदान कर सकते हैं।

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

// This example might be a tuple type
// for a CLI similar to Node.js. The first
// two elements are system-internal.
//
// Starting from the 3rd element, a user can
// provide as much arguments as desired, yet
// we can still cleanly handle it with TS. Nice!
let input: [number, boolean, ...string[]];

// Just to show that we really can provide any
// number of rest elements, including 0.
e = [0, false, "max-cache", "1024", "debug", "false"];
e = [0, false];
e = [0, false, "verbose"];

टपल प्रकारों में अग्रणी या मध्य विश्राम तत्व

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

लेकिन केवल कुछ प्रतिबंधों के साथ, टाइपस्क्रिप्ट अब उन्नत टुपल्स के लिए एक बहुत अच्छा सिंटैक्स प्रदान करता है। जब तक वे निम्नलिखित दो नियमों का पालन करते हैं, तब तक बाकी तत्व टुपल के भीतर कहीं भी हो सकते हैं:

• इसके बाद एक वैकल्पिक तत्व नहीं है
• कोई अन्य बाकी तत्व पहले वाले का अनुसरण नहीं करता है

बहुत अधिक सिद्धांत पर बात करने से पहले, आइए एक उदाहरण के लिए देखें।

// And here comes the fancy part: rest elements
// *not only* at the end of a tuple.
// 
// Note: this example is taken directly from the
// TS documentation. For more details, check out the
// links in the addendum.
let foo: [...string[], number];

foo = [123];
foo = ["hello", 123];
foo = ["hello!", "hello!", "hello!", 123];

let bar: [boolean, ...string[], boolean];

bar = [true, false];
bar = [true, "some text", false];
bar = [true, "some", "separated", "text", false];

// And here's an example that shows how the
// type system would catch your errors:
interface Clown { /*...*/ }
interface Joker { /*...*/ }

let StealersWheel: [...Clown[], "me", ...Joker[]];
//                                    ~~~~~~~~~~ Error!
// A rest element cannot follow another rest element.

let StringsAndMaybeBoolean: [...string[], boolean?];
//                                        ~~~~~~~~ Error!
// An optional element cannot follow a rest element.

इस लेख के बाकी तत्व

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