Typescript: आंशिक कक्षाएं

मुझे लगता है कि आप मॉड्यूल पर भी "आंशिक" नियोजित करते हैं और यहां उठाए गए इस मुद्दे को हल करने में मदद करते हैं।

https://github.com/Microsoft/TypeScript/issues/447

@dishishkov शायद विस्तार के तरीके पर्याप्त होंगे: #9

आप इसका उपयोग किस प्रकार की स्थितियों के लिए करना चाहते हैं, और मौजूदा समाधान इससे कैसे कम हो जाते हैं?

ध्यान दें कि इसे WinForms-प्रकार के संपादन परिदृश्यों का समर्थन करने के लिए C# में लागू किया गया था, जहां आपके पास एक ऑटो-जेनरेट की गई फ़ाइल और एक ही प्रकार में योगदान देने वाली उपयोगकर्ता-संपादित फ़ाइल है; मुझे यकीन नहीं है कि इस तरह की स्थितियां जावास्क्रिप्ट/टाइपस्क्रिप्ट में लागू होती हैं।

कुछ वर्गों में कई पंक्ति संख्याएँ हो सकती हैं, बस बेहतर पढ़ने के लिए कई अलग-अलग वर्गों में विभाजित करने से मदद मिलेगी। आप अलग-अलग प्रकार से विभाजित कर सकते हैं, उदाहरण के लिए तर्क द्वारा (यदि यह तर्क किसी अन्य वर्ग में स्थानांतरित नहीं किया जा सकता है), दृश्यता (निजी और सार्वजनिक) और अन्य द्वारा। मामले में जब आंशिक वर्गों की तलाशी में समस्या हो सकती है (उदाहरण के लिए 2 आंशिक कक्षाएं समान विधि/परिवर्तनीय घोषणा) संकलक को सूचित करना चाहिए और त्रुटि फेंकना चाहिए।

यह वास्तव में सम्मोहक नहीं है। यदि आपकी कक्षा इतनी बड़ी है कि इसके विशाल आकार के कारण इसे एक फ़ाइल में आराम से संपादित नहीं किया जा सकता है, तो यह एक बहुत ही प्रमुख डिज़ाइन गंध है (उदाहरण के लिए http://programmers.stackexchange.com/questions/157482 में टिप्पणी)। विभिन्न प्रकार/तर्क/दृश्यता/आदि द्वारा विभाजन कुछ ऐसा है जिसे एक आईडीई या संगठन द्वारा एक फ़ाइल के भीतर नियंत्रित किया जा सकता है।

यह चर्चा करने योग्य है कि आपकी कक्षाएं इतनी बड़ी क्यों हैं कि उन्हें नेविगेट नहीं किया जा सकता है (क्या ऐसा इसलिए है क्योंकि नेविगेशन टूल बेहतर होना चाहिए?), और यदि बेहतर तरीके हैं तो भाषा केवल _splitting_ के बजाय _decompose_ कक्षा का समर्थन कर सकती है।

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

आंशिक कक्षाओं के लिए उपयोग का मामला उत्पन्न प्रॉक्सी कक्षाओं के लिए है। जैसे वेबएपीआई या सिग्नलआर रैपर। कस्टम तर्क के साथ जेनरेट की गई प्रॉक्सी कक्षाओं का विस्तार करने में सक्षम होना वाकई अच्छा होगा। विशेष रूप से मॉडल के लिए कक्षाएं उत्पन्न करते समय एपीआई से लौटाए गए मॉडल कक्षाओं में सीधे व्यावसायिक तर्क संलग्न करने में सक्षम होना अच्छा होगा।

+1 क्वांटेटोर।

उपयोग का मामला बिल्कुल .net जैसा ही है; वर्ग का एक हिस्सा उत्पन्न होता है (हमारे मामले में, एवरो स्कीमा से) और आप उत्पन्न कक्षाओं के साथ काम करने के लिए अतिरिक्त सहायक कोड जोड़ना चाहते हैं।

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

मेरा डेटा पदानुक्रम फ़ाइल :

class A {
  x: number;
  y: number;
  z: number;
}

class B extends A {
  value: string;
  flag1: boolean;
  flag2: boolean;
}

कक्षा ए के तरीकों वाली फाइल :

class A {
  constructor(x: number, y: number, z: number) {
    this.x = x;
    this.y = y;
    this.z = z;
  }
  method1(...) { ... }
  ...
  methodN(...) { ... }
}

कक्षा बी के तरीकों वाली फाइल :

class B extends A {
  constructor(x: number, y: number, z: number, value: string) {
    super(x, y, z);
    this.value = value;
    this.flag1 = false;
    this.flag2 = false;
  }
  method1(...) { ... }
  ...
  methodN(...) { ... }
}

मुझसे +1। मैं टाइपप्रति कक्षाओं को उत्पन्न करने के लिए tt टेम्पलेट्स का उपयोग करना चाहता हूं, लेकिन उन्हें एक अलग फ़ाइल में जोड़ें जो टेम्पलेट पीढ़ी द्वारा प्रतिस्थापित नहीं किया जाएगा।

+1 यह वास्तव में मेरी ऑटो जेनरेटेड कक्षाओं में मेरी सहायता करेगा जिन्हें मुझे विस्तारित करने की आवश्यकता है

आंशिक वर्ग वास्तव में अच्छा है लेकिन इसका कोई मतलब नहीं है। इससे पता चला कि आपको डिज़ाइन की समस्या है। प्रोग्रामिंग में अंगूठे का नियम इसे सरल बेवकूफ (KISS) रखना है, चाहे आप किसी भी भाषा का उपयोग करें, बड़े वर्ग को छोटे लोगों में विभाजित करना है - या तो 1) स्क्रिप्ट को कक्षाओं में विभाजित करना और उन्हें कॉल करना (अन्य वर्ग भी इसे कॉल कर सकते हैं) पहिया का पुन: आविष्कार करने के बजाय छोटे वर्ग भी), या 2) अलग हो जाते हैं और सार/इंटरफ़ेस/विरासत/वर्चुअल इत्यादि या बहुरूपता में परिवर्तित हो जाते हैं।

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

इस तरह आपके पास कम विकास समय होने की भी अधिक संभावना है। मेरे पास एक बार ASP.NET C# ब्लॉग था जो बहुत से आंशिक वर्गों का उपयोग करता है। मैं इससे बहुत अधिक आंशिक वर्गों के कारण संघर्ष कर चुका था और आप नहीं जानते कि वे कहाँ हैं। यह प्रोग्रामिंग में GOTO लॉजिक से निपटने जैसा है। बहुत बुरा!! मैं बगफिक्स के लिए सफलतापूर्वक पैच बनाने में सक्षम नहीं था, न ही मैं स्क्रिप्ट को अनुकूलित करने में सक्षम था क्योंकि यह आंशिक कक्षाओं के ढेर में भी दफन था (इसलिए कुछ नाम बदलकर शब्दांकन करें)।

बस यह कह रहा हूं कि मेरे दिमाग से 1 प्रतिशत सोचा था।

@ fletchsod-डेवलपर: कुछ स्थितियों को विरासत द्वारा ठीक से नियंत्रित किया जाता है, लेकिन सभी नहीं। और कुछ डेवलपर्स आंशिक कक्षाओं का दुरुपयोग कर सकते हैं, लेकिन सभी नहीं। ऐसी कुछ स्थितियां हैं जहां मुझे आंशिक कक्षाएं बहुत उपयोगी लगती हैं, लेकिन यदि आप उन्हें पसंद नहीं करते हैं, तो आपको उनका उपयोग करने की आवश्यकता नहीं है।

@jfrank14 , जैसा कि ऊपर @basarat द्वारा

// File1.ts
class Dog { 
 ...
}

// File2.ts
extends class Dog {
  woof() { /* ... */ }
}

@NoelAbrahams , क्या आप फ़ाइल में फ़ाइल 1 से परिभाषाओं को प्राप्त करने में सक्षम होंगे, लेकिन इसके विपरीत नहीं? यह मेरे लिए तब तक ठीक है जब तक समावेशन आदेश से स्वतंत्र है।

मैं वास्तव में आशा करता हूं कि आप लोग टीएस के लिए आंशिक कक्षाओं को ला सी # मानते हैं ... मेरे लिए एकमात्र कारण कोड पीढ़ी है, जो सी # के आंशिक वर्गों के पीछे प्राथमिक कारण है ... अधिक से अधिक करने की उम्मीद है... वर्तमान में हमें "// पर निर्भर रहना है

+1 - ऑटो-जेनरेटेड कक्षाओं में कार्यक्षमता जोड़ने के लिए वास्तव में इसका उपयोग कर सकता है; कोई अन्य सुरुचिपूर्ण समाधान मौजूद नहीं है जिसके बारे में मैं सोच सकता हूं या आज तक पढ़ सकता हूं ...

+1 - कोड जेनरेट की गई कक्षाएं। सी #/जावा ऑब्जेक्ट्स क्लाइंट को क्रमबद्ध किया गया

उत्पन्न वर्गों के विलय के लिए भी इसकी आवश्यकता है!

गैर-जेनरेट किए गए कोड के साथ जेनरेट कोड के सरल विलय की अनुमति देने के लिए यह एक बहुत ही उपयोगी सुविधा होगी।

+1

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

+1

इस सीमा में फिर से दौड़ें - कृपया इस सुविधा को जोड़ें! :+1:

+1

+1

+1

+1

लोग बेतरतीब ढंग से +1 करते हैं, यह इसे आगे नहीं ले जाएगा।

अब तक उपयोग के मामले हैं:

• मेरे पास वास्तव में बड़ी कक्षाएं हैं जो कई फाइलों को फैलाती हैं। @RyanCavanaugh ने संकेत दिया कि यह कोड के साथ एक प्रमुख डिजाइन मुद्दा था जो जटिल और कार्यान्वयन की जटिलता को वारंट करने के लिए पर्याप्त नहीं था।
• यह उन्हें पसंद है।
• एक अन्य तर्क लगता है कि सी # उनके पास है।
• अन्य तर्क अन्य भाषाओं से उत्पन्न कोड के आसपास है।

दूसरा और तीसरा उपयोग मामला सम्मोहक नहीं है और चौथा, मुझे संदेह है कि कुछ स्तर के विस्तार की आवश्यकता है कि कैसे #9 वितरित करना एक समान आवश्यकता और यहां तक ​​​​कि डेकोरेटर्स (#2249) को पूरा नहीं करेगा।

ऐसा लगता है कि #9 वही काम पूरा करेगा और और भी सामान्य होगा (क्योंकि आप अपने अलावा अन्य कक्षाओं का विस्तार कर सकते हैं)। लेकिन वर्ग सामग्री को दो फाइलों में रखना उचित हो सकता है (शायद इसलिए कि एक हाथ से लिखा गया है और दूसरा टेम्पलेट द्वारा उत्पन्न), और यह कहना कि दोनों फाइलें कक्षा के आवश्यक सदस्यों को समान महत्व के साथ परिभाषित करती हैं, और इसकी आवश्यकता नहीं है फ़ाइल "विस्तार" वर्ग दूसरे में परिभाषित करता है।

यह लगभग अस्तित्वगत अंतर है, लेकिन कुछ स्थितियों में कुछ लोगों के लिए शायद महत्वपूर्ण है।

मैं बताए गए कारणों से कक्षाओं पर आंशिक नहीं चाहता, लेकिन मॉड्यूल पर यह IMHO समझ में आता है।

https://github.com/Microsoft/TypeScript/issues/447

उपयोग के मामलों में विशेषज्ञता के लिए आंशिक कक्षाएं अत्यंत उपयोगी हैं। यह किसी OOP पैटर्न का उल्लंघन नहीं है बल्कि कोड दस्तावेज़ को व्यवस्थित करने का एक तरीका है, जो प्रदान करता है:

1. कई फाइलों में वर्ग/प्रकार परिभाषा को विभाजित करने की क्षमता। विशाल कोड फ़ाइलों के लिए, यह रखरखाव ++ सुविधा है।
2. संकलन-समय पर कंडीशनल लिंकेज का उपयोग करने के लिए कंपाइलर/बिल्ड-सिस्टम के लिए अवसर। सादृश्य एमएसबिल्ड, सी # में ठोस उपयोग-मामला: डीबीएमएल, डिजाइनर कक्षाएं और यहां तक ​​​​कि अधिक फैंसी सामान जैसे https://github.com/dotnet/corefx/pull/2045/files।
3. अंतर्निहित सुरक्षा, इसलिए दो (या अधिक) डेवलपर कोड चेक-इन के दौरान एक-दूसरे से नहीं मिलते हैं। संघर्ष का संकल्प उड़ा! :)
4. आप मुख्य आंशिक वर्ग में कोड उत्पन्न करते हैं, फिर कस्टम अधिभार के लिए एक और आंशिक बनाते हैं। अच्छी तरह से काम!

मैं व्यावसायिक तर्क और डेटा परतों को अलग-अलग वर्गों में अलग करने में विश्वास करता हूं और मैं ज्यादातर इन परतों में स्थिर तरीकों का उपयोग करता हूं। मैं वास्तव में नहीं देखता कि यह कैसे अधिक कोड और कम रखरखाव योग्य हो सकता है।

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

:+1: हानिरहित "आंशिक वर्ग" को टाइपस्क्रिप्ट में लाने के लिए।

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

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

+1

+1

कोड जनरेशन उद्देश्यों के लिए +1।

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

कोड जनरेशन परिदृश्यों के लिए +1

+1 कोड जनरेशन के लिए अत्यंत उपयोगी

कोड पीढ़ी के लिए विरासत का उपयोग क्यों नहीं करें?

वंशानुक्रम गड़बड़ है और अधिक उपरि है।

सोम को, अगस्त 10, 2015, 10:09 पूर्वाह्न गोर्गी कोसेव नोटिफिकेशन @github.com ने लिखा:

कोड पीढ़ी के लिए विरासत का उपयोग क्यों नहीं करें?

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
https://github.com/Microsoft/TypeScript/issues/563#issuecomment -129468291
.

वंशानुक्रम बेकार नाम युग्मन बनाता है

वंशानुक्रम कम भयानक है क्योंकि यह:

1. प्रोटोटाइप श्रृंखला को अनावश्यक रूप से गहरा करता है और तात्कालिकता को धीमा कर देता है,
   हालांकि अधिकांश ऐप्स के लिए यह कोई बड़ी बात नहीं है, संभवत: गेम के अलावा सब कुछ;
2. सार और ओवरराइड की कमी के लिए या तो कुछ प्रकार की सुरक्षा खो देता है या
   दोनों के बीच कास्टिंग जैसे कुछ अजीब पैटर्न की आवश्यकता का परिचय देता है
   प्रकार;
3. समग्र रूप से भ्रमित कर रहा है क्योंकि बेस क्लास इस विचार को संप्रेषित करता है कि
   इसे अन्य वर्गों द्वारा बढ़ाया जा सकता है, जो कि कोडजेन के मामले में शायद ही कभी होता है

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

जेएस में @JoshMcCullough विरासत ओवरहेड न्यूनतम है, और मुझे नहीं लगता कि आंशिक कक्षाओं की तुलना में यह कितना

@ yahiko00 हम

@hdachev

1. कुछ ओवरहेड है, लेकिन यह काफी कम है - केवल तभी ध्यान देने योग्य है जब आप ऐसी चीजें कर रहे हैं जो सीधे कुछ मशीन निर्देशों में अनुवाद करती हैं
2. अच्छा बिंदु - जब आपको अन्य जेनरेट किए गए वर्गों से जेनरेट की गई कक्षा का संदर्भ देना होता है तो आपको विस्तारित कक्षा नहीं मिलती है।
3. वे वर्ग वास्तव में विस्तारित होने के लिए हैं - अन्यथा आप उन्हें उत्पन्न कर सकते हैं और इसके साथ किया जा सकता है, है ना?

AFAIK यह ES7+ रडार पर नहीं है, है ना? यह समस्याग्रस्त हो सकता है ...

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

यह टीएस में सीधा है लेकिन पर्दे के पीछे जेएस दोगुना होगा
"प्रोटोयिंग" यदि आप अपने सभी जेनरेट किए गए डेटा के लिए बेस क्लास का उपयोग कर रहे थे
वस्तुओं। शायद एक गंभीर प्रदर्शन प्रभाव नहीं है जब तक कि आपके पास एक टन नहीं है
डेटा ऑब्जेक्ट्स, लेकिन यह तब भी अनावश्यक है जब हम जानते हैं कि "आंशिक"
कक्षाएं" संभव हैं।

सोम, अगस्त 10, 2015 पूर्वाह्न 11:03 बजे गोर्गी कोसेव नोटिफिकेशन @github.com
लिखा था:

@JoshMcCullough https://github.com/JoshMcCullough इनहेरिटेंस ओवरहेड
जेएस में न्यूनतम है, और मैं नहीं देखता कि आंशिक कक्षाओं की तुलना में यह कितना गड़बड़ है:
उन लोगों के साथ आप संभावित रूप से कक्षा को 10 फाइलों में विभाजित कर सकते हैं और अपना पीछा कर सकते हैं
हर जगह तरीके।

@yahiko00 https://github.com/yahiko00 किस तरह का "बेकार नाम"
कपलिंग" क्या हम यहां बात कर रहे हैं? क्या आप उन चीजों का उल्लेख करते हैं जिनकी आपको आवश्यकता होगी
नीचे नंबर 2 पाने के लिए क्या करना है (विस्तारित वर्ग का नाम हार्डकोड)?

क्लास MyClass, GenerateMyClass को बढ़ाता है {...}

@hdachev https://github.com/hdachev

1.

कुछ ओवरहेड है, लेकिन यह काफी कम है
https://jsperf.com/prototype-chain-vs-direct-calls - केवल ध्यान देने योग्य
अगर आप ऐसे काम कर रहे हैं जो सीधे एक दो मशीन में अनुवाद करते हैं
निर्देश
2.

अच्छा बिंदु - जब आपको करना हो तो आपको विस्तारित कक्षा नहीं मिलती है
अन्य उत्पन्न वर्गों से उत्पन्न वर्ग का संदर्भ लें।
3.

वे वर्ग वास्तव में विस्तारित होने के लिए हैं - अन्यथा आप कर सकते हैं
उन्हें उत्पन्न करें और इसके साथ किया जाए, है ना?

AFAIK यह ES7+ रडार पर नहीं है, है ना?

किसी भी मामले में, मौजूदा वर्ग के प्रोटोटाइप में अतिरिक्त चीजें संलग्न करना
जावास्क्रिप्ट में काफी तुच्छ है और बिल्कुल भी असामान्य नहीं है, इसलिए यह हो सकता है a
इसके लिए वाक्यविन्यास रखना अच्छा विचार है ...

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
https://github.com/Microsoft/TypeScript/issues/563#issuecomment -129483174
.

@ डेविडसन 90 उस फ़ाइल में शून्य कक्षाएं हैं। क्या आप इसे किसी अन्य थ्रेड में पोस्ट करना चाहते थे?

मैं सही धागे पर पोस्ट करूंगा। https://github.com/Microsoft/TypeScript/issues/447

+1

+1

+100

+1

+1

कोड पीढ़ी के लिए +1।
मैं angularjs और webapi में शामिल हो रहा हूं और मैं एक ऐसा टूल बनाना चाहता हूं जो अनिवार्य रूप से मेरे सी # ऑब्जेक्ट्स और सेवाओं से स्वचालित जेएस परिभाषाएं बनाता है। मैं तब "मचान" जेएस परिभाषाओं को संपादित किए बिना इन कक्षाओं का विस्तार करने में सक्षम होना चाहता हूं। मैंने देखा है कि कुछ अन्य लोग इसका अनुरोध कर रहे हैं और ऐसा लगता है कि हमारे पास समान उपयोग के मामले हैं।

कोड जनरेशन के लिए +1

कोड जनरेशन के लिए +1, कोणीय में बहुत सारे बॉयलरप्लेट कोड होते हैं, हम पहले से ही इसकी बहुत सारी पीढ़ी कर रहे हैं, लेकिन आंशिक कक्षाओं के साथ हम बहुत कुछ करने में सक्षम होंगे।

कोड जनरेशन के लिए फिर से +1। कक्षाओं को किसी अन्य फ़ाइल में विस्तारित करने का प्रयास करना सबसे अच्छा गड़बड़ है।

@RyanCavanaugh , इसे "+1" मोड से बाहर निकालने और उत्पादक दिशा में आगे बढ़ने के लिए क्या आवश्यक है?

-1 निम्नलिखित वाक्यविन्यास मिश्रणों के लिए बेहतर है: #2919

निश्चित नहीं है कि हमारे पास आंशिक वर्ग और मिश्रण दोनों क्यों नहीं हो सकते हैं; दो पूरी तरह से असंबंधित विशेषताएं।

+1

कोड जेनरेट होने पर यह अच्छा होगा, लेकिन आप जेनरेट कोड में चीजों को जोड़ने के लिए इसे संशोधित नहीं करना चाहते हैं।

+1

मेरे पास एक प्रस्ताव है जो इन दोनों उपयोग मामलों को पूरा करना चाहिए:

1. आप अलग-अलग जगहों पर अपनी खुद की कक्षा के तरीके लिखना चाहते हैं।
2. आप किसी और की कक्षा में नई विधियां जोड़ना चाहते हैं, उदाहरण के लिए एक बिल्टिन।

(2) के लिए, आम तौर पर आप इंफिक्स सिंटैक्स प्राप्त करने के लिए :: ऑपरेटर का उपयोग करेंगे।

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

interface ITimes {
    times(n: number): number
}

Array implements ITimes {
    times(n: number): number {
        return this.length * n
    }
}

// The compiler should check that all methods of ITimes and IOther are implemented.
Number implements ITimes, IOther {
    times(n: number): number {
        return this * n
    }

    other(): void {}
}

// The old types should typecheck with the new interface.
const x: ITimes = true ? [] : 0
x.times(3)

// The interface list can be empty. This essentially gives you partial classes.
MyClass implements {
    anotherMethod(): void {}
}

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

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

: +1: मुझे आंशिक कक्षाएं भी देखना अच्छा लगेगा।

इस सुविधा की स्थिति क्या है?

उदाहरण के लिए यह उपयोग मामला:

मेरे पास एक Math पैकेज है जो Set विधियों के साथ एक वर्ग को परिभाषित करता है Set#add , 'Set#remove'

// math.ts
export partial class Set {
  add(){}
  remove(){}
}

मेरे पास एक वैकल्पिक , भारी , Relational पैकेज है जो Relation और Tuple कक्षाओं को परिभाषित करता है।

यह Relational पैकेज एक Set#product विधि भी जोड़ देगा।

// relational.ts
///<reference path="./../math/tsd.d.ts"/>
partial class Set {
  product(){}
}

export class Relation(){}
export class Tuple(){}

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

मैं कुछ ऐसा करने के लिए अपना सिर खुजला रहा हूं जिसमें इस मामले में आंशिक उपयोग के बिना एक अच्छा एपीआई होगा।

मैं केवल कुछ रिपोजिटरी पैटर्न के साथ आ सकता हूं।

// Without partials

// base

export class Base {
    static registerOperation(opName, method){
        this.prototype[opName] = method;
    }
    operation(name, ...args){
        return this[name].apply(this, args);
    }
}

// math.ts
import {Base} from './base';
class Set extends Base{
    // Define the methods here
    add(){}
    remove(){}
}

// Or here
Set.registerOperation("add", function(...){});
Set.registerOperation("remove", function(...){});

// relational.ts
import {Set} from './../math/math';

Set.registerOperation("product", function(...){});

// app.ts

import {Set} from 'math';

var set = new Set();
set.add // compiler error
set.remove // compiler error
set.product // compiler error

// have to use something like
set.operation("add", args);
// or
(<any>set).add(arg);

+1 मैं वेबएपी पर कक्षाएं और प्रॉक्सी उत्पन्न करने के लिए टी 4 का उपयोग कर रहा हूं। मुझे लगता है कि ऑटो-जेनरेशन टाइपस्क्रिप्ट में बहुत अधिक उपयोग कर रहा है और जब ऑटो-जेनरेशन की बात आती है, तो आंशिक कक्षाएं आवश्यक होती हैं!

विशेष रूप से प्रतिक्रिया में एक ही वर्ग के पहलुओं को विभाजित करने के लिए यह बहुत अच्छा होगा
+1

+1 कोड जनरेशन और "बस पर्याप्त अलगाव" क्लाइंट-विशिष्ट विशेषताओं के साथ शुद्ध पुन: प्रयोज्य डेटा ऑब्जेक्ट्स के मामले में सत्यापन के लिए जो कक्षा पर परिभाषित करने के लिए साफ होगा लेकिन स्रोत कोड के एक अलग टुकड़े में बनाए रखा जाएगा।

आंशिक कक्षाओं के कोड जनरेशन के लिए +1 और इन कक्षाओं के लिए अलग-अलग फाइलों में अतिरिक्त सदस्यों को हैंडकोड करें।

+1

+1 मेरे पास हमारी जेएस एपीआई सेवा में विधियों का बड़ा आधार है, उन्हें फाइलों में विभाजित करना सबसे अच्छा होगा, जिससे प्रत्येक विधि को समझना आसान हो जाता है।

एपीआई सेवा जैसे fb (facebook) या gq (google analytics) , जहां आपको एक वैश्विक वर्ग या वस्तु दी जाती है, जिसका उपयोग आप अपने विकास के दौरान कर सकते हैं।

+1

यह फीचर हमारे लिए भी एक बड़ा प्लस होगा।

हमने एक मिडलवेयर विकसित किया है, जहां सभी प्रकार के क्लाइंट इसके माध्यम से हमारे सर्वर से जुड़ सकते हैं और संचार कर सकते हैं।

हम सर्वर द्वारा उजागर की गई चीज़ों के आधार पर कुछ क्लाइंट कोड जेनरेट करते हैं।

अब तक तो सब ठीक था। लेकिन अब, हम वस्तुओं के विषम संग्रहों को स्थानांतरित करने में सक्षम होना चाहते हैं (लेकिन एक ही आधार वर्ग के साथ)। स्थानांतरित की गई वस्तुएं सर्वर एपीआई के आधार पर उत्पन्न कोड का हिस्सा हैं।

विरासत की शक्ति का उपयोग करने में सक्षम होने के लिए, इस मामले में अमूर्त विधियां महत्वपूर्ण हैं। लेकिन हमारे डेवलपर्स जेनरेट कोड में विधियों को नहीं जोड़ेंगे, मुझे लगता है कि हर कोई जानता है कि क्यों;)

जहां तक ​​मुझे समझ में आया (मैं एक सी # डेवलपर हूं), यहां प्रस्तावित समाधान (https://github.com/Microsoft/TypeScript/issues/9) हमें ऐसा करने की अनुमति नहीं देगा।

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

+1

+1 कोड जनरेशन के लिए बहुत उपयोगी है

मुझे आश्चर्य है कि क्या मॉड्यूल वृद्धि मूल रूप से एक विशिष्ट विशेषता के रूप में इसकी आवश्यकता को नकारती है।

यदि आपके पास जेनरेट क्लास है तो आप कुछ ऐसा करने में सक्षम होना चाहिए ...

import {MyClass} from "./MyClass.generated"

MyClass.prototype.partialMethod1 = function() {
  return true;
}
MyClass.prototype.partialMethod2 = function(abc: string) {
  this.doSomething(abc);
}

declare module './MyClass.generated' {
  interface MyClass {
    partialMethod1(): boolean;
    partialMethod2(abc: string): void;
  }
}

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

मैं हाथी-पोत से सहमत हूं। आंशिक वर्ग का मैन्युअल रूप से तैयार किया गया हिस्सा जितना संभव हो उतना ढीला युग्मित (टीएस में डिजाइन समय पर) उत्पन्न भाग के रूप में होना चाहिए।

@ डेविड-ड्रिस्कॉल का सुझाव कई मामलों में काम करता है। हालाँकि, जहाँ तक मैं बता सकता हूँ, प्रोटोटाइप की आंतरिक चरों तक पहुँच नहीं है। यह कोड जनरेशन संदर्भों में इस दृष्टिकोण की उपयोगिता को सीमित करता है जहां आप अपनी कक्षाओं के मुख्य भागों को उत्पन्न करना चाहते हैं और फिर उन्हें कस्टम कोड के साथ बढ़ाना चाहते हैं।

+1

@ डेविड-ड्रिस्कॉल जो इस सुविधा को कम करने का एक शानदार तरीका दिखता है। (निजी/संरक्षित संपत्तियों तक पहुंचने की क्षमता जोड़ने की आवश्यकता होगी)। आश्चर्य है कि एकाधिक आंशिक वर्ग घोषणा के साथ क्या होगा? उन की पारस्परिक दृश्यता क्या होगी?

++ 1 मेरे ऑटो जेनरेट किए गए मॉडल को विस्तारित करने का प्रयास करते समय आंशिक कमी वास्तव में मुझे चोट पहुंचा रही है ..

मुझे लगता है कि यहां केवल एक चीज है जो मूल रूप से @ डेविड-ड्रिस्कॉल ने प्रस्तावित की है - आप नए तरीकों (जो प्रोटोटाइप पर रखे जाएंगे) और नए _non-initialized_ गुण (जिसमें कोई कोडजन नहीं है) घोषित कर सकते हैं, लेकिन नए प्रारंभिक गुण नहीं (क्योंकि इनका कंस्ट्रक्टर कोडेजन पर साइड इफेक्ट होता है)।

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

OOP के साथ आप लोगों का कोई भविष्य नहीं है (वहां रहा हूं, जानिए मैं किस बारे में बात कर रहा हूं)

एफपी पर आते हैं, हमारे पास कुकीज हैं और बिना किसी वर्ग के प्रोग्राम लिखने का एक तरीका है और इस तरह ** टी

तो हम पहले से ही मूल रूप से इसे interface A { method(): void } A.prototype.method = function() { }; माध्यम से अनुमति देते हैं; इसे चीनी में कोडित करना वास्तव में समझ में आता है।

बाइकशेड के लिए एक चीज कीवर्ड है partial । एक संक्षिप्त ऐतिहासिक शब्दचित्र: C# में, partial class मूल रूप से extension class (जिसे आपने एक घोषणा के अलावा सभी पर रखा था), लेकिन इस बारे में कोई स्पष्ट अंतर नहीं था कि कौन सी घोषणाएं होंगी extension और कौन सी घोषणा गैर-विस्तार घोषणा होगी। इसके बजाय आपके पास संशोधक partial जिसे आपको _all_ कक्षाओं में रखना होगा।

टाइपस्क्रिप्ट में यह _not_ मामला है; बल्कि विपरीत। यहां, केवल एक वर्ग (इसे "_primary_ घोषणा" कहते हैं) में कंस्ट्रक्टर/आरंभिक सदस्य फ़ील्ड हो सकते हैं; प्राथमिक घोषणा को कोई नया संशोधक नहीं मिलता है। हर दूसरी घोषणा (चलिए उन्हें "_extension_ घोषणाएं" कहते हैं) में केवल स्टैटिक्स, विधियाँ और गैर-आरंभिक फ़ील्ड हो सकते हैं, और आपको यह इंगित करने के लिए कि वे प्राथमिक नहीं हैं, उन पर कुछ संशोधक रखने के लिए _need_ होगा।

वर्तमान सर्वोत्तम अनुमान है

class Foo {
  x = 6; // only legal to initialize here
  constructor() { } // only legal to have constructor here
  someMethod() { }
}

// vvvvvvvvv thoughts?
   extension class Foo {
     someOtherMethod() {
     }
   }

:चमक: :बाइक: :घर::चमक:

बाइकशेडिंग या नहीं, यह #311 की तरह एक भयानक लग रहा है जिसे भविष्य के ईसीएमएस्क्रिप्ट मानकों में हस्तक्षेप करने की संभावना के कारण दूर कर दिया गया था। यह विचार करने योग्य क्यों है, लेकिन उचित मिश्रण समर्थन नहीं है?

कीवर्ड extension का उपयोग करने से एक्सटेंशन विधियों का विरोध होता है? या यह विस्तार विधियों को पूरी तरह से नकारने वाला है?

@kitsonk मुझे लगता है कि

@ हाथी-पोत मुझे नहीं लगता कि आंशिक कक्षाएं होने पर विस्तार विधियां हो रही हैं। कक्षाएं ही एकमात्र ऐसी जगह हैं जहां विस्तार के तरीके हमारी बाधाओं को देखते हुए समझ में आते हैं, और प्रस्तावित ES7+ बाइंड ऑपरेटर एक्सटेंशन-जैसे सिंटैक्स में शूहॉर्न का एक बेहतर तरीका है।

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

@RyanCavanaugh ... मैं इसे ठीक उसी तरह से करूंगा जैसे सी # करता है ... यह कोड जनरेशन के लिए बहुत अच्छा काम करता है ... जो मेरा मानना ​​​​है कि प्राथमिक समस्या थी जिसे सी # में हल करना था ... हालांकि मेरी याददाश्त अस्पष्ट है ... कभी कोई समस्या नहीं थी, यह वर्षों से है, और युद्ध का परीक्षण किया गया है ...

यदि आंशिक/विस्तारित कक्षाओं में प्रारंभिक फ़ील्ड नहीं हो पाएंगे, तो मुझे लगता है कि यह आंशिक विधियों जैसे कुछ का समर्थन करने के लिए अतिरिक्त साफ होगा,

public partial class MyGeneratedClass
 {
     partial void Initialize();
     public constructor()
     {
          //...
         this.Initialize();
    }
 }

 public partial class MyGeneratedClass
 {
     partial void Initialize()  { //... }
 }

तृतीय-पक्ष वर्गों को आंशिक/विस्तारित करने में सक्षम होने की आवश्यकता को partial/extends आम तौर पर वैकल्पिक बनाकर हल किया जा सकता है लेकिन आंशिक तरीकों के उपयोग के लिए आवश्यक है।

मुझे लगता है कि यह उस अवधारणा के लिए कुछ साफ-सुथरी अभिव्यंजक और संचालन शक्ति ला सकता है जो हम यहां चाहते हैं।

जो लोग मिक्सिन की तलाश में हैं।

ऑब्जेक्ट इनिशियलाइज़ेशन प्रस्ताव पर विचार करें जिसके माध्यम से (और प्रवाह विश्लेषण) मिश्रणों को सुरुचिपूर्ण ढंग से, स्वाभाविक रूप से, मुहावरेदार रूप से सही तरीके से किया जा सकता है जहाँ तक जावास्क्रिप्ट जाता है:

function enableBeingPositioned<a>(
   // hypothetical syntax
   something: a /* <-- before type */ => a & { x: number; y: number; } /* <-- after type */
): void { 
   something.x = 0;
   something.y = 0;
}
let value = {};
value.x; // <-- should not typecheck
enableBeingPositioned(value);
value.x; // <-- should typecheck

जावा जैसी भाषाएं आंशिक कक्षाओं/संरचनाओं की पेशकश नहीं करती हैं। यह सी # की एक विशिष्ट विशेषता है। सी # "आंशिक वर्ग/संरचना" अवधारणाओं का पूरी तरह से अनुकरण करना यहां जाने का सबसे अच्छा तरीका है।
पूर्व-संकलन चरण में, टीएस कंपाइलर जो पहली चीज कर सकता है, वह है मेमोरी में आंशिक कोड ब्लॉक को सिलाई करना और फिर नियमित संकलन पाइपलाइन मार्ग पर जाना। यह टाइपस्क्रिप्ट में v1.0.0-preview1.0000 आंशिक कक्षाओं की सुविधा के लिए अर्हता प्राप्त करने के लिए पर्याप्त से अधिक होगा।
सी # जो पेशकश कर रहा है उससे परे कुछ भी ऐसा कुछ है जिसे बाद के संस्करणों में पेश किया जा सकता है जब सुविधा विकसित होगी और इसके परीक्षण/पूर्वावलोकन को पार कर जाएगी। कोने के मामलों और इसी तरह के अस्पष्ट सामान पर एक बार में अलग-अलग चर्चा की जा सकती है और हम बाद में फिट और खत्म होने के बारे में चिंता कर सकते हैं ... आईएमओ।

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

विस्तार विधियां किसी को ऐसा करने की अनुमति देती हैं (स्वरूपण की कमी के बारे में खेद है,
फोन पर टाइप करना):

माईटाइप का विस्तार करें [] {
कुछ विशिष्ट टोमाई टाइप () {...}
}

अजीब थर्डपार्टीडेटास्ट्रक्चर का विस्तार करें{
मेरा भी यही विचार है() { ... }
}

अन्य बातों के अलावा जैसे कि अंडरस्कोर जैसे कामों का उपयोग करने में सक्षम होना
क्रॉफ्ट के बिना, जिसका मूल रूप से अर्थ है के वाक्यात्मक लाभों को प्राप्त करना
वास्तव में उन्हें प्रदूषित किए बिना अंतर्निर्मित प्रकारों का विस्तार करना।

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

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

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

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

मुझे इस अवधारणा के एक प्रसिद्ध और आजमाए हुए मॉडल के अनुसार इसे लागू करने का विचार पसंद है, ठीक उसी तरह जैसे C# में है। 'नकल' के कुछ नकारात्मक अर्थ हैं, लेकिन अगर समझदारी से किया जाए तो इसका महत्वपूर्ण मूल्य है। दूसरी ओर, इसका 'बुद्धिमान' हिस्सा विभिन्न परिस्थितियों और सीमाओं से अवगत होना है, इसलिए यदि टाइपस्क्रिप्ट के लिए आंशिक सी # के लिए आंशिक रूप से नहीं दिखता है तो मैं विरोध नहीं करूंगा।

@ हाथी-पोत, मैं मानता हूं कि इसे सी # आंशिक की एक समान प्रतिलिपि की आवश्यकता नहीं है, सामान्य डिजाइन को पहले टाइपस्क्रिप्ट/जावास्क्रिप्ट स्वाद के आसपास तैयार किया जा सकता है जबकि सी # आंशिक से अधिकतम प्रेरणा लेते हुए। मेरा सुझाव है कि पहले चरण के रूप में ' partial कीवर्ड का पंजीकरण' और 'सिलाई आंशिक' के साथ जाएं, और इसे एक प्रयोगात्मक/पूर्वावलोकन सुविधा के रूप में शिप करें (ताकि उपभोक्ता उत्पादन कोड में इसके आधार पर शुरू न करें) बल्ले से)। बाद में, समुदाय प्रतिक्रिया के आधार पर, इस सुविधा को तब तक विकसित करें जब तक कि यह उत्पाद-तैयार और RTM'd न हो जाए। यदि हम पहले से ही सभी प्रकार के पेचीदा गठजोड़ और परिदृश्यों के बारे में चिंता करते हैं, तो संभवत: इससे मामले में और देरी होगी।

+1 - उत्पन्न वस्तुओं को विस्तारित करने और बनाए रखने के लिए।

जेनरेट कोड बनाए रखने के लिए +1

मैंने पॉलीफिल बनाया और अपनी बड़ी कक्षा को विभाजित किया।

एक वर्ग को एक इंटरफ़ेस के रूप में परिभाषित करें।

export class C {
  constructor() {
  }
}
export interface C {
  m(): void;
}

वर्ग के सदस्यों को लागू करें।

export default class extends C {
  m(): void {
  }
}

कार्यान्वयन मर्ज करें।

import {C} from './core';
import m from './member/m';

compose(C, m);
export {C}

import {assign} from './assign';
import {concat} from './concat';

export function compose<T extends new (...args: any[]) => any>(target: T, ...sources: T[]): T {
  return concat([target], sources)
    .reduce((b, d) => {
      void assign(b.prototype, d.prototype);
      for (const p in d) if (d.hasOwnProperty(p)) b[p] = d[p];
      return b;
    });
}

https://github.com/falsandtru/spica/commit/a6ff30da5319db5f25f703a29da48fc0f7dbe2fe

मुझे लगता है कि यह एक विशिष्ट कारण के लिए एक भयानक विचार है: यह वैश्विक, परिवेश, बाहरी, नामांकित, और भंगुर घोषणा आदेश निर्भर विरासत समस्याओं के लिए पहले से ही जटिल नियम बना देगा। यह सी # नहीं है और नाम संकल्प और सदस्य घोषणाएं बहुत अलग हैं।

यदि आपको वास्तव में ऐसा करने की ज़रूरत है तो शायद कक्षा के बजाय किसी ऑब्जेक्ट या नेमस्पेस का उपयोग करें, एक ला खुलासा मॉड्यूल पैटर्न। अन्यथा आपकी कक्षा शायद बहुत बड़ी है।

इसके अलावा सज्जाकारों का उपयोग जेनरेट कोड और हस्तलिखित कोड के बीच संघों को लागू करने के लिए किया जा सकता है।

क्या आपके पास अन्य उपाय हैं?

मैं इसे TS में भी जोड़कर देखना पसंद करूंगा

कोड जनरेशन उद्देश्यों के लिए +1 (अतिरिक्त आंशिक वर्ग परिभाषाओं के साथ डब्ल्यूसीएफ सेवा संदर्भ से डीटीओ)

कोड जनरेशन उद्देश्यों के लिए +1। मेरा उपयोग मामला है: मेरे पास प्रतिक्रिया घटक हैं जिनके render() फ़ंक्शन प्रतिक्रिया-टेम्पलेट्स के माध्यम से बाहरी रूप से उत्पन्न होते हैं।

partial कक्षाओं के साथ मैं मुख्य वर्ग ( Component ) बनाम ऐसे कार्यों को टाइप-चेक कर सकता था। आंशिक कक्षाओं के बिना, केवल एक चीज जो मैं कर सकता हूं वह है समारोह को मुख्य वर्ग के लिए बाध्य करना और सर्वश्रेष्ठ के लिए आशा करना।

अगले TS 2.0 के साथ, मैं सोच रहा था कि कुछ कोड-जनरेशन मामलों को this प्रकार की सुविधा के साथ कवर किया जा सकता है।

उदाहरण के लिए उस मामले में जिसका मैंने पहले वर्णन किया था, के बजाय

partial class MyComponent extends React.Component<any,any> {
    render() {
        ...
    }
}

मैं लिख सकता हूँ

function render<this extends MyComponent>()
        ...
}
MyComponent.prototype.render = render;

+1 एक डेवलपर के रूप में मुझे आंशिक कक्षाएं चाहिए ताकि एकाधिक टेम्पलेट एकाधिक फ़ाइलों में फैले एक ही वर्ग को उत्पन्न/संशोधित कर सकें।

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

@wendelm क्या आप ऐसा करने का एक साफ तरीका सोच सकते हैं, यह देखते हुए कि ES मॉड्यूल भौतिक हैं। आंशिक कक्षाएं अच्छी तरह से काम करती हैं और सी # जैसी भाषा में बहुत समझ में आती हैं जहां मॉड्यूल तार्किक होते हैं भौतिक नहीं। सीएलआर के दृष्टिकोण से, नामस्थान मौजूद नहीं हैं, यह सिर्फ इतना है कि वर्ग के नामों में बिंदु हो सकते हैं (स्रोत @ahejlsberg के साथ एक साक्षात्कार)

+1 मुझे आंशिक वर्ग चाहिए!

क्या हम इंटरफ़ेस बढ़ा सकते हैं? इंटरफ़ेस में कुछ कार्यान्वित कार्य भी हो सकते हैं, जैसे स्विफ्ट:

interface Rect {
    x: number
    y: number
}

extension Rect {
    area() => this.x * this.y
}

स्विफ्ट संस्करण:

protocol Rect {
    var x: Float {get}
    var y: Float {get}
}
extension Rect {
    func area() -> Float {
        return self.x * self.y
    }
}

+1

कोड जनरेशन और आंशिक कक्षाएं साथ-साथ चलती हैं।

विरासत अनिवार्य रूप से एक गौरवशाली #include निर्देश का एक खराब समाधान है।

उदाहरण के लिए कोणीय 2 लें। यह मूल वर्ग से मेटाडेटा नहीं पढ़ेगा , जिससे विस्तार-दर-विरासत अव्यवहारिक हो जाएगा।

@tsvetomir यह एक कोणीय मुद्दा है जो टाइपस्क्रिप्ट समस्या नहीं है।

वंशानुक्रम अनिवार्य रूप से एक महिमामंडित #निर्देश शामिल करने का एक खराब समाधान है

हां विरासत एक खराब समाधान है, लेकिन समस्या पहली जगह कक्षाओं का उपयोग कर रही है। उनका अपना स्थान है लेकिन यह बहुत सीमित है। अन्य भाषाओं की कक्षाओं की तुलना में जावास्क्रिप्ट कक्षाएं बहुत कमजोर और अनुभवहीन हैं।

टाइपस्क्रिप्ट एक "कोणीय" भाषा नहीं है... कभी नहीं थी

जुला 23, 2016 में 9:46 बजे पर, Aluan हद्दाद < [email protected] [email protected] > ने लिखा:

@tsvet omirhttps://github.com/tsvetomir यह एक कोणीय समस्या है जो टाइपस्क्रिप्ट समस्या नहीं है।

वंशानुक्रम अनिवार्य रूप से एक महिमामंडित #निर्देश शामिल करने का एक खराब समाधान है

हां विरासत एक खराब समाधान है, लेकिन समस्या पहली जगह कक्षाओं का उपयोग कर रही है। उनका अपना स्थान है लेकिन यह बहुत सीमित है। अन्य भाषाओं की कक्षाओं की तुलना में जावास्क्रिप्ट कक्षाएं बहुत कमजोर और अनुभवहीन हैं।

आप इसे प्राप्त कर रहे हैं क्योंकि आपने टिप्पणी की थी।
इस ईमेल का सीधे उत्तर दें, इसे Gi tHubhttps://github.com/Microsoft/TypeScript/issues/563#issuecomment -234753589 पर देखें, या इसे पढ़ने के लिए म्यूट करें https://github.com/notifications/unsubscribe-auth/AJPCIh7n2_0dt00kw- XJv7tc9LB0tPsIks5qYtH4gaJpZM4CcixK।

मैं इस मुद्दे को किसी भी तरह से कोणीय विशिष्ट के रूप में नहीं देखता। यह एक विशेष मामला है जिसमें आंशिक वर्गों ने मदद की हो सकती है।

अनुरोध सी # के साथ पिछले अनुभव और परिचित सुविधाओं की कमी से उत्पन्न होता है। तुलना अपरिहार्य है क्योंकि टाइपस्क्रिप्ट स्वयं को .NET से दूर करने का कोई प्रयास नहीं करता है । इसके उपयोगकर्ताओं द्वारा कुछ प्रकार की सुविधा समता की अपेक्षा की जाती है।

अनुरोध सी # के साथ पिछले अनुभव और परिचित सुविधाओं की कमी से उत्पन्न होता है। तुलना अपरिहार्य है क्योंकि टाइपस्क्रिप्ट स्वयं को .NET से दूर करने का कोई प्रयास नहीं करता है। इसके उपयोगकर्ताओं द्वारा कुछ प्रकार की सुविधा समता की अपेक्षा की जाती है।

@tsvetomir लंबे समय तक .NET डेवलपर के रूप में, और एक भावुक सी # प्रोग्रामर के रूप में, मैं मूल रूप से असहमत हूं।

आपके द्वारा उद्धृत लेख आधिकारिक नहीं है, और टाइपस्क्रिप्ट टीम की किसी भी आधिकारिक सामग्री को नहीं दर्शाता है।

इसके अलावा, यह कई वार्ताओं, साक्षात्कारों और पोस्टों में @ahejlsberg द्वारा बताए गए

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

सी # या नहीं, हमें आंशिक कक्षाओं की आवश्यकता है जो टाइपस्क्रिप्ट को जावास्क्रिप्ट की प्रोटोटाइप सुविधाओं के करीब लाने में मदद करेगी।

@yahiko00
टाइपस्क्रिप्ट में पहले से ही जावास्क्रिप्ट की सभी प्रोटोटाइप विशेषताएं हैं।
यह एक सुपरसेट है।

टाइपस्क्रिप्ट में आंशिक कक्षाओं की धारणा के साथ कई समस्याएं हैं, जिनमें शामिल हैं

1. सी # के विपरीत, टाइपस्क्रिप्ट (जावास्क्रिप्ट) वर्ग परिभाषाएं अनिवार्य नहीं घोषणात्मक हैं। वे घोषणात्मक दिखाई देते हैं, लेकिन वे नहीं हैं। इसका मतलब है कि वे नियतात्मक निष्पादन आदेश पर निर्भर करते हैं।
2. ईसीएमएस्क्रिप्ट मॉड्यूल सिस्टम भौतिक नहीं तार्किक कोड इकाइयों के आयात पर आधारित है।
   उदाहरण के लिए, मान लें कि मेरे पास है

_app/my-class-part-1.ts_

TypeScript export partial class MyClass { firstName = "John"; lastName = "Smith"; }

तथा
_app/my-class-part-2.ts_

TypeScript export partial class MyClass { fullName = this.firstName + ' ' + this.lastName; }

मैं इस वर्ग को कैसे आयात कर सकता हूं? चूंकि मैं किसी भी मॉड्यूल से आयात नहीं कर सकता, आइए टाइपस्क्रिप्ट में एक काल्पनिक अमूर्तता की कल्पना करें जो मुझे लिखने की अनुमति देता है
_app/main.ts_

TypeScript import { MyClass } from './my-class';

इसका क्या मतलब होगा? भले ही टाइपस्क्रिप्ट कंपाइलर यह अनुमान लगा सके कि _app/my-class-part-1.ts_ को _app/my-class-part-2.ts_ से पहले लोड किया जाना है, यह अलग-अलग हिस्सों के आयात को अमान्य नहीं बना सकता है और न ही यह सुनिश्चित कर सकता है वे एक अतुल्यकालिक मॉड्यूल लोडर द्वारा सही क्रम में आयात किए जाते हैं जैसे कि RequJS या अंततः ब्राउज़र में क्या लागू किया जाएगा।

आंशिक कक्षाओं की पूरी धारणा मूल रूप से ईसीएमएस्क्रिप्ट मॉड्यूल सिस्टम के साथ है।

अद्यतन: इसे मनमाने ढंग से जटिल निर्भरता अनुमान करने और कुछ बहुत ही अजीब जावास्क्रिप्ट उत्सर्जित करने की आवश्यकता होगी।

टाइपस्क्रिप्ट में पहले से ही जावास्क्रिप्ट की सभी प्रोटोटाइप विशेषताएं हैं।
यह एक सुपरसेट है।

मुझे खुद को बेहतर तरीके से व्यक्त करना चाहिए था। बेशक हम सभी जानते हैं कि टाइपस्क्रिप्ट जावास्क्रिप्ट का सुपरसेट है। लेकिन मैं कहना चाहता था कि आंशिक कक्षाएं टाइपस्क्रिप्ट कक्षाओं को जेएस प्रोटोटाइप के करीब लाने में मदद करेंगी। फिलहाल, हमारे पास केवल "स्थैतिक" और गैर-विस्तार योग्य कक्षाएं हो सकती हैं, जबकि, एक प्रोटोटाइप दृष्टिकोण के साथ, हम वर्ग-जैसे कार्यों का विस्तार कर सकते हैं।

आंशिक कक्षाओं को आयात करने से मेरे द्वारा सहमत वर्तमान ES6 सिंटैक्स का विस्तार होगा। हम कुछ इस तरह की कल्पना कर सकते हैं:

import { MyClass } from ['app/my-class-part-1', 'app/my-class-part-2'];

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

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

@aluanhaddad मैं देखता हूं कि मॉड्यूल के संबंध में आपका क्या मतलब है। एक संभावित समाधान फाइलों में से केवल एक को export partial class जबकि शेष में केवल partial class परिभाषाएं होंगी। आप इसे उस जगह से आयात करते हैं जहां से इसका निर्यात होता है। आपके उदाहरण से:

_app/my-class.ts_

export partial class MyClass {
    firstName = "John";
    lastName = "Smith";
}

_app/my-class.part.ts_

partial class MyClass {
    get fullName(): string {
        return this.firstName + ' ' + this.lastName;
    }
}

_app/main.ts_

import { MyClass } from './my-class';

क्या गुम है संकलक को यह बताने के लिए एक वाक्यविन्यास है कि भागों का पता लगाने के लिए कहां है। यह सी # के साथ कोई समस्या नहीं है जहां आप सभी फाइलों को एक साथ संसाधित करते हैं। यह एक विशेष वाक्यविन्यास हो सकता है, जैसा कि घोषणा विलय के लिए उपयोग किया जाता है।

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

मैं यह देखने में विफल हूं कि इन परिदृश्यों के लिए मॉड्यूल ऑग्मेंटेशन क्यों मान्य नहीं है। यह हमारे लिए Rxjs5 के साथ बहुत अच्छा काम करता है।

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

क्या यह आंशिक कक्षाओं के लिए एक आदर्श प्रतिस्थापन है? मुझे नहीं लगता, लेकिन मैं आंशिक कक्षाएं तब तक नहीं देखता जब तक कि ईसीएमएस्क्रिप्ट तय नहीं करता कि जावास्क्रिप्ट को उनकी आवश्यकता है। अकेले बाहरी मॉड्यूल के बीच आंशिक कक्षाओं को एक साथ कैसे जोड़ा जाता है, इसके लिए शब्दार्थ मेरे सिर को चोट पहुँचाता है।

@ डेविड-ड्रिस्कॉल इसे और भी बेहतर बनाने के लिए, एक मजबूत टाइप-चेकिंग के लिए अतिरिक्त तरीकों में this: तर्क घोषित किया जा सकता है।

मॉड्यूल ऑग्मेंटेशन के उद्धृत उदाहरण में:

// observable.ts stays the same
// map.ts
import { Observable } from "./observable";
declare module "./observable" {
    interface Observable<T> {
        map<U>(f: (x: T) => U): Observable<U>;
    }
}
Observable.prototype.map = function (this: Observable, f) {
    // here "this" has the shape of the "Observable" class
}

हां। Rxjs अभी तक इसका उपयोग नहीं करता है, क्योंकि यह एक 2.0 विशेषता है, और 2.0 अभी तक जारी नहीं किया गया है। यह बाद में मेरी हिट लिस्ट में है।

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

_app/my-class.ts_

export partial class MyClass {
    firstName = "John";
    lastName = "Smith";
}

ऐप/my-class.part.ts

partial class MyClass {
    get fullName(): string {
        return this.firstName + ' ' + this.lastName;
    }
}

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

क्या गुम है संकलक को यह बताने के लिए एक वाक्यविन्यास है कि भागों का पता लगाने के लिए कहां है। यह सी # के साथ कोई समस्या नहीं है जहां आप सभी फाइलों को एक साथ संसाधित करते हैं। यह एक विशेष वाक्यविन्यास हो सकता है, जैसा कि घोषणा विलय के लिए उपयोग किया जाता है।

घोषणा विलय _declarations_ के लिए काम करता है, स्रोत फ़ाइलों के लिए नहीं।

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

ये सभी _are_ आमतौर पर निर्भर करते हैं।

संपादित करें: यह कहना है कि उन्हें परिभाषित करना वर्ग को संशोधित करता है।

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

बीटीडब्लू: अगर किसी को सी # कक्षाओं से टीएस प्रकार उत्पन्न करने की ज़रूरत है तो आप टाइपस्क्रिप्टबिल्डर की जांच कर सकते हैं

इस पर विचार करने के लिए धन्यवाद!

मैं आपके टाइपस्क्रिप्टबिल्डर को आजमाने जा रहा हूं;)

मेरा सुझाव...

क्या होगा अगर संकलक ने सभी भागों को खोजने की कोशिश नहीं की? क्या होगा यदि मुझे अन्य भागों का आयात करना पड़े और सब कुछ नियंत्रित करना पड़े?

/MyClass.partial.ts

export partial class MyClass {
    firstName = "John";
    lastName = "Smith";
}

MyClass.ts

// v- this would NOT throw an error because the definition is marked as partial
import { MyClass } from "./MyClass.partial";

export class MyClass {
    get fullName(): string {
        return this.firstName + ' ' + this.lastName;
    }
}

फिर...

1. अगर मैं MyClass का उपयोग करना चाहता हूं तो मुझे इसे MyClass.ts से आयात करना होगा
2. संकलित होने पर, MyClass.partial.ts एक जावास्क्रिप्ट उत्पन्न करेगा जो MyClass.prototype बढ़ाता है जैसा कि पहले यहां दिखाया गया था। लेकिन यह एक फ़ंक्शन निर्यात करता है जो प्रोटोटाइप को विस्तारित करने के लिए प्राप्त करता है।
3. MyClass.partial.ts को MyClass में आयात किया जाता है जब MyClass को परिभाषित किया जाता है और इसका विस्तार फ़ंक्शन कहा जाता है।

एक तरफ ध्यान दें ... मुझे सीधे संकलित कोड उत्पन्न करने से कोई रोक नहीं रहा है। लेकिन मैंने टाइपस्क्रिप्ट की सारी महानता खो दी।

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

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

कंपाइलर के लिए यह सब ट्रैक करना मुश्किल हो सकता है, लेकिन जैसा कि आप सुझाव देते हैं, इसे स्पष्ट रूप से काम करने के लिए बनाया जा सकता है।

यह उस प्रकार की प्रणाली में वृद्धि होगी, जिसमें आंशिक वर्ग उस वृद्धि से बाहर होने वाले मामले का उपयोग करते हैं।

मैंने इसे निम्नलिखित की तरह किया है:

मैंने इसे निम्नलिखित की तरह किया है :
 फ़ाइल1 . टी
 इंटरफ़ेस इफू {
 ए ( ) : शून्य ;
 }
 क्लास फू इफू लागू करता है {
 ए ( ) { /*कुछ करो*/ }
 }
 फ़ाइल 2 । टी
 /// <संदर्भ पथ = "file1.ts" /> // आवश्यक नहीं
 इंटरफ़ेस इफू {
 बी ( ) : शून्य ;
 }
 फू . प्रोटोटाइप । बी = ( ) = > { /*कुछ करो*/ }
 फ़ाइल3 . टी
 /// <संदर्भ पथ = "file1.ts" /> // आवश्यक नहीं
 इंटरफ़ेस इफू {
 ग ( ) : शून्य ;
 }
 ( < ifoo > foo । प्रोटोटाइप ) । सी = ( ) = > { /*कुछ करो*/ }
 उपभोक्ता । टी
 /// <संदर्भ पथ = "file1.ts" />
 /// <संदर्भ पथ = "file2.ts" />
 /// <संदर्भ पथ = "file3.ts" />
 चलो f = नया फू ( ) ;
 च । ए ( ) ;
 च । बी ( ) ;
 च । ग ( ) ;

मॉड्यूल ऑग्मेंटेशन अभी भी यहां 90% समस्या का समाधान करता है। @svallory के उदाहरण दिए गए हैं।

/MyClass.partial.ts

export partial class MyClass {
    firstName = "John";
    lastName = "Smith";
}

MyClass.ts

// v- this would NOT throw an error because the definition is marked as partial
import { MyClass } from "./MyClass.partial";

export class MyClass {
    get fullName(): string {
        return this.firstName + ' ' + this.lastName;
    }
}

मॉड्यूल वृद्धि कुछ इस तरह होगी ...

MyClass.ts

export class MyClass {
    firstName = 'John';
    lastName = 'Smith';
}

MyClass.generated.ts

import { MyClass } from './test';

Object.defineProperty(MyClass.prototype, "fullName", {
    get(this:MyClass) {
        return this.firstName + ' ' + this.lastName;
    }
});

declare module './test' {
    interface MyClass {
        readonly fullName: string;
    }
}

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

आज आपके पास एकमात्र गोचा नहीं होगा:

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

संपादित करें: ध्यान रखें, यह TS 2.0+ सिंटैक्स है।

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

@wongchichong आपका उदाहरण वैश्विक वर्ग के नाम और /// <reference path="..."/> । मुझे नहीं लगता कि यह अच्छी तरह से बढ़ेगा, हालांकि आप स्थिति को सुधारने के लिए नामस्थान का उपयोग कर सकते हैं।
मॉड्यूल के रूप में लिखा गया कोड (जो बाहरी मॉड्यूल है) एक बहुत ही अलग जानवर है क्योंकि इसमें एक लोडर शामिल होता है जिसे निर्भरताओं के बारे में पता होना चाहिए जो ऑर्डर निर्भर और निहित हैं। इसीलिए @svallory का सुझाव मूल्यवान है, इसके लिए बहुत कम मात्रा में मैनुअल वायरिंग की आवश्यकता होती है जो निर्भरता को स्पष्ट करती है।

क्या होगा यदि कोई मॉड्यूल का उपयोग नहीं करता है?

@pankleks आंशिक कक्षाएं अभी भी एक बुरा विचार हैं।

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

सी # जैसी भाषा में, आंशिक कक्षाएं अच्छी तरह से काम करती हैं, लेकिन ऐसा इसलिए है क्योंकि वे मूल रूप से जावास्क्रिप्ट में कक्षाओं से अलग हैं।

यह याद रखना महत्वपूर्ण है कि जावास्क्रिप्ट में, वर्ग घोषणाओं को भी फहराया नहीं जाता है, अकेले घोषणात्मक।

ES6 को छोड़कर, "वर्ग" अवधारणा को TS द्वारा परिभाषित किया गया है। JS के पास _at all_ वर्ग की कोई धारणा नहीं है।
तो यह टाइपस्क्रिप्ट पर निर्भर है कि एक वर्ग क्या हो सकता है, नहीं?

ES6 को छोड़कर,

TS भाषा सुविधाओं पर चर्चा करते समय हम ES6 पर रोक नहीं लगा सकते, क्योंकि TS लक्ष्यों में से एक वर्तमान/भविष्य के ES युक्ति का पालन करना है ।

सच है :/

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

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

ऐसा लगता है कि एस्डिस्कस पर इस पर ज्यादा चर्चा नहीं हुई है, मुझे जो एकमात्र धागा मिला है उसमें 9 पोस्ट हैं।

@ yahiko00 ऐसा नहीं है कि मैं इस अवधारणा का विरोधी हूं। जैसा कि आप कहते हैं कि यह सी # जैसी भाषाओं में बहुत उपयोगी है।

एक उत्साही सी # प्रोग्रामर के रूप में, मुझे कुछ कार्यों के लिए आंशिक कक्षाएं बहुत उपयोगी लगती हैं। हालांकि, वे भाषा के अन्य पहलुओं में हस्तक्षेप नहीं करते हैं। वे नेमस्पेस, असेंबली, और मनमाने ढंग से ऑर्डर करने योग्य प्रकार की घोषणाओं जैसे प्रमुख संबंधित सार तत्वों को नहीं तोड़ते हैं।

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

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

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

उस ने कहा, जैसा कि @SaschaNaz बताते हैं, इस _does_ को ECMAScript में संबोधित करने की आवश्यकता है।

हो सकता है कि रुचि रखने वाला कोई भी व्यक्ति http://esdiscuss.org पर एक नया सूत्र खोल सकता है और यहां यूआरएल पोस्ट कर सकता है ताकि हम वहां चर्चा जारी रख सकें

पुनश्च: या अधिक-GitHub- जैसे ES प्रवचन पर ।
PS2: या भी- GitHub-like-and-more-active

मुझे भी कुछ निर्माण देखना अच्छा लगेगा जो टीएस के लिए कोड जनरेशन की अनुमति देता है। सी # में इसके लिए आंशिक वर्ग बहुत अच्छा काम करते हैं।

हो सकता है कि मुझे कुछ याद आ रहा हो, लेकिन मुझे ऐसा लगता है कि मूल मुद्दा एक वर्ग को 'निजी' चर तक पहुंच के साथ कन्स्ट्रक्टर के अलावा कहीं और से बढ़ा रहा है, अधिमानतः किसी अन्य फ़ाइल से।

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

एक पूर्वापेक्षा है कि एक अच्छा डिसुगरिंग ढूंढा जाए :

हालांकि मैंने पहले सोचा था कि आंशिक कक्षाएं बहुत मूर्खतापूर्ण थीं क्योंकि आप सीधे कक्षा में जोड़ सकते थे, मैं अपील देख सकता हूं कि ऐसा करने में आपके तरीकों को गैर-गणना योग्य बनाने के साथ-साथ सुपर बाध्यकारी को ठीक करना शामिल होगा (जिनमें से बाद में वर्तमान में असंभव है ईएस6)।

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

सुनिश्चित नहीं है कि इसका वास्तव में क्या अर्थ है लेकिन शायद इस तरह:

class A {
  foo() { return "foo" }
}
class B extends A {
}

partial(B, class {
  get foo() {
    return super.foo(); // should work
  }
});

( एस्किसस पर क्रॉस पोस्ट किया गया)

ऐसा लगता है कि शुद्ध जेएस ( ES2017 getOwnPropertyDescriptors के साथ) में आंशिक वर्ग को लागू करने का एक आसान तरीका है। ES लोग सोच सकते हैं कि केवल इस छोटे से कोड को हटाने के लिए सिंटैक्स चीनी की भी आवश्यकता नहीं होगी।

function partial(base, extension) {
  extension.prototype.__proto__ = base.prototype.__proto__; // to enable 'super' reference
  const descriptors = Object.getOwnPropertyDescriptors(extension.prototype);
  delete descriptors.constructor; // must not override constructor
  Object.defineProperties(base.prototype, descriptors);
  
  return base;
}

टीएस पर इसका उपयोग करने के लिए मौजूदा वर्ग प्रकार का विस्तार करने के लिए interface डुप्लिकेट की आवश्यकता होती है।

@SaschaNaz मुझे उम्मीद है कि getOwnPropertyDescriptors के माध्यम से कंस्ट्रक्टर में जोड़े गए गुण IDE "ऑटोसुगेशन" के लिए छिपाए जाएंगे (क्योंकि वे रनटाइम पर जोड़े जाते हैं)। याद रखें, टाइपस्क्रिप्ट "स्वत: सुझाव" के साथ एक जावास्क्रिप्ट के रूप में पैदा हुआ है (कभी-कभी लोग इसे "स्ट्रोलजी टाइप किया हुआ" कहते हैं, लेकिन वास्तव में उन्हें जो पसंद है वह "ऑटोसुजेशन" है)।

पीएस लोगों को आंशिक कक्षाओं की आवश्यकता क्यों है - कोडजनरेशन। लेकिन फिर से कोड जनरेशन को IDE (आसान "टूल" को सोर्स फाइल में एडजस्ट करना, फाइल एक्सप्लोरर में पदानुक्रमित परिणाम, T4 या इसी तरह के "कॉमन कोडजेनरेटर" सपोर्ट) और भाषा (आंशिक क्लास, एक्सटेंशन मेथड्स) दोनों द्वारा समर्थित होना चाहिए। इसे समझने के बाद ही यह समझना संभव हो पाता है कि डेवलपर्स वास्तव में क्या पूछते हैं। यदि आप पूरी तस्वीर नहीं देखते हैं - बेशक "आंशिक कक्षाएं" "बकवास" की तरह दिखती हैं।

@aluanhaddad : लेकिन टाइपस्क्रिप्ट का मुख्य कार्य हमें भाषा तत्व प्रदान करना नहीं है जो जावास्क्रिप्ट में मौजूद नहीं हैं? एक वर्ग को दो आंशिक टाइपस्क्रिप्ट फ़ाइलों में विभाजित करना एक बुरा विचार क्यों है, जिसे एक एकल जावास्क्रिप्ट फ़ाइल में संकलित किया जाएगा?

मैं वास्तव में समुदाय को एक उपकरण देने में समस्या नहीं देखता। और मुझे 100% यकीन है कि ऐसे देव होंगे जो इसका दुरुपयोग करेंगे। लेकिन ऐसे देवता भी हैं जो इसका उपयोग करना जानते हैं। लेकिन क्या किसी भाषा की किसी रचना के साथ हमारी यही स्थिति नहीं है?

कोड जनरेशन उद्देश्यों के लिए +1। और मैं @rpokrovskij से सहमत टाइपस्क्रिप्ट क्यों चुनते हैं, मैं सीधे जावास्क्रिप्ट का भी उपयोग कर सकता हूं, सिर्फ इसलिए कि यह सी # जैसा लगता है, और इसमें विचारधारा का समर्थन है।

@greendimka मुझे नहीं पता कि यह ES मॉड्यूल से अलग होने और पर्याप्त जटिलता को जोड़ने के बिना कैसे काम कर सकता है।

@ xiexin36 टाइपस्क्रिप्ट निश्चित रूप से मेरे लिए सी # की तुलना में जावास्क्रिप्ट की तरह लगता है।
जावास्क्रिप्ट और सी# के बीच समानताएं हैं, लेकिन class की उनकी धारणाएं अलग हैं।

@ xiexin36 कोड पीढ़ी के लिए आप अभी भी मॉड्यूल वृद्धि का उपयोग कर सकते हैं (जैसा कि मैंने पहले इस धागे में नोट किया

@aluanhaddad ठीक है, यह बहुत सरलता से काम करता है: आंशिक वर्ग किसी भी तरह से कोड की संरचना को नहीं बदलते हैं। वे हमें कई फाइलों में एक ही वर्ग की परिभाषा लिखने की अनुमति देते हैं (जो वैसे भी एकल जेएस में संकलित हैं)।

@aluanhaddad कड़ाई से बोलते हुए: जावास्क्रिप्ट में कक्षाओं की कोई अवधारणा नहीं है (ईएस 6 कक्षाएं सिर्फ एक वाक्य रचनात्मक चीनी प्रदान करती हैं)। इसलिए, अगर हम टाइपस्क्रिप्ट को जावास्क्रिप्ट के रूप में कमजोर होने की अवधारणा का पालन करने की कोशिश करते हैं - तो क्या हमें टाइपस्क्रिप्ट से कक्षाओं को दूर नहीं करना चाहिए? क्या हमें केवल जावास्क्रिप्ट पर वापस नहीं जाना चाहिए?

@greendimka ES6 कक्षाएं और टाइपस्क्रिप्ट कक्षाएं एक ही हैं।
टाइपस्क्रिप्ट का उद्देश्य जावास्क्रिप्ट के रनटाइम में अतिरिक्त निर्माण जोड़ना नहीं है।

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

ES6 कक्षाएं _very_ कमजोर हैं लेकिन टाइपस्क्रिप्ट के लिए कक्षाओं की अपनी धारणा को पेश करना इसके डिजाइन लक्ष्यों का सीधा उल्लंघन होगा।

बस कक्षाओं से बचें और आपकी समस्या हल हो जाएगी।

खैर, यह बहुत सरलता से काम करता है: आंशिक वर्ग किसी भी तरह से कोड की संरचना को नहीं बदलते हैं। वे हमें कई फाइलों में एक ही वर्ग की परिभाषा लिखने की अनुमति देते हैं (जो वैसे भी एकल जेएस में संकलित हैं)।

और मनुष्य को ज्ञात लगभग हर उपकरण को तोड़ दो? नहीं धन्यवाद।

@ डेविड-ड्रिस्कॉल धन्यवाद, मैं इसे आज़माउंगा, लेकिन मैं कोणीय 2.0 का भी उपयोग करता हूं, मुझे आश्चर्य है कि क्या मैं कोड उत्पन्न करता हूं
@ इनपुट या @ आउटपुट , यह काम करेगा, वैसे भी मैं इसे

@aluanhaddad यह देखने में दर्द होता है कि आपने "कक्षाएं" दोहराने पर कैसे लटका दिया? जावास्क्रिप्ट में कोई वर्ग नहीं है। अपने सिर से कक्षाएं हटा दें, केवल जावास्क्रिप्ट छोड़ दें, और अब सुनें: कोड पीढ़ी का उपयोग करने वाले डेवलपर्स कई फाइलों में एक संकलन इकाई रखना चाहते हैं। इस भाषा में कोई वर्ग नहीं हैं, केवल कार्य हैं? ठीक है, हम आंशिक कार्य चाहते हैं। और इसके लिए जावास्क्रिप्ट लगभग तैयार है: घोषणा से पहले वहां के कार्यों का उपयोग किया जा सकता है। वहां हम निश्चित रूप से अन्य समस्याओं को पूरा कर सकते हैं (उदाहरण के लिए यह सुनिश्चित करने के लिए कि सभी भागों/फाइलों को निष्पादन पर्यावरण में लोड किया गया है), लेकिन वे हल करने योग्य हैं, और वास्तव में हम टाइपस्क्रिप्ट में आंशिक संकलन इकाइयां रखना चाहते हैं, जावास्क्रिप्ट में नहीं। इसके लिए टाइपस्क्रिप्ट 100% तैयार है।

और वैसे, टाइपस्क्रिप्ट टीम, हमें आंशिक कार्य भी देती है! और कृपया इसे C# टीम को भी बताएं, क्योंकि अभी हमारे पास "फ़ंक्शंस में फ़ंक्शन" हैं। :)

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

@aluanhaddad । क्या आप "कई फाइलों में एक संकलन इकाई" शब्द को समझते हैं? जावास्क्रिप्ट निश्चित रूप से संकलन भाषा नहीं है लेकिन ए) निष्पादन से पहले फ़ंक्शन को पूरी तरह से पार्स किया जाना चाहिए और हम इसे "संकलन" नाम दे सकते हैं बी) टाइपस्क्रिप्ट संकलन भाषा है।

अपनी कल्पना में मदद करने के लिए:

function partial func(arguments) {
  return function() {
    return codegenerated(arguments);
  };
}

function partial func(arguments) {
   function codegenerated(arguments){
      // ...
   }
}

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

@rpokrovskij
अगर मैं विरोधी के रूप में सामने आया तो मैं क्षमा चाहता हूं। मेरा मतलब कोई अपराध या अनादर नहीं था।

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

@aluanhaddad....
"बस कक्षाओं से बचें और आपकी समस्या हल हो जाएगी" - गंभीरता से, यह एक समस्या का समाधान है ?! शायद अगर मैं जावास्क्रिप्ट का उपयोग करने से बचता हूं - मैं इस पूरी चर्चा की समस्या को हल कर सकता हूं। एक समाधान भी, है ना? दुर्भाग्य से हमारे ब्रह्मांड में यह घटिया भाषा है क्योंकि कई साल पहले वेब में आने के लिए यह काफी भाग्यशाली था। वैसे भी, यह एक ऑफटॉपिक है।

"मनुष्य को ज्ञात लगभग हर उपकरण को तोड़ दो" - यह कैसे संभव है ??? कैसे?!?! मैं टाइपस्क्रिप्ट में आंशिक कक्षाओं का उपयोग करके कुछ तोड़ने की कल्पना करने की कोशिश करता हूं, लेकिन मैं नहीं कर सकता। मैं बस नहीं कर सकता। कृपया, कुछ वास्तविक जीवन उदाहरण के साथ यहां मेरी सहायता करें।

अब कल्पना कीजिए कि आपने बक्सों को ले जाने के लिए एक कार का निर्माण किया है। यह बिना किसी समस्या के काम करता है। आप एक कर्मचारी को काम पर रखते हैं, जो कार को लोड करता है। कार्यकर्ता एक बार में दो डिब्बे लेता है और कार में डालता है। फिर भी सब कुछ ठीक काम करता है।
एक दिन कर्मचारी दूसरी कंपनी के लिए निकल जाता है और आप एक नई कंपनी किराए पर लेते हैं। नया एक सिंगल बॉक्स लेता है, उसे लोड करता है, दूसरा सिंगल बॉक्स लेता है और उसे भी लोड करता है। तार्किक रूप से: सब कुछ ठीक है। लेकिन आप इधर-उधर भागते हैं और चिल्लाते हैं: रुको, रुको, हमारे पास सिस्टम फेल है! :)

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

ES2015 में निश्चित रूप से कई चीजें गलत हैं। ES5.1 में निश्चित रूप से कई चीजें गलत थीं। मेरी राय में, कक्षाओं की कमी उन चीजों में से एक नहीं थी। मेरा कहना है कि रिवीलिंग मॉड्यूल पैटर्न जैसी तकनीकों का उपयोग करके आप आंशिक कक्षाओं की आवश्यकता को कम करते हैं। टाइपस्क्रिप्ट रिवीलिंग मॉड्यूल पैटर्न, नेमस्पेस के लिए चीनी प्रदान करता है।

"मनुष्य को ज्ञात लगभग हर उपकरण को तोड़ दो" - यह कैसे संभव है ??? कैसे?!?! मैं टाइपस्क्रिप्ट में आंशिक कक्षाओं का उपयोग करके कुछ तोड़ने की कल्पना करने की कोशिश करता हूं, लेकिन मैं नहीं कर सकता। मैं बस नहीं कर सकता। कृपया, कुछ वास्तविक जीवन उदाहरण के साथ यहां मेरी सहायता करें।

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

इसलिए, मूल रूप से, किसी भाषा के विकास को उन उपकरणों द्वारा रोका जा रहा है, जो भाषा के विकास के बिना कभी विकसित नहीं होंगे।
क्षमा करें, लेकिन मैं यहां केवल विकसित न होने के कारण की खोज देख रहा हूं।

आंशिक कक्षाएं क्या लाभ देती हैं, कि आप पहले से ही भाषा के साथ अलग तरीके से नहीं कर सकते हैं? यह अच्छी वाक्य रचनात्मक चीनी है, निश्चित रूप से, लेकिन असली लाभ क्या है? क्या इसे सी # की तरह बनाने के अलावा कोई ठोस उदाहरण है?

इसके अलावा: रिकॉर्ड के लिए मैंने सी # डेवलपर के रूप में शुरुआत की, वहां से जावास्क्रिप्ट/सी # में स्थानांतरित हो गया। एक बार टाइपस्क्रिप्ट 0.8 की घोषणा के बाद मुझे बेच दिया गया था, इसलिए नहीं कि यह जावास्क्रिप्ट के लिए सी # था, बल्कि इसलिए कि यह सख्त जावास्क्रिप्ट ले रहा था और डेवलपर्स के लिए इसे बेहतर बना रहा था जो मजबूत प्रकार के सी # का आनंद लेते थे।

टाइपस्क्रिप्ट सी # नहीं है, और सी # से सुविधाओं को सख्ती से विरासत में नहीं लेना चाहिए क्योंकि सी # उनके पास है। जैसे सी # को टाइपस्क्रिप्ट से सुविधाओं का उत्तराधिकारी नहीं होना चाहिए। मैं उस समय की गणना नहीं कर सकता जब मुझे सी # में यूनियन प्रकार जैसी सुविधाएं चाहिए क्योंकि वे टाइपस्क्रिप्ट के लिए बहुत बढ़िया हैं, लेकिन वे अभी तक भाषा के लिए सही नहीं हैं।

अब तक मैंने कोड जनरेशन और कोड ऑर्गनाइजेशन पढ़ा है।

कोड जनरेशन, मॉड्यूल ऑग्मेंटेशन को देखें, कुछ कमियां हैं जिन्हें मैंने यहां बताया था लेकिन मुझे यकीन है कि उन्हें ठीक किया जा सकता है।

कोड संगठन, मुझे लगता है कि क्षेत्रों का उपयोग करें (एलओएल)? आपको कोड व्यवस्थित करने के कई अन्य तरीके हैं, यदि आपके पास एक ईश्वर वर्ग है (किसी भी कारण से) तो आप इसे हमेशा कई ईश्वर वर्गों में विभाजित कर सकते हैं। सतह पर ईश्वर वर्ग वह आयात है जिसे हर कोई देखता है और उपयोग करता है, हालांकि यह कई वर्गों से बना है जो शायद ईश्वर वर्ग के गुणों के रूप में है। यदि आप संगठन के लिए आंशिक कक्षाओं का उपयोग कर रहे हैं तो मैं तर्क दूंगा कि आपको कोशिश करने के लिए अपने कोड को थोड़ा सा रीफैक्टर करने की आवश्यकता है और SOLID अपने कोड को ify करें।

मैं आज तक सामना किए गए अधिकांश कोड जनरेशन परिदृश्यों में वृद्धि को फिट करने में सक्षम हूं।

Omnisharp-Client के लिए मैं यहां इंटरफ़ेस एक्सटेंशन OmniSharp.Api.V2 सी # में प्रतिबिंब के माध्यम से उत्पन्न होता है। फ़ाइल के निचले भाग में मेरे पास एक उपकरण है जो उस इंटरफ़ेस के सभी तरीकों को रोकता है।

RxJS के लिए हम करने के लिए करने के लिए उपयोग हमारे सभी विधियों के नक्शे पर हैं नमूदार ।

मैं आंशिक कक्षाओं के साथ कुछ मुद्दों के बारे में तर्क नहीं कर सकता। उदाहरण के लिए यदि हमें 3 आंशिक वर्ग दिए गए हैं।

• MyAwesomeClass1.ts
• MyAwesomeClass2.ts
• MyAwesomeClass3.ts

दायरा: वैश्विक मॉड्यूल ( namespace / module )

वैश्विक संकलन वह जगह है जहां यह सबसे आसान प्रतीत होता है। जैसा कि टाइपस्क्रिप्ट पहले से ही नामस्थानों को एक साथ मिला देता है।

यदि मेरे tsconfig.json केवल Class1 और Class2 के लिए फ़ाइल पथ हैं, तो Class3 में जो कुछ भी है वह स्वचालित रूप से विलय नहीं होता है।

• सबसे पहले यह उपयोगकर्ता त्रुटि की तरह लगता है, लेकिन यह तुरंत स्पष्ट नहीं होगा कि कक्षा 3 के तरीकों को शामिल क्यों नहीं किया गया है। यह एक बहुत बड़ी उपयोगिता समस्या है जिससे भ्रम की स्थिति पैदा होगी।

दायरा: बाहरी मॉड्यूल (आयात / निर्यात)

बाहरी संकलन के साथ, प्रत्येक फ़ाइल को वास्तव में मॉड्यूल (या .NET दुनिया में नरक असेंबली) माना जाता है क्योंकि प्रत्येक मॉड्यूल में इसकी सभी निर्भरताओं (आयात) और इसके सभी सार्वजनिक एपीआई (निर्यात) की एक स्पष्ट सूची होती है।

आप इन परिदृश्यों के बारे में कैसे तर्क करते हैं?

केवल एक फ़ाइल संदर्भ को देखते हुए, कक्षा का व्यवहार क्या है?
क्या यह स्वचालित रूप से कक्षा 2 और कक्षा 3 को मर्ज करता है?

• क्या Class1, Class2 और Class3 की डिफ़ॉल्ट परिभाषा सभी एक ही मान को एक्सपोर्ट करती हैं?
• डिस्क में कौन सी फाइल उत्सर्जित होती है?
• सभी समर्थित प्रारूपों (amd, umd, commonjs, आदि) के लिए अंतर्निहित JavaScript कैसा दिखेगा

// somefile.ts
import { MyAwesomeClass } from 'MyAwesomeClass1';

new mac = new MyAwesomeClass();
mac. // What methods are available here?

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

// somefile.ts
import { MyAwesomeClass } from 'MyAwesomeClass1';
import { MyAwesomeClass } from 'MyAwesomeClass2'; // or maybe import 'MyAwesomeClass2';
import { MyAwesomeClass } from 'MyAwesomeClass3'; // or maybe import 'MyAwesomeClass3';

new mac = new MyAwesomeClass();
mac. // What methods are available here?

@ डेविड-ड्रिस्कॉल बस मेरे दो सेंट यहाँ:

यह अच्छी वाक्य रचनात्मक चीनी है, निश्चित रूप से, लेकिन असली लाभ क्या है?

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

और जबकि भाषाएं आम तौर पर कंप्यूटर को निर्देश देने के संचालन भाग में अच्छी होती हैं, वे आम तौर पर कोड लिखने के संगठनात्मक हिस्से में चूसते हैं। हमारे पास ये सांस्कृतिक तदर्थ कलाकृतियाँ हैं जैसे वस्तुएं, वर्ग, विरासत और ऐसे, लेकिन कोई ठोस सैद्धांतिक आधार नहीं है, afaik, जो वास्तव में संचालन के आयोजन के क्षेत्र और उन सभी अमूर्तताओं की व्याख्या करता है जिन्हें हम अपने स्रोत कोड में क्रम में बनाने और प्रस्तुत करने का प्रयास कर रहे हैं। इसके साथ अच्छे तरीके से काम करने में सक्षम होने के लिए।

टाइपस्क्रिप्ट के बारे में मुझे दो चीजें पसंद हैं: 1. यह हमें टाइप की गई जावास्क्रिप्ट का उपयोग करने देता है ताकि क्लाइंट में जटिल सिस्टम बनाने के लिए यह अचानक प्रबंधनीय हो। 2. प्रकार प्रणाली अत्यंत अभिव्यंजक है (क्योंकि इसे जावास्क्रिप्ट में सभी प्रकार के पैटर्न को व्यक्त करने में सक्षम होने के लिए मजबूर किया गया था जिसे लोग एक प्रकार की प्रणाली की सीमा के बिना लिख ​​सकते थे)।

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

आंशिक वर्ग न केवल विशेष रूप से कोड निर्माण के लिए बहुत सुविधाजनक हैं, बल्कि यह सामान्य रूप से संगठन में स्वतंत्रता को बढ़ाता है। स्वतंत्रता जो हमें कोड संगठन के इस कलंक से बाहर निकलने के लिए चाहिए।

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

और नहीं: टाइपस्क्रिप्ट में आंशिक होने का अनुरोध इस विचार पर आधारित नहीं है कि C# उनके पास है। मुझे विश्वास नहीं है कि टाइपस्क्रिप्ट में सिर्फ इसे रखने के लिए कुछ होना चाहिए क्योंकि किसी अन्य भाषा में यह है।

और अंत में: आपको ऐसा क्यों लगता है कि यदि आप किसी चीज़ का उपयोग नहीं करते हैं - किसी को इसकी आवश्यकता नहीं है?

@greendimka मैं किसी भी शत्रुता को ढाल:। मैं बस परिदृश्यों को समझने की कोशिश कर रहा हूं या अगर कुछ हैं तो मैं अनजान हूं जो स्पष्ट रूप से पूरी तरह से संभव है!

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

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

ऐसा नहीं है कि मैं इसका उपयोग नहीं करूंगा (यदि यह अस्तित्व में होता तो शायद मैं होता)। समस्या यह है कि यह इस मुद्दे में खड़ा है, आंशिक वर्गों में चेतावनी हो सकती है, इसलिए ऐसा लगता है कि इसे जल्द ही किसी भी समय लागू किया जाएगा। यह संभवत: कुछ समय के लिए इस तरह से रहेगा जब तक a) यह एक उच्च मूल्य वाले हितधारक के लिए एक आवश्यक विशेषता बन जाता है या b) एक प्रस्ताव TC39 के बाद के चरणों में भाप बन जाता है।

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

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

• क्या यह एकदम सही है? से बहुत दूर! मुझे भाषा स्तर पर समर्थन की आवश्यकता वाले मिश्रणों के साथ कहीं अधिक सामान्य परिदृश्य दिखाई देता है। और मुझे लगता है कि यहां प्रस्तावित सज्जाकारों के साथ कुछ लाइन समझ में आती है, हालांकि फिर से कोई विशिष्ट प्रस्ताव नहीं है।

@ डेविड-ड्रिस्कॉल, बेहद कठोर होने के लिए खेद है। मैं वास्तव में सकारात्मक प्रगति के पक्ष में खड़ा हूं।

मुझे यह पसंद है ताकि मैं आंशिक कक्षा में स्थिर कार्यान्वयन कर सकूं।

चूंकि ऐसा नहीं लगता है कि यह जल्द ही सामने आएगा, इसलिए मैं एक समाधान का प्रस्ताव देना चाहूंगा जो हमें मिला। इस तरह की कुछ टिप्पणियां हैं, लेकिन मैंने इन विशिष्टताओं को पढ़ने वाला कोई नहीं देखा।

हम कोड जनरेशन परिदृश्य में उपयोग के लिए आंशिक चाहते हैं जहां हम अपने जेनरेट किए गए टाइपस्क्रिप्ट कोड का विस्तार करने में सक्षम होना चाहते हैं। हालांकि, हम ऐसे मॉडल तैयार कर रहे हैं जिनमें अन्योन्याश्रितताएं हैं इसलिए हमारी कक्षाओं से विरासत पारंपरिक अर्थों में अच्छी तरह से काम नहीं करती है। उत्पन्न वर्ग जो अन्य वर्गों को संदर्भित करते हैं, वे सही प्रकार के ऑब्जेक्ट के संदर्भ में समाप्त नहीं होते हैं और हम सही इंस्टेंस प्रकार बनाने के लिए एक जटिल फैक्ट्री पैटर्न के साथ समाप्त होते हैं।

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

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

फ़ाइल 1: बेस क्लास

module ViewModels {
    export class PersonBase {
        // Generated members
        public anotherPerson: Person;
        constructor(){
            // Generated constructor code
        }
    }
}

फ़ाइल 2: वास्तविक वर्ग

module ViewModels {
    export class Person extends PersonBase {
        // Custom methods
        public NewVariable: string = "NewVar";
        constructor() {
            super();
            // Custom constructor code
        }
    }
}

इसने जेनरेट कोड के साथ हमारी आंशिक कक्षा की समस्या हल कर दी है। इस विचार के साथ आने के लिए कुडोस टू एंड्रयू स्कॉट।

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

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

Foo.prototype.someFunction = function() {/*....*/}

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

@RyanCavanaugh आप उल्लेख करते हैं कि यहां मांगी गई हर चीज को अन्य टाइपस्क्रिप्ट सिंटैक्स के साथ वाक्यात्मक रूप से नियंत्रित किया जा सकता है:

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

तो टाइपस्क्रिप्ट में ऐसा करने के बारे में कोई कैसे जाएगा ?:
File1.ts:

// Imagine this file is code generated and could be regenerated during development
export partial class Contact
{
    firstName: string;
    lastName: string;
    partial OnInit( args: any ) : void;
    constuctor( args: any )
    {
        this.OnInit( args );
    }
}
export class Address
{
    addr: string;
    city: string;
    state: string;
    zip: string;
}

File2.ts

// See where I'm going with this? This file would be hand edited and allows me to specify associations and children.
partial class Contact
{
    Addresses: string[] = [];
    partial OnInit( args: any ) void
    {
        this.firstName = args.firstName;
        this.lastName = args.lastName;
        this.Addresses.push( new Address() );
    }
}

उपरोक्त ट्रांसपिलिंग संपर्क के लिए एक जेएस क्लास उत्सर्जित करेगा, ऐसा कुछ:

var Contact = (function () {
    function Contact() {
         this.Addresses = [];
   }
   Contact.prototype.constuctor = function (args) {
       this.OnInit( args );
   };
   Contact.prototype.OnInit = function (args) {
       this.firstName = args.firstName;
       this.lastName = args.lastName;
       this.Addresses.push(new Address());
   };
   return Contact;
})();

var Address = (function () {
    function Address() {
    }
    return Address;
})();

ध्यान दें कि अंत में मुझे संपर्क नामक एक वर्ग चाहिए और मैं दो अलग-अलग वर्गों को तीसरे में उप-वर्ग नहीं करना चाहता हूं।

@cosmoKenney

यहां कुछ ऐसा उदाहरण दिया गया है जो काम करेगा। यह वाक्य रचना के रूप में partial है, हालांकि यह काम करता है और एक बहुत ही कार्यात्मक समाधान है।

// address.ts
export class Address
{
    addr: string;
    city: string;
    state: string;
    zip: string;
}

// contact.impl.ts
import { Address } from './address';

// Class implementation, do the things here that are not code generated
export class Contact {
    firstName: string;
    lastName: string;
    addresses: Address[];
    constructor(args: any) {
        this.onInit(args);
    }
}
// extending the interface here
// define methods you know will need in the constructor only
// This only applies to the constructor however
export interface Contact {
    onInit(args: any): void;
}

// contact.partial.ts
import { Contact } from './contact.impl';

// Implement the extended contract here
Contact.prototype.onInit = function(this: Contact, args: any) {
    this.addresses = args.addresses.concat();
    // do stuff;
};

// Adding another method (not part of the extended interface)
Contact.prototype.somethingAwesome = function(this: Contact) {
    // do awesome stuff here
};

// Tell TypeScript "I added this here!!!!"
declare module './contact.impl' {
    interface Contact {
        somethingAwesome();
    }
}

// contact.ts
import { Contact } from './contact.impl';
import './contact.partial';

// Bring it all together (perhaps there are more than one partial class?)
export { Contact };

// main.ts
import { Contact } from './contact';

// use the contact!
const contact = new Contact(['my', 'args']);
const {firstName, lastName} = contact;
contact.somethingAwesome();

वैकल्पिक रूप से आप इंटरफ़ेस उत्पन्न करने के लिए कोड भी कर सकते हैं और इंटरफ़ेस एक्सटेंशन का उपयोग करके इसे लागू कर सकते हैं।

नई मिक्सिन कार्यक्षमता का उपयोग करने के तरीके भी हो सकते हैं, हालांकि मैंने उसमें अभी तक गोता नहीं लगाया है, फिर भी मैं एक योग्य उत्तर देने के लिए पर्याप्त हूं।

@ डेविड-ड्रिस्कॉल वाह। मेरा सिर बस फट गया।

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

@greendimka

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

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

@cosmoKenney यह पूरी तरह से स्पष्ट नहीं था कि पता कहाँ मौजूद होना चाहिए। संदर्भ गलत होने के लिए मुझे क्षमा करें। मैं सिर्फ विकल्प देने में मदद करने की कोशिश कर रहा हूं। बहुत सारी कार्यक्षमता है जो आंशिक कक्षाओं जैसे संकलक में कुछ डाले बिना समान व्यवहार की अनुमति देती है, जिसमें मॉड्यूल सिस्टम (आंतरिक/बाहरी) दोनों को लागू करने के लिए बहुत से अतिरिक्त विचार और संभावित समस्याएं हैं।

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

अर्थात:

// address.partial.ts
export interface IAddress
{
    addr: string;
    city: string;
    state: string;
    zip: string;
}

// address.ts
import { IAddress } from './address.partial';

export class Address
{
    constructor(args: any) {

    }
}
export interface Address extends IAddress{}

// contact.partial.ts
import { IAddress } from './address.partial';

export interface IContact {
    firstName: string;
    lastName: string;
    addresses: IAddress[];
}

// contact.ts
import { Address } from './address';
import { IContact } from './contact.partial';

// Class implementation, do the things here that are not code generated
export class Contact {
    addresses: Address[] = [];

    constructor(args: any) {
        this.firstName = args.firstName;
        this.lastName = args.lastName;
        this.addresses.push( new Address("address?") );
    }

    public somethingAwesome() {
        //
    }
}
export interface Contact extends IContact {}

// main.ts
import { Contact } from './contact';

const contact = new Contact(['my', 'args']);
const {firstName, lastName} = contact;
contact.somethingAwesome();

@cosmoKenney : @ डेविड-ड्रिस्कॉल एक दिलचस्प समाधान प्रदान करता है, लेकिन इसमें अभी भी वास्तविक आंशिक कक्षाओं की आसानी का अभाव है। जैसा कि मेरे व्यक्तिगत प्रयोगों ने दिखाया है - देव केवल "आंशिक" का उपयोग नहीं करते हैं जो इस तरह से बने होते हैं। हालांकि यह एक अच्छा समाधान है, लेकिन पार्टिकल्स में आसानी और आराम नहीं है।

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

@greendimka , @david-driscoll
मैंने ऊपर से डेविड के उदाहरण को संकलित करने की कोशिश की, और ts को यह पसंद नहीं आया:

C:\TestProjects\TypeScriptFakePartialClassTest>tsc -m amd address.partial.ts address.ts contact.partial.ts contact.ts main.ts
address.ts(4,14): error TS2300: Duplicate identifier 'Address'.
address.ts(10,18): error TS2300: Duplicate identifier 'Address'.
contact.ts(7,14): error TS2300: Duplicate identifier 'Contact'.
contact.ts(11,14): error TS2339: Property 'firstName' does not exist on type 'Contact'.
contact.ts(12,14): error TS2339: Property 'lastName' does not exist on type 'Contact'.
contact.ts(20,18): error TS2300: Duplicate identifier 'Contact'.
main.ts(5,8): error TS2459: Type 'Contact' has no property 'firstName' and no string index signature.
main.ts(5,19): error TS2459: Type 'Contact' has no property 'lastName' and no string index signature.

इसके अलावा मैं @greendimka से सहमत

@greendimka मुझे नहीं पता कि कंपाइलर भी कैसे काम करता है, लेकिन कार्य को कम मत समझो। जावास्क्रिप्ट .NET नहीं है और मॉड्यूल विश्व स्तर पर उपलब्ध नहीं हैं (आपको उन्हें सचमुच आयात करना चाहिए)

मैं इसे लागू होते हुए देखना पसंद करूंगा, लेकिन यह कार्य कई चीजें लाता है, जिन पर ध्यान से विचार करने की आवश्यकता है, जैसे:

• यदि आप फ़ाइल ए पर कक्षा के भाग को फ़ाइल बी पर भाग परिभाषित करते हैं, तो ट्रांपिलिंग के बाद पूर्ण कक्षा में कौन सा होना चाहिए? एक नया उत्पन्न किया जाना चाहिए?
• क्या आंशिक सामग्री वाली सभी फाइलें एक ही कक्षा को निर्यात करती हैं?
• अगर मुझे उन अतिरिक्त फाइलों पर मुख्य फाइल की आवश्यकता है तो चक्रीय निर्भरताओं से कैसे बचें?
• क्या होगा यदि मैं केवल कक्षा की तुलना में मॉड्यूल पर अधिक चीजें निर्यात करता हूं?
• नाम विरोध की जाँच कर रहा है?

और इसी तरह...

@greendimka नीचे मेरी प्रतिक्रियाएं देखें: (संपादित करें: इसे @WoLfulus पर लक्षित किया गया था, क्षमा करें @greendimka):

यदि आप फ़ाइल ए पर कक्षा के भाग को फ़ाइल बी पर भाग परिभाषित करते हैं, तो ट्रांपिलिंग के बाद पूर्ण कक्षा में कौन सा होना चाहिए? एक नया उत्पन्न किया जाना चाहिए?

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

क्या आंशिक सामग्री वाली सभी फाइलें एक ही कक्षा को निर्यात करती हैं?

यह पहले प्रश्न के लिए मेरी प्रतिक्रिया से काफी हद तक उत्तर दिया गया है।

अगर मुझे उन अतिरिक्त फाइलों पर मुख्य फाइल की आवश्यकता है तो चक्रीय निर्भरताओं से कैसे बचें?

मुझे नहीं पता। क्या इस परिदृश्य को पहचानना मॉड्यूल लोडर का काम नहीं है?

क्या होगा यदि मैं केवल कक्षा की तुलना में मॉड्यूल पर अधिक चीजें निर्यात करता हूं?

मुझे इसमें समस्या नहीं दिखती। दूसरे शब्दों में यदि B.ts में आंशिक परिभाषा और कुछ अन्य गैर-आंशिक वर्ग दोनों हैं, तो B.js में ऊपर बताए अनुसार डिब्बाबंद टिप्पणी और गैर-आंशिक वर्गों की परिभाषाएँ होनी चाहिए। सरल, मुझे लगता है।

नाम विरोध की जाँच कर रहा है?

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

@WoLfulus , @cosmoKenney ने अच्छा जवाब दिया है। अपने पहले प्रश्न (ए और बी फाइलों के बारे में) के साथ इसे बेहतर बनाने के लिए: एक भाषा डिजाइनर के रूप में, नियमों को परिभाषित करने का विशेषाधिकार है। इससे मेरा मतलब है कि फ़ाइल A में ऐसा कोड "आंशिक वर्ग X" हो सकता है और फ़ाइल B में ऐसा कोड "आंशिक (fileX) वर्ग X" हो सकता है, जो fileX.js का उत्पादन करेगा।

@cosmoKenney

अगर मुझे उन अतिरिक्त फाइलों पर मुख्य फाइल की आवश्यकता है तो चक्रीय निर्भरताओं से कैसे बचें?
मुझे नहीं पता। क्या इस परिदृश्य को पहचानना मॉड्यूल लोडर का काम नहीं है?

टाइपस्क्रिप्ट में मॉड्यूल लोडर नहीं है।

@greendimka

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

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

@WoLfulus , @cosmoKenney ने अच्छा जवाब दिया है। अपने पहले प्रश्न (ए और बी फाइलों के बारे में) के साथ इसे बेहतर बनाने के लिए: एक भाषा डिजाइनर के रूप में, नियमों को परिभाषित करने का विशेषाधिकार है। इससे मेरा मतलब है कि फ़ाइल A में ऐसा कोड "आंशिक वर्ग X" हो सकता है और फ़ाइल B में ऐसा कोड "आंशिक (fileX) वर्ग X" हो सकता है, जो fileX.js का उत्पादन करेगा।

मुझे नहीं लगता कि आप अपना संदेश पहुंचा रहे हैं। इससे ऐसा लगता है जैसे आपको लगता है कि किसी भी भाषा में खुद को अभिव्यक्त करने वाली कोई भी सीमा पूरी तरह से मनमानी कारणों से मौजूद है।
इसके अलावा @WoLfulus के सवालों का जवाब नहीं दिया गया, कम से कम मेरी संतुष्टि के लिए नहीं।

डॉन्स फ्लेमसूट

TL; DR: ऐसा नहीं हो रहा है। यदि आप टिप्पणी संख्या 189 पर नीचे हैं और इसके साथ अपनी अस्वीकृति दर्ज करना चाहते हैं, तो कृपया पहले पूरा धागा पढ़ें, क्योंकि इसे न जोड़ने के बहुत अच्छे कारणों को ऊपर व्यापक रूप से कवर किया गया है।

इस स्थिति की हमारी व्याख्या इस प्रकार है:

• टाइपस्क्रिप्ट में पहले से implements , आदि) जो वास्तव में केवल "ES6 + प्रकार" होने का इरादा था। . कि का हिस्सा है हमारी गलती (हमारे मूल डिजाइन दिशा आम तौर पर भी था OOP) और उस का हिस्सा ES6 की गलती (वर्ग प्रस्ताव पांच साल पहले एक बहुत चारों ओर ले जाया और हम है कि यह नहीं किया सुविधाओं होने समाप्त हुआ) है। एक और टीएस-विशिष्ट वर्ग विशेषता जोड़ना ऊंट की पीठ पर एक और तिनका है जिससे हमें बचना चाहिए यदि हम कर सकते हैं।
• स्पष्ट रूप से, जावास्क्रिप्ट का भविष्य मॉड्यूल है। आंशिक कक्षाएं केवल "वैश्विक सूप" मॉडल में समझ में आती हैं और अच्छी तरह से संचालित होती हैं। कई मॉड्यूल में आंशिक कक्षाओं की अनुमति देना आपदा के लिए एक नुस्खा है क्योंकि लोडिंग ऑर्डर अनुमानित नहीं है। ऐसी सुविधा जोड़ना जो केवल वैश्विक-केवल ब्रह्मांड में अच्छी तरह से काम करती है, समय का अच्छा उपयोग नहीं है।
• सी # में है लेकिन हम यहां सी # को फिर से शुरू करने के लिए नहीं हैं। गंभीरता से!
• "जनरेटेड कोड" परिदृश्य गुणों पर सम्मोहक नहीं है। आंशिक कक्षाओं के लिए कोई भी प्रशंसनीय उत्सर्जन संपत्ति प्रारंभकर्ताओं और कन्स्ट्रक्टर कोड को बिल्कुल एक घोषणा तक सीमित कर देगा, और यह .Designer.cs -स्टाइल सेटअप के लिए एक डीलब्रेकर होगा क्योंकि उपयोगकर्ता कोड और जेनरेट कोड दोनों को प्रारंभकर्ता या कन्स्ट्रक्टर तर्क की आवश्यकता होगी .
• JS - मिक्सिन्स, Object.assign , आदि में कई, कई अन्य कंपोजिटल मैकेनिज्म उपलब्ध हैं। जिस परिदृश्य के कारण C# में यह फीचर आया, वह उन बाधाओं से प्रेरित था जो बस JS में मौजूद नहीं हैं।
• interface + prototype.method = ... का वर्तमान समाधान जेनरेट-कोड परिदृश्य को ठीक वैसे ही सक्षम करता है जैसे partial class करेगा। उस कोड को हाथ से लिखना अजीब है, लेकिन अलग-अलग कोड जनरेट करने में कोई समस्या नहीं है, इसलिए यदि आप वास्तव में सोचते हैं कि एक स्प्लिट-फाइल जनरेटेड कोड सेटअप आपकी समस्या को हल करने का एकमात्र तरीका है (मुझे संदेह है) तो वह तरीका आपके लिए उपलब्ध है .
• हम ES6 को कक्षाओं के लिए "होना चाहिए" का मध्यस्थ मानते हैं। टाइपस्क्रिप्ट (सी # प्रोग्रामर के लिए इसकी अपील के अलावा) के बारे में कुछ खास नहीं है जो इसे गैर-टाइप किए गए जावास्क्रिप्ट की तुलना में आंशिक कक्षाओं की आवश्यकता बनाता है। इसलिए यदि कुछ ऐसा परिदृश्य है जो आंशिक कक्षाओं को जोड़ने के लिए वास्तव में इसे पार्क से बाहर कर देता है, तो उस परिदृश्य को TC39 प्रक्रिया के माध्यम से खुद को सही ठहराने में सक्षम होना चाहिए। यदि वह कर्षण प्राप्त करता है तो हमें उस पर इनपुट के साथ वजन करने में खुशी होगी, लेकिन यह किसी के रडार पर भी नहीं लगता है।

@RyanCavanaugh इसके बारे में:

इंटरफ़ेस + प्रोटोटाइप.मेथोड = ... का वर्तमान वर्कअराउंड जेनरेट-कोड परिदृश्य के साथ-साथ आंशिक वर्ग को भी सक्षम बनाता है।

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

@cosmoKenney क्या आप वह साइट हैं

यह सुनकर खेद है, लेकिन मैं यहां किए गए डिजाइन निर्णयों का सम्मान करता हूं। मेरे पास कुछ प्रश्न हैं यदि यह ठीक है:

टाइपस्क्रिप्ट में पहले से ही बहुत अधिक TS-विशिष्ट वर्ग विशेषताएं हैं (कन्स्ट्रक्टर संपत्ति घोषणाएं, सदस्य प्रारंभकर्ता, गैर-अंतिम सज्जाकार, एक्सेस संशोधक, उपकरण, आदि) जो वास्तव में केवल "ES6 + प्रकार" होने का इरादा था। इसका एक हिस्सा हमारी गलती है (हमारी मूल डिजाइन दिशा आम तौर पर बहुत ओओपी थी) और इसका एक हिस्सा ईएस 6 की गलती है (कक्षा प्रस्ताव लगभग पांच साल पहले स्थानांतरित हो गया था और हमारे पास ऐसी विशेषताएं थीं जो इसे नहीं बनाती थीं)। एक और टीएस-विशिष्ट वर्ग विशेषता जोड़ना ऊंट की पीठ पर एक और तिनका है जिससे हमें बचना चाहिए यदि हम कर सकते हैं।

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

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

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

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

सच्ची में? निश्चित रूप से मॉड्यूल जावास्क्रिप्ट का एक स्वाभाविक हिस्सा होगा, लेकिन कोड के मुख्य मूल निकाय के बारे में क्या? मुझे नेमस्पेस पसंद है और अगर ठीक से किया जाए तो इसमें कोई सूप नहीं है। मैं इसे एक फ़ाइल में संकलित कर रहा हूं, और मुझे मॉड्यूल लोडर की कोई आवश्यकता नहीं है और लगभग सभी मामलों में एसिंक्रोनस मॉड्यूल लोडिंग की कोई आवश्यकता नहीं है। https://github.com/Microsoft/TypeScript/issues/420 जैसे प्रस्तावित कुछ सामान केवल नामस्थानों के साथ संभव और प्रासंगिक होंगे। क्या आप कह रहे हैं कि इस तरह की चीजें नहीं होने वाली हैं क्योंकि हमें केवल मॉड्यूल का उपयोग करना चाहिए? क्या नाम स्थान बहिष्करण की राह पर हैं?

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

आंशिक कक्षाएं क्या हैं, इसके बारे में मुझे बहुत सी गलतफहमियां भी दिखाई दे रही हैं। यह वास्तव में एक सरल निर्माण है, और हर कोई इसे अनुपात से बाहर उड़ा रहा है:
https://msdn.microsoft.com/en-us/library/wa80x488.aspx

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

यह एक भाषा का पुनर्लेखन होगा और प्रत्येक कोड को तोड़ देगा।

इसके अलावा "बस मुझे भयानक सामान दें" टाइपस्क्रिप्ट के लिए डिज़ाइन लक्ष्यों से बहुत मौलिक रूप से अलग है। यदि आप केवल कमाल की चीजें चाहते हैं और जावास्क्रिप्ट के संरेखण की परवाह नहीं करते हैं, तो आपको एक अलग भाषा चुननी चाहिए, जैसे CoffeeScript , Dart , या Haxe । निश्चित रूप से ऐसे कारण हो सकते हैं कि वे गोद लेने में टाइपस्क्रिप्ट के साथ-साथ ऐसा क्यों नहीं कर रहे हैं ...

जो इस मुद्दे को बंद करता रहता है और कहता है कि काम के आसपास हैं, शायद उसे एक उदाहरण काम करना चाहिए

partial हल करता है उसके लिए बहुत सारे उपयोग के मामले हैं। लगभग किसी भी भाषा के निर्माण में बहुत से उपयोग के मामले होते हैं जिनके लिए यह मान्य है, लेकिन अच्छे कारणों से, आपको चुनना और चुनना होगा।

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

मुझे समझ में नहीं आता कि आपको क्यों लगता है कि यह रयान का दायित्व है कि वह आपको बताए कि आपकी कार को कैसे फिर से रंगना है, सिर्फ इसलिए कि वैध कारणों से कार कंपनी ने हरी कारों का उत्पादन नहीं करने का फैसला किया है।

(ओह और टाइपस्क्रिप्ट 2.2 में जोड़े गए मिक्सिन क्लासेस आपकी वास्तविक जरूरत को पूरा करने का एक अच्छा तरीका है)

interface Base {}

interface Constructor<T> {
    new (...args: any[]): T;
    prototype: T;
}

interface PartialClass {
    foo(): void;
}

function PartialClass<B extends Constructor<Base>>(base: B): B & Constructor<PartialClass> {
    return class extends base {
        foo() {
            console.log('foo');
        }
    };
}

class MyBase {
    bar() {
        console.log('bar');
    }
}

const MyPartialBase = PartialClass(MyBase);

const instance = new MyPartialBase();

instance.bar();
instance.foo();

@kitsonk मिश्रण एक ही चीज़ नहीं हैं।

• मिक्सिन स्व-निहित इकाइयाँ हैं जिन्हें मौजूदा कक्षाओं में जोड़ा जा सकता है।
• आंशिक वर्ग किसी अन्य आंशिक से सदस्यों तक पहुँच सकते हैं, जैसे कि वे उसी वर्ग का हिस्सा हों।

एक अभ्यास के रूप में, मिक्सिन के साथ निम्नलिखित कोड स्प्लिट को लागू करने का प्रयास करें:

partial class Point {
  readonly x: number;
  readonly y: number;
}

partial class Point {
  translate(dx: number, dy: number): Point {
    return new Point(this.x + dx, this.y + dy);
  }
}

एक अभ्यास के रूप में, मिक्सिन के साथ निम्नलिखित कोड स्प्लिट को लागू करने का प्रयास करें

तो मुद्दे पर वापस आते हैं... तो किसी भाषा विशेषता को इंगित करने के बजाय, आप अपने उदाहरण से किस समस्या का समाधान करने का प्रयास कर रहे हैं? क्योंकि टाइपस्क्रिप्ट में समाधान आसान है:

class Point {
  readonly x: number;
  readonly y: number;
  translate(dx: number, dy: number): Point {
    return new Point(this.x + dx, this.y + dy);
  }
}

(और अगर हम पूर्णवादी हैं, लेकिन फिर से, यह एक उपयोग को हल

interface PointBase {
    x: number;
    y: number;
}

interface Constructor<T> {
    new (...args: any[]): T;
    prototype: T;
}

interface TranslatePointPartial {
    translate(dx: number, dy: number): TranslatePointPartial;
}

function TranslatePointPartial<B extends Constructor<PointBase>>(base: B): B & Constructor<TranslatePointPartial> {
    return class TranslatePointPartial extends base {
        translate(dx: number, dy: number): TranslatePointPartial & PointBase {
            return new TranslatePointPartial(this.x + dx, this.y + dy);
        }
    };
}

class Point {
    readonly x: number;
    readonly y: number;
}

const MyPoint = TranslatePointPartial(Point);

const instance = new MyPoint();

instance.x;
instance.y;
instance.translate(1, 2);

@ हाथी-पोत

इसे ध्यान में रखते हुए, क्या जेएस की शुद्ध टाइपिंग और टीएस द्वारा प्रदान की जाने वाली दूसरी भाषा के निर्माण के बीच स्पष्ट रूप से अंतर करना, संगठनात्मक और कोड-वार आगे बढ़ना संभव होगा?

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

क्या आप कह रहे हैं कि इस तरह की चीजें नहीं होने वाली हैं क्योंकि हमें केवल मॉड्यूल का उपयोग करना चाहिए? क्या नाम स्थान बहिष्करण की राह पर हैं?

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

@RyanCavanaugh

शायद ऐसा... शायद उनका उतना मतलब नहीं है... लेकिन जैसा कि मैंने कई बार कहा है, मुझे लगता है कि इस धागे में भी, आंशिक कक्षाएं कोड जनरेशन को आसान बनाने के बारे में हैं... यही मुख्य लाभ है जो मुझे दिखाई देता है उनमें से टीएस में सुविधा के लायक ... मैं, और मुझे कई अन्य लोगों को मानना ​​​​है, लेकिन यह सिर्फ एक अनुमान है, वर्तमान में मेरे सी # कोड से बहुत से टीएस कोड उत्पन्न कर रहा हूं ... लेकिन फिर सवाल यह है कि जेनरेट को सुरक्षित रूप से कैसे बढ़ाया जाए टीएस कोड??? आंशिक कक्षाओं के साथ इसका उत्तर देना कहीं अधिक आसान प्रश्न है... वर्तमान में हम अपनी जेनरेट की गई TS कोड फ़ाइलों में कस्टम कोड रखने के लिए हैक्स का सहारा ले रहे हैं...

धन्यवाद

यहां वही बात है, हम अपने सी # एपीआई के लिए टाइपस्क्रिप्ट "प्रॉक्सी" उत्पन्न करते हैं, और हम इन ऑब्जेक्ट्स को टाइपस्क्रिप्ट में आसानी से विस्तारित करने में सक्षम होना चाहते हैं।

मैं जेएस विशेषज्ञ नहीं हूं इसलिए मुझे कुछ याद आ रहा होगा, क्योंकि, मुझे नहीं लगता कि कई टीएस फाइलों में कक्षाओं की घोषणा को विभाजित करने में सक्षम होने के कारण (संकलन के बाद केवल एक जेएस फाइल में केवल एक वर्ग घोषणा के साथ) होगा जेएस दुनिया के लिए एक समस्या। जहाँ तक मैं इसे देखता हूँ, यह JS के लिए पारदर्शी है, जैसे कि यह शुरू से ही एक फ़ाइल में लिखा गया होता। मेरा मतलब है, यदि आप आंशिक कक्षाओं का उपयोग करते हैं या नहीं, तो जेएस आउटपुट बिल्कुल वही होगा, लेकिन यह हमारे डेवलपर्स के लिए जेएस ऑब्जेक्ट एक्स्टेंसिबिलिटी की लागत को रोक देगा।

@RyanCavanaugh

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

@kitsonk

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

नहीं, मैं अब कोई नई सुविधा नहीं माँग रहा हूँ। यह बार-बार कहा गया है कि भाषा वह कर सकती है जो मैं चाहता हूं। मैं जो चाहता हूं (सी # में) के उदाहरण प्रदान करता हूं, लेकिन मुझे अभी तक उपयोगी उदाहरणों में यह देखने का तरीका नहीं है कि मुझे कहां होना चाहिए।

मुझे समझ में नहीं आता कि आपको क्यों लगता है कि यह रयान का दायित्व है कि वह आपको बताए कि आपकी कार को कैसे फिर से रंगना है, सिर्फ इसलिए कि वैध कारणों से कार कंपनी ने हरी कारों का उत्पादन नहीं करने का फैसला किया है।

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

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

मैं

@RyanCavanaugh , मुझे पता है कि आपने मदद करने का प्रयास किया है। और इस बिंदु पर मैं मिक्सिन्स आज़माने के लिए आगे बढ़ रहा हूँ। या सिर्फ विरासत, या हो सकता है कि मैं इस परियोजना को पूरा करने के लिए इतनी जल्दी में हूं कि मैं जेनेरिक के साथ ऐसा करने का एक तरीका देख रहा हूं। हम्म...
विरासत और नामकरण के साथ, मैं यह कर सकता हूं:

class AddressBase // this is a code generated class
{
    public address: string;
    public city: string;
    public state: string;
    public zip: string;

    constructor( jsonFromService: any )
    {
        this.OnInit( jsonFromService );
    }

    OnInit( jsonFromService: any )
    {
        // could use Object.assign here
        this.address = jsonFromService.address;
        this.city = jsonFromService.city;
        this.state = jsonFromService.state;
        this.zip = jsonFromService.zip;
    }
}

class ContactBase // this is also a code generated class
{
    public firstName: string;
    public lastName: string;

    constructor( jsonFromService: any )
    {
        this.OnInit( jsonFromService );
    }

    OnInit( jsonFromService: any )
    {
        // could use Object.assign here
        this.firstName = jsonFromService.firstName;
        this.lastName = jsonFromService.lastName;
    }
}

// classes that extend the functionality of the code generated classes:
class Address extends AddressBase // subclass simply because I don't want to have to use AddressBase all over my codebase, and then refactor if I ever extend the class
{
}

class Contact extends ContactBase
{
    public Addresses: Address[] = []; // THIS is the customization/extension that cannot be code generated.

    OnInit( jsonFromService: any )
    {
        // note that jsonFromService receives a dto with a array of address info
        super.OnInit( jsonFromService );

        for ( let addr of jsonFromService.Addresses )
        {
            this.Addresses.push( new Address( addr ) );
        }
    }
}

और यह मेरे लिए ठीक काम करता है। यह उतना सुंदर नहीं है और मेरे कोड जेनरेट किए गए वर्गों को ऐसे नाम रखने के लिए मजबूर करता है जिन्हें मैं कोड में उपयोग नहीं करना चाहता हूं। लेकिन, यह फिर से काम करता है।

फिलहाल मुझे लगता है कि जो लोग आंशिक वर्गों के सख्त खिलाफ हैं, वे आंशिक वर्गों की अवधारणा को गलत समझते हैं, और वे सोचते हैं कि आंशिक कक्षाएं कुछ ऐसी हैं जो आंशिक वर्ग नहीं हैं।

इसे स्पष्ट करने के लिए: आंशिक वर्ग एक वाक्यात्मक निर्माण है, जो आपको एक ही एकल वर्ग की परिभाषा को कई भौतिक फ़ाइलों में विभाजित करने देता है। यहां कीवर्ड "समान" और "एकल" हैं।

टाइपस्क्रिप्ट का प्रलेखन आंशिक कक्षाओं की खराब परिभाषा देता है (पहला पैराग्राफ यहां: https://www.typescriptlang.org/docs/handbook/mixins.html )।

वास्तविक आंशिक वर्ग अवधारणा का उदाहरण:

फ़ाइल "Point.generated.ts":

partial class Point {
   readonly x: number;
   readonly y: number;
}

फ़ाइल "Point.codeByHand.ts":

partial class Point {
  constructor(x: number, y: number) {
      this.x = x;
      this.y = y;
  }

  translate(dx: number, dy: number): Point 
  {
      return new Point(this.x + dx, this.y + dy);
  }
}

वे "प्वाइंट.जेएस" में संकलित होते हैं - और नाम एक वर्ग के नाम से आता है, फाइलों के नाम से नहीं:

var Point = (function () {
    function Point(x, y) {
        this.x = x;
        this.y = y;
    }
    Point.prototype.translate = function (dx, dy) {
        return new Point(this.x + dx, this.y + dy);
    };
    return Point;
}());

मिक्सिन, जब "आंशिक वर्गों" के रूप में उपयोग किया जाता है (और मुझे दृढ़ता से विश्वास है कि दस्तावेज़ीकरण में इस शब्द का दुरुपयोग किया गया है ) वास्तव में एक बहु विरासत का प्रतिनिधित्व करता है ( https://en.wikipedia.org/wiki/Multiple_inheritance )।

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

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

TS टीम यदि संभव हो तो TS-विशिष्ट सुविधाओं को लागू नहीं करना चाहती। यदि आप और अधिक चर्चा करना चाहते हैं तो यहां एक बेहतर जगह है: https://esdiscuss.org/topic/class-syntax-enhancements

मुझे आशा है कि TC39 की तरफ एक GitHub रेपो है जो इस बात पर चर्चा करने के लिए

@greendimka

फिलहाल मुझे लगता है कि जो लोग आंशिक वर्गों के सख्त खिलाफ हैं, वे आंशिक वर्गों की अवधारणा को गलत समझते हैं, और वे सोचते हैं कि आंशिक कक्षाएं कुछ ऐसी हैं जो आंशिक वर्ग नहीं हैं।

इसे स्पष्ट करने के लिए: आंशिक वर्ग एक वाक्यात्मक निर्माण है, जो आपको एक ही एकल वर्ग की परिभाषा को कई भौतिक फ़ाइलों में विभाजित करने देता है। यहां कीवर्ड "समान" और "एकल" हैं।

मुझे नहीं लगता कि यहां कोई भी आंशिक कक्षाओं की परिभाषा को गलत समझ रहा है, मुझे लगता है कि आप शायद जावास्क्रिप्ट में कक्षाओं की परिभाषा को गलत समझ रहे हैं।

यदि आप इस धारणा के तहत हैं कि जावास्क्रिप्ट कक्षाएं लगभग किसी भी अन्य व्यापक रूप से उपयोग की जाने वाली भाषा में पाई जाने वाली कक्षाओं की तरह हैं, तो यह आपको _प्रकट_ हो सकता है कि अन्य लोग गलत समझ रहे हैं।

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

वे तब तक मौजूद नहीं हैं जब तक कि बयानों को निष्पादित नहीं किया जाता है।

उन्हें परिभाषित करना उत्परिवर्तन पर निर्भर करता है।

जब यह विरासत की बात आती है तो यह पहले से ही उन्हें भंगुर और आदेश पर निर्भर बनाता है।

यह सिलसिला आगे भी जारी रह सकता है...

@cosmoKenney

मुझे समझ में नहीं आता कि कैसे कुछ जटिल और समझने में कठिन भाषा में मिल गया, और फिर भी हर कोई आंशिक वर्ग वाक्यविन्यास के लालित्य को अस्वीकार कर रहा है, ऐसा लगता है, क्योंकि यह सी # से उधार लिया गया है।

मुझे सच में नहीं लगता कि यह सही है। हर कोई सी #, यहां तक ​​​​कि जावा प्रोग्रामर 😛 से प्यार करता है, और टाइपस्क्रिप्ट अलग होने के लिए अलग नहीं है।

@aluanhaddad

मुझे लगता है कि आप शायद जावास्क्रिप्ट में कक्षाओं की परिभाषा को गलत समझ रहे हैं ...

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

@greendimka

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

इस संतृप्ति के साथ समस्या टाइपस्क्रिप्ट वर्ग जैसी कोई चीज नहीं है।

ओह यार! कुछ लोग किसी भी चीज़ को एक कारण के रूप में उपयोग करेंगे।
ठीक है, टाइपस्क्रिप्ट में कोई कक्षा नहीं है। या टाइपस्क्रिप्ट कक्षाएं। जो कुछ भी। जो भी हो।

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

मुझे लगता है कि जब हम कक्षाओं की बात करते हैं तो हमारा मतलब वही नहीं होता है और यह संज्ञानात्मक असंगति का कारण बनता है और आपसी समझ को बाधित करता है।

मुझे लगता है कि जब हम कक्षाओं की बात करते हैं तो हमारा मतलब वही नहीं होता है और इससे संज्ञानात्मक असंगति होती है और आपसी समझ में बाधा आती है।
पूर्णतया सहमत!

वास्तव में इस विषय में पहली पोस्ट पूरी तरह से वर्णन करती है कि क्या अनुरोध किया गया था, इसलिए इस चर्चा का कोई भविष्य नहीं है :)

@greendimka हाँ, इसका कोई भविष्य नहीं है क्योंकि ऐसा लगता है कि टाइपस्क्रिप्ट में कभी भी आंशिक कक्षाएं नहीं होंगी। मेरे विचार से यह अच्छी बात है।

हालाँकि, गलतफहमी और गलत संचार अच्छी चीजें नहीं हैं, इसलिए मैं अभी भी आपसे बातचीत कर रहा हूं।

दुर्भाग्य से, ऐसा लगता है कि आप इनमें से किसी में भी रुचि नहीं ले रहे हैं

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

B. जावास्क्रिप्ट क्लासेस क्या हैं, इसके बारे में दूसरों से सीखना ताकि आपको विरोधी दृष्टिकोण को समझना चाहिए।

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

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

@aluanhaddad
यार अरे यार। समीकरण के जावास्क्रिप्ट भाग की परवाह कौन करता है? टाइपस्क्रिप्ट ऊपर की एक परत है, या हालाँकि आप इसे वाक्यांश देना चाहते हैं। पुरानी 4GL बनाम 3GL चर्चाएं याद हैं? टाइपस्क्रिप्ट जावास्क्रिप्ट के लिए है क्योंकि 4GL एक 3GL के लिए है, एक तरह का। यह भी तर्क है कि टाइपस्क्रिप्ट मजबूत प्रकारों के साथ ES6 है, इस प्रकार आंशिक वर्ग टाइपस्क्रिप्ट के रोडमैप के दायरे से बाहर है, LAME है। हमें मिक्सिन्स, जेनरिक, मॉड्यूल्स, नेम स्पेसेस और टाइप कास्टिंग मिले। तो क्यों न आंशिक कक्षाओं के साथ अतिरिक्त प्रयास करें?

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

@cosmoKenney "इसका सिर्फ ES.next प्रकार के साथ" एक बड़ा विक्रय बिंदु है जो जावास्क्रिप्ट डेवलपर्स को परिवर्तित करता है। अगर आप कुछ और चाहते हैं, तो आप गलत भाषा देख रहे हैं। शायद इसके बजाय Scala.js आज़माएं?

संपादित करें: मुझे बस एक दिलचस्प अहसास था कि ES.next में आंशिक कक्षाओं को एक कस्टम मॉड्यूल लोडर के साथ लागू किया जा सकता है। यदि तुम प्रयोग करते हो

import {MyClass} from './myclass.*'

लोडर वाइल्डकार्ड से मेल खाने वाली किसी भी फाइल से सभी निर्यातित MyClass परिभाषाओं को एक वर्ग में मर्ज कर सकता है, फिर उसे प्रदान करें।

@spion मुझे पसंद है कि आप उन्हें ES.next आंशिक कक्षाओं के रूप में कैसे सही ढंग से संदर्भित कर रहे हैं। एक ES मॉड्यूल लोडर, जैसे ब्राउज़र, या लोडर पॉलीफ़िल, जैसे कि SystemJS, तब आंशिक कक्षाओं का समर्थन करेगा।
टाइपस्क्रिप्ट स्तर पर इस सुविधा को जोड़ने के साथ प्राथमिक समस्याओं में से एक यह है कि यह मौजूदा टूल जैसे लोडर और पैकेजर्स को तोड़ देता है। दूसरी ओर, यदि ईसीएमएस्क्रिप्ट ने उन्हें निर्दिष्ट किया है, तो ये सभी उपकरण सुविधा को लागू करेंगे और टाइपस्क्रिप्ट इन सभी उपकरणों के साथ संगत रहेगा।

मैं निश्चित रूप से Scala.js . के संबंध में आपसे सहमत हूं

@cosmoKenney

हमें मिक्सिन्स, जेनरिक, मॉड्यूल्स, नेम स्पेसेस और टाइप कास्टिंग मिले। तो क्यों न आंशिक कक्षाओं के साथ अतिरिक्त प्रयास करें?

टाइपस्क्रिप्ट में देखा गया मिक्सिन एक ईसीएमएस्क्रिप्ट डिज़ाइन पैटर्न है जो टाइपस्क्रिप्ट _types_.

जेनरिक एक प्रकार की सिस्टम विशेषता है इसलिए वे लागू नहीं होते हैं।

मॉड्यूल एक ईसीएमएस्क्रिप्ट सुविधा है।

नेमस्पेस ईसीएमएस्क्रिप्ट डिजाइन पैटर्न के लिए एक वाक्य रचनात्मक चीनी और औपचारिकता है।

टाइप कास्टिंग टाइपस्क्रिप्ट में मौजूद नहीं है।

@aluanhaddad आप इसे रन-टाइम चीज़ के रूप में क्यों बनाते रहते हैं? मॉड्यूल लोडर और वे सभी जिनका ट्रांसपिलिंग से कोई लेना-देना नहीं है।

+1

@cosmoKenney

@aluanhaddad आप इसे रन-टाइम चीज़ के रूप में क्यों बनाते रहते हैं? मॉड्यूल लोडर और वे सभी जिनका ट्रांसपिलिंग से कोई लेना-देना नहीं है।

वह सही नहीं है।

SystemJS और Webpack पारिस्थितिक तंत्र को देखें और आप अन्यथा देखेंगे।

इससे भी अधिक पारंपरिक, और रॉक सॉलिड गल्प वर्कफ़्लो इनपुट और आउटपुट फ़ाइलों के बीच पत्राचार पर निर्भर करते हैं।

+1

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