टाइपस्क्रिप्ट का उपयोग करके एक एक्शन प्रकार प्राप्त करना

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

यह अल्फा जावास्क्रिप्ट मीटअप पर मेरी रिपोर्ट का एक प्रतिलेख है। आप यहां प्रेजेंटेशन स्लाइड्स से कोड, और यहां प्रसारित माइटैप की रिकॉर्डिंग देख सकते हैं।

हमारे फ्रंट-एंड एप्लिकेशन रिएक्ट + रेडक्स के एक समूह पर चलते हैं। Redux डेटा प्रवाह बस इस तरह दिखता है:


एक्शन क्रिएटर्स हैं - फ़ंक्शंस जो एक्शन लौटाते हैं। एक्शन रेड्यूसर में आते हैं, रेड्यूसर पुराने के आधार पर एक नया पक्ष बनाता है। घटकों को पार्टी में हस्ताक्षरित किया जाता है, जो बदले में नए कार्यों को भेज सकता है - और सब कुछ दोहराता है।

कोड में एक्शन निर्माता कैसा दिखता है:


यह केवल एक फ़ंक्शन है जो एक एक्शन लौटाता है - एक ऑब्जेक्ट जिसमें एक स्ट्रिंग स्ट्रिंग फ़ील्ड और कुछ डेटा (वैकल्पिक) होना चाहिए।

यह वही है जो एक विशिष्ट रेड्यूसर जैसा दिखता है:


यह एक नियमित स्विच-केस है जो एक एक्शन के प्रकार को देखता है और एक नया पक्ष उत्पन्न करता है। ऊपर दिए गए उदाहरण में, यह वहां की कार्रवाई से संपत्ति के मूल्यों को जोड़ता है।

क्या होगा अगर हम गलती से एक reducer लिखने में गलती करते हैं? उदाहरण के लिए, इस तरह, हम विभिन्न कार्यों के गुणों को बदल देंगे:


जावास्क्रिप्ट हमारे कार्यों के बारे में कुछ भी नहीं जानता है और इस तरह के कोड को बिल्कुल वैध मानता है। हालाँकि, यह इरादा के अनुसार काम नहीं करेगा, और हम इस त्रुटि को देखना चाहेंगे। यदि टाइपस्क्रिप्ट नहीं तो क्या हमारी मदद करेगा? आइए हमारे कार्यों को टाइप करने की कोशिश करें।


शुरू करने के लिए, हम अपने कार्यों के लिए "माथे" प्रकार लिखेंगे - Action1Type और Action2Type। और फिर, उन्हें reducer में उपयोग करने के लिए एक संघ प्रकार में संयोजित करें। दृष्टिकोण सरल और सीधा है, लेकिन क्या होगा यदि अनुप्रयोगों के विकास के दौरान कार्यों में डेटा बदल जाए? हर बार मैन्युअल रूप से प्रकार न बदलें। हम उन्हें इस प्रकार लिखते हैं:


टाइपऑफ़ ऑपरेटर हमारे लिए एक्शन क्रिएटर प्रकार लौटाएगा, और रिटर्न टाइप हमें फ़ंक्शन का रिटर्न प्रकार देगा - अर्थात कार्रवाई का प्रकार। नतीजतन, यह ऊपर की स्लाइड के समान होगा, लेकिन अब मैन्युअल रूप से नहीं - जब क्रियाओं को बदलते हुए यूनियन-टाइप एक्शनटेप्स को स्वचालित रूप से अपडेट किया जाएगा। वाह! हम इसे reducer में लिखते हैं और ...


और तुरंत हमें स्क्रिप्ट से त्रुटियां मिलती हैं। इसके अलावा, त्रुटियां पूरी तरह से स्पष्ट नहीं हैं - बार संपत्ति एक्शन फू में अनुपस्थित है, और फू बार में अनुपस्थित है ... ऐसा लगता है कि यह जिस तरह से होना चाहिए? कुछ गड़बड़ लग रहा है। सामान्य तौर पर, माथे का दृष्टिकोण उम्मीद के मुताबिक काम नहीं करता है।

लेकिन यह एकमात्र समस्या नहीं है। कल्पना करें कि समय के साथ, हमारा आवेदन बढ़ेगा, और हमारे पास बहुत सारी क्रियाएं होंगी। बहुत कुछ।


इस मामले में उनके लिए हमारे सामान्य प्रकार क्या दिखेंगे? शायद कुछ इस तरह:


और अगर हम इस बात को ध्यान में रखते हैं कि क्रियाओं को जोड़ दिया जाएगा और हटा दिया जाएगा, तो हमें मैन्युअल रूप से इन सभी का समर्थन करना होगा - प्रकार जोड़ें और हटाएं। यह भी हमें बिल्कुल शोभा नहीं देता। क्या करें? पहली समस्या से शुरू करते हैं।



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



इस प्रकार को शाब्दिक कहा जाता है। शाब्दिक प्रकार तीन प्रकार के होते हैं - न्यूमेरिक, स्ट्रिंग और बूलियन।



उदाहरण के लिए, हमारे पास onlyNumberOne टाइप है और हम निर्दिष्ट करते हैं कि इस प्रकार का एक वेरिएबल केवल संख्या 1 के बराबर हो सकता है - 2 असाइन करें - और टाइपस्क्रिप्ट त्रुटि प्राप्त करें। स्ट्रिंग एक समान तरीके से काम करती है - केवल एक विशिष्ट स्ट्रिंग मान को एक चर को सौंपा जा सकता है। ठीक है, बूलियन या तो सच है या गलत है, अस्पष्टता के बिना।

सामान्य

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



एक जेनेरिक हमें इस स्थिति से बाहर निकलने में मदद करेगा। उपरोक्त प्रविष्टि का मतलब है कि हम एक निश्चित प्रकार T का तर्क पारित कर रहे हैं, और फ़ंक्शन ठीक उसी प्रकार T वापस आएगा। हम नहीं जानते कि यह कौन सा होगा - एक संख्या, एक स्ट्रिंग, बूलियन या कुछ और - लेकिन हम इसकी गारंटी दे सकते हैं यह बिल्कुल उसी प्रकार का होगा। यह विकल्प हमें सूट करता है।

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



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

नीचे फैली और जेनरिक के साथ टाइप किए गए फ़ंक्शन का उपयोग करने के उदाहरण हैं:

• प्रकार स्ट्रिंग का तर्क - फ़ंक्शन स्ट्रिंग वापस करेगा
• प्रकार शाब्दिक स्ट्रिंग का एक तर्क - फ़ंक्शन शाब्दिक स्ट्रिंग लौटाएगा
• यदि तर्क स्ट्रिंग की तरह नहीं दिखता है, उदाहरण के लिए, एक संख्या, या एक सरणी, स्क्रिप्ट त्रुटि देगा।

खैर, और कुल मिलाकर यह काम करता है।


हम अपने फ़ंक्शन को एक्शन के प्रकार में प्रतिस्थापित करते हैं - यह ठीक उसी स्ट्रिंग प्रकार को लौटाता है, लेकिन यह अब स्ट्रिंग नहीं है, लेकिन शाब्दिक स्ट्रिंग है, जैसा कि यह होना चाहिए। हम यूनियन प्रकार एकत्र करते हैं, हम एक reducer टाइप करते हैं - सब कुछ ठीक है। और अगर हम गलती करते हैं और गलत गुण लिखते हैं, तो समय की स्क्रिप्ट हमें दो नहीं, बल्कि एक तार्किक और समझने योग्य त्रुटि देगी:


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


और अंत में: वर्णित समस्या लंबे समय तक गिथब पर जारी रही, और अंत में, टाइपस्क्रिप्ट संस्करण 3.4 में, डेवलपर्स ने हमें एक समाधान के साथ प्रस्तुत किया - कांसेप्ट। इसमें रिकॉर्डिंग के दो रूप हैं:


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



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


कहाँ से शुरू करें? मान लीजिए कि हमारे पास एक फ़ाइल से एक साथ आयात किए गए एक्शन निर्माता हैं। हम एक-एक करके उनके चारों ओर जाना चाहेंगे, उनके कार्यों के प्रकारों को कम करेंगे और उन्हें एक संघ प्रकार में इकट्ठा करेंगे। और सबसे महत्वपूर्ण बात, हम मैन्युअल रूप से संपादन प्रकार के बिना, यह स्वचालित रूप से करना चाहते हैं।


एक्शन क्रिएटर्स के आसपास जाने से शुरू करते हैं। ऐसा करने के लिए, एक विशेष मैप्ड प्रकार है जो कुंजी-मूल्य संग्रह का वर्णन करता है। यहाँ एक उदाहरण है:


यह ऑब्जेक्ट के लिए एक प्रकार बनाता है जिसकी कुंजियाँ विकल्प 1 और विकल्प 2 (कीज़ सेट से) हैं, और मान सही या गलत हैं। अधिक सामान्य संस्करण में, इसे एक प्रकार के मैपऑफबूल के रूप में दर्शाया जा सकता है - कुछ प्रकार की पंक्ति कुंजियों और बूलियर मूल्यों के साथ एक वस्तु।

सब ठीक है। लेकिन हम यह कैसे सत्यापित कर सकते हैं कि यह एक वस्तु है जो हमें इनपुट पर दी गई है, न कि किसी अन्य प्रकार से? सशर्त प्रकार, प्रकारों की दुनिया में एक सरल गुठली, इससे हमें मदद मिलेगी।


इस उदाहरण में, हम जांचते हैं: टाइप T में स्ट्रिंग के साथ कुछ सामान्य है? यदि हाँ, तो स्ट्रिंग वापस करें, और यदि नहीं, तो कभी वापस न करें। यह एक ऐसा विशेष प्रकार है जो हमेशा हमें एक त्रुटि लौटाएगा। स्ट्रिंग शाब्दिक टर्नरी स्थिति को संतुष्ट करता है। यहाँ कुछ नमूना कोड हैं:


अगर हम जेनेरिक में कुछ निर्दिष्ट करते हैं जो स्ट्रिंग की तरह नहीं है, तो टाइपस्क्रिप्ट हमें एक त्रुटि देगा।

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


खैर, अब इसे एक साथ रखना बाकी है।

यह इस डिजाइन को पूरा करता है:


तर्क लगभग निम्नलिखित है: यदि T एक ऑब्जेक्ट की तरह दिखता है जिसमें कुछ स्ट्रिंग कुंजी (एक्शन क्रिएटर नाम) हैं, और उनके पास कुछ प्रकार के मान हैं (एक फ़ंक्शन जो हमें कार्रवाई वापस करेगा), तो इन जोड़ों को बायपास करने का प्रयास करें, इन मानों के प्रकार को घटाएं और उनके सामान्य प्रकार को कम करें। और अगर कुछ गलत हो जाता है - एक विशेष त्रुटि (प्रकार कभी नहीं) को बाहर फेंक दें।

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


हम एक्शन क्रिएटर्स को एक्शन के रूप में आयात करते हैं, उनका रिटर्न टाइप (रिटर्न वैल्यू का प्रकार एक्शन है) लेते हैं, और हमारे विशेष प्रकार का उपयोग करके इकट्ठा करते हैं। यह वही निकला जो आवश्यक था।


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