टाइपस्क्रिप्ट की घोषणा 3.3 आर.सी.

आज हम टाइपस्क्रिप्ट 3.3 के हमारे रिलीज़ उम्मीदवार (RC) की उपलब्धता की घोषणा करते हुए खुश हैं। हमारी उम्मीद है कि फीडबैक और शुरुआती मुद्दों को एकत्र करना सुनिश्चित करने के लिए हमारी अंतिम रिलीज़ को तुरंत लेने और उपयोग करने के लिए सरल है।

ब्लॉग में मूल

आरसी का उपयोग शुरू करने के लिए, आप इसे NuGet के माध्यम से प्राप्त कर सकते हैं, या निम्न कमांड के साथ npm का उपयोग कर सकते हैं:

npm install -g typescript@rc 

आप संपादक द्वारा सहायता भी प्राप्त कर सकते हैं

• विजुअल स्टूडियो 2017 के लिए डाउनलोड करना (संस्करण 15.2 या बाद के संस्करण के लिए)
• विज़ुअल स्टूडियो कोड और उदात्त पाठ के लिए निम्नलिखित निर्देश।

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

यूनियन प्रकारों को कॉल करने के लिए बेहतर व्यवहार

जब टाइपस्क्रिप्ट में एक यूनियन टाइप A | B A | B , यह आपको A और B दोनों (यानी सदस्यों के प्रतिच्छेदन) के लिए सभी संपत्तियों को आम तक पहुंचने की अनुमति देता है।

 interface A { aProp: string; commonProp: string; } interface B { bProp: number; commonProp: number } type Union = A | B; declare let x: Union; x.aProp; // error - 'B' doesn't have the property 'aProp' x.bProp; // error - 'A' doesn't have the property 'bProp' x.commonProp; // okay! Both 'A' and 'B' have a property named `commonProp`. 

इस व्यवहार को सहज महसूस करना चाहिए - आप केवल एक यूनियन प्रकार की संपत्ति प्राप्त कर सकते हैं यदि यह यूनियन के प्रत्येक प्रकार में जाना जाता है।

गुणों के एक्सेस के बजाय, हम कॉलिंग प्रकारों के साथ क्या कर रहे हैं? खैर, जब हर प्रकार के समान मापदंडों के साथ एक ही हस्ताक्षर होता है, तो चीजें बस काम करती हैं और आप इन प्रकारों को कॉल कर सकते हैं।

 type CallableA = (x: boolean) => string; type CallableB = (x: boolean) => number; type CallableUnion = CallableA | CallableB; declare let f: CallableUnion; let x = f(true); // Okay! Returns a 'string | number'. 

हालांकि, यह प्रतिबंध कभी-कभी, अच्छी तरह से, अत्यधिक प्रतिबंधात्मक था।

 type Fruit = "apple" | "orange"; type Color = "red" | "orange"; type FruitEater = (fruit: Fruit) => number; // eats and ranks the fruit type ColorConsumer = (color: Color) => string; // consumes and describes the colors declare let f: FruitEater | ColorConsumer; // Cannot invoke an expression whose type lacks a call signature. // Type 'FruitEater | ColorConsumer' has no compatible call signatures.ts(2349) f("orange"); 

एक तरफ मूर्खतापूर्ण उदाहरण और खराब त्रुटि संदेश, FruitEater एस और FruitEater दोनों को स्ट्रिंग "orange" लेने में सक्षम होना चाहिए, और एक number या एक string ।

टाइपस्क्रिप्ट 3.3 में, यह अब कोई त्रुटि नहीं है।

 type Fruit = "apple" | "orange"; type Color = "red" | "orange"; type FruitEater = (fruit: Fruit) => number; // eats and ranks the fruit type ColorConsumer = (color: Color) => string; // consumes and describes the colors declare let f: FruitEater | ColorConsumer; f("orange"); // It works! Returns a 'number | string'. f("apple"); // error - Argument of type '"apple"' is not assignable to parameter of type '"orange"'. f("red"); // error - Argument of type '"red"' is not assignable to parameter of type '"orange"'. 

टाइपस्क्रिप्ट 3.3 में, नए हस्ताक्षर बनाने के लिए इन हस्ताक्षरों के मापदंडों को एक साथ रखा गया है। ऊपर दिए गए उदाहरण में, पैरामीटर fruit और color को एक साथ नए प्रकार के Fruit & Color । Fruit & Color वास्तव में ("apple" | "orange") & ("red" | "orange") समान है जो कि ("apple" & "red") | ("apple" & "orange") | ("orange" & "red") | ("orange" & "orange") बराबर है ("apple" & "red") | ("apple" & "orange") | ("orange" & "red") | ("orange" & "orange") ("apple" & "red") | ("apple" & "orange") | ("orange" & "red") | ("orange" & "orange") ("apple" & "red") | ("apple" & "orange") | ("orange" & "red") | ("orange" & "orange") । उन असंभव चौराहों में से प्रत्येक वाष्पित हो जाता है, और हम "orange" & "orange" साथ छोड़ देते हैं जो कि सिर्फ "orange" ।

हालांकि अभी भी कुछ प्रतिबंध हैं। यह नया व्यवहार केवल तब होता है जब संघ में अधिकांश एक प्रकार के कई अधिभार होते हैं, और संघ के अधिकांश एक प्रकार में एक सामान्य हस्ताक्षर होता है। इसका मतलब है कि number[] | string[] number[] | string[] map तरह (जो सामान्य है) अभी भी कॉल करने योग्य नहीं होगा।

दूसरी ओर, forEach जैसे तरीके अब forEach होंगे, लेकिन noImplicitAny तहत कुछ मुद्दे हो सकते हैं।

 interface Dog { kind: "pupper" dogProp: any; } interface Cat { kind: "kittyface" catProp: any; } const catOrDogArray: Dog[] | Cat[] = []; catOrDogArray.forEach(animal => { // ~~~~~~ error! // Parameter 'animal' implicitly has an 'any' type. }); 

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

 interface Dog { kind: "pupper" dogProp: any; } interface Cat { kind: "kittyface" catProp: any; } const catOrDogArray: Dog[] | Cat[] = []; catOrDogArray.forEach((animal: Dog | Cat) => { if (animal.kind === "pupper") { animal.dogProp; // ... } else if (animal.kind === "kittyface") { animal.catProp; // ... } }); 

वृद्धिशील फ़ाइल - --build --watch में समग्र परियोजनाओं के लिए देख रहा है

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

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

शायद विडंबना यह है कि --build --watch का उपयोग कर समग्र परियोजनाओं का निर्माण वास्तव में इस बुनियादी ढांचे का उपयोग नहीं किया। अंडर- --build --watch मोड के तहत एक परियोजना में एक अद्यतन उस परियोजना के पूर्ण निर्माण को बाध्य करेगा, बजाय यह निर्धारित करने के कि उस परियोजना के भीतर कौन सी फाइलें प्रभावित हुई थीं।

टाइपस्क्रिप्ट 3.3 में, --build मोड का - --watch झंडा वृद्धिशील फ़ाइल के रूप में अच्छी तरह से देख रहा है। इसका मतलब यह हो सकता है कि --build --watch से तेजी से निर्माण के तहत --build --watch । हमारे परीक्षण में, इस कार्यशीलता के परिणामस्वरूप मूल- --build --watch समय के निर्माण में 50% से 75% की कमी आई है । विशिष्ट संख्याओं को देखने के लिए आप मूल पुल अनुरोध पर अधिक पढ़ सकते हैं , लेकिन हमें विश्वास है कि अधिकांश समग्र परियोजना उपयोगकर्ता यहां महत्वपूर्ण जीत देखेंगे।

आगे क्या है?

3.3 से परे, आप किसी भी आगामी कार्य के लिए हमारे रोडमैप पृष्ठ पर नज़र रख सकते हैं।

लेकिन अभी हम आरसी के साथ अपने अनुभव के बारे में सुनने के लिए उत्सुक हैं, इसलिए इसे अभी एक शॉट दें और हमें अपने विचार बताएं!

- डैनियल रोसेनवेसर और टाइपस्क्रिप्ट टीम