Typescript: सुझाव: गैर-शून्य प्रकार

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

function(myNonNull:!myClass):void {
  myNonNull.foo();
}

और क्योंकि इसे गैर-शून्य के रूप में परिभाषित किया गया है, संकलक के लिए सबकुछ खुश हो सकता है, लेकिन फिर कोई और जो जावास्क्रिप्ट में इसका उपयोग करता है, कुछ शून्य और कबूम पास करता है।

अब उसने कहा, शायद समाधान यह हो सकता है कि सार्वजनिक सामना करने वाले तरीकों के लिए, यह स्वचालित रूप से शून्य नहीं होने का दावा कर सकता है। लेकिन फिर संकलक यह भी दावा कर सकता है कि आपके पास सार्वजनिक संपत्तियां नहीं हो सकती हैं (या वास्तव में उस मामले के लिए निजी) जिसमें ! गैर-घोषणा हो सकती है क्योंकि उन्हें लागू नहीं किया जा सकता है।

इसे ठीक से लागू करने के लिए कोड अनुबंधों की चर्चा में यह गहराई तक जा सकता है।

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

व्यक्तिगत रूप से, मैंने अभी थोड़ा सा Maybe<T> इंटरफ़ेस लिखा है और यह सुनिश्चित करने के लिए अनुशासन का उपयोग करें कि उस प्रकार के चर कभी भी शून्य नहीं हैं।

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

समारोह (myNonNull:!myClass): शून्य {
myNonNull.foo();
}
और क्योंकि इसे गैर-शून्य के रूप में परिभाषित किया गया है, संकलक के लिए सबकुछ खुश हो सकता है, लेकिन फिर कोई और जो जावास्क्रिप्ट में इसका उपयोग करता है, कुछ शून्य और कबूम पास करता है।

मैं वास्तव में नहीं समझता कि आप यह भी परिभाषित कर सकते हैं:

function myFunc(str: string): int {
 return str && str.length;
}

और अगर कोई उस फ़ंक्शन के लिए int पास करता है तो यह एक त्रुटि के साथ भी समाप्त हो जाएगा, टाइपस्क्रिप्ट का एक लाभ संकलक पास चीजों को सौंपना है जिसे आप जावास्क्रिप्ट में मैन्युअल रूप से जांचेंगे, शून्य/गैर के लिए एक और चेक होने पर -शून्य प्रकार मेरे लिए उचित लगता है। वैसे SaferTypeScript और ClosureCompiler पहले से ही उस तरह की जाँच करते हैं।

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

var myNullableString: (null | string);
var myString = "hello";
myNullableString = myString //valid
myString = myNullableString // error null is not assignable to string;

'सख्त मोड' के साथ सक्रिय टाइपस्क्रिप्ट को यह जांचना चाहिए कि प्रत्येक चर गैर अशक्त है, डिफ़ॉल्ट रूप से भी वैकल्पिक पैरामीटर अशक्त हैं।

var myString: string; // error
var myNullableString: (null | string); // no error

function myString(param1: string, param2?: string) {
  // param1 is string
  // param2 is (null | string)
}

@fdecampredon +1

आईआईआरसी से फेसबुक ने फ्लो दिखाया जो टाइपस्क्रिप्ट सिंटैक्स का उपयोग कर रहा है लेकिन डिफ़ॉल्ट रूप से गैर-शून्य प्रकारों के साथ वे आपके मूल पोस्ट में (null | T) लिए शॉर्टहैंड का समर्थन करते हैं - मुझे लगता है कि यह ?T या T? ।

var myString: string; // error

उस मामले में संभावित रूप से काफी परेशान हो सकता है जहां आप एक चर को सशर्त रूप से प्रारंभ करना चाहते हैं, उदाहरण के लिए:

var myString: string;
if (x) {
myString = a;
} else if (y) {
myString = b;
} else {
myString = c;
}

उदाहरण के लिए रस्ट में, यह तब तक ठीक है जब तक कि कंपाइलर देख सकता है कि myString का उपयोग करने से पहले इसे इनिशियलाइज़ किया जाएगा, लेकिन टाइपस्क्रिप्ट का अनुमान इस समय इसका समर्थन नहीं करता है।

ईमानदारी की तरह कुछ कर रही var myString = '' के बजाय var myString: string मुझे इतना परेशान नहीं करता है, लेकिन लगता है कि शासन की तरह हमेशा संभव है।

इसके लिए

(null | string) लिए आशुलिपि के लिए सुनिश्चित करें कि ?string ठीक है।
और निश्चित रूप से @johnnyreilly यह केवल एक संकलन समय जांच है

योग प्रकार डिफ़ॉल्ट रूप से गैर-शून्य प्रकार को एक बहुत ही रोचक संभावना बनाते हैं। डिफ़ॉल्ट रूप से गैर-शून्य के सुरक्षा गुणों को अतिरंजित नहीं किया जा सकता है। योग प्रकार प्लस नियोजित "अगर/टाइपऑफ डिस्ट्रक्टिंग" (सुनिश्चित नहीं है कि इसे क्या कहा जाना चाहिए) यहां तक ​​​​कि इसे अशक्त और गैर-अशक्त एपीआई को एकीकृत करने के लिए सुरक्षित भी बनाते हैं।

हालाँकि, डिफ़ॉल्ट रूप से प्रकारों को अशक्त बनाना एक बहुत बड़ा परिवर्तन है, जिसके लिए लगभग हर मौजूदा तृतीय-पक्ष प्रकार परिभाषा फ़ाइल को बदलने की आवश्यकता होगी। जबकि मैं ब्रेकिंग चेंज के लिए 100% हूं, कोई भी व्यक्ति जंगली में मौजूद प्रकार की परिभाषाओं को अपडेट करने में सक्षम नहीं है।

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

@samwgoldman का विचार है कि केवल एक विशेष कंपाइलर ध्वज के तहत गैर-शून्य प्रकार होना चाहिए जैसे nonImplicitAny इस ध्वज को strict या nonNullableType नाम दिया जा सकता है। तो कोई ब्रेकिंग परिवर्तन नहीं होगा।

@fdecampredon गैर-टाइपस्क्रिप्ट पुस्तकालयों के लिए प्रकार परिभाषाओं के बारे में क्या, निश्चित रूप से टाइप किए गए लोगों की तरह? उन परिभाषाओं को कंपाइलर द्वारा चेक नहीं किया जाता है, इसलिए कोई भी तृतीय पक्ष कोड जो शून्य वापस कर सकता है उसे सही ढंग से काम करने के लिए फिर से एनोटेट करने की आवश्यकता होगी।

मैं एक फ़ंक्शन के लिए एक प्रकार की परिभाषा की कल्पना कर सकता हूं जिसे वर्तमान में "रिटर्न स्ट्रिंग" के रूप में एनोटेट किया गया है, लेकिन कभी-कभी शून्य हो जाता है। अगर मैं अपने nonNullableType 'एड कोड में उस फ़ंक्शन पर निर्भर हूं, तो कंपाइलर शिकायत नहीं करता है (यह कैसे हो सकता है?) और मेरा कोड अब शून्य-सुरक्षित नहीं है।

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

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

ठीक है, मान लेते हैं कि ? type लिए एक शॉर्टहैंड type | null | undefined ।

@fdecampredon गैर-टाइपस्क्रिप्ट पुस्तकालयों के लिए प्रकार परिभाषाओं के बारे में क्या, निश्चित रूप से टाइप किए गए लोगों की तरह? उन परिभाषाओं को कंपाइलर द्वारा चेक नहीं किया जाता है, इसलिए कोई भी तृतीय पक्ष कोड जो शून्य वापस कर सकता है उसे सही ढंग से काम करने के लिए फिर से एनोटेट करने की आवश्यकता होगी।

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

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

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

मैं नहीं देखता कि हमारे पास फ़्लैग स्विच की गई सुविधा क्यों नहीं हो सकती है, नियम सरल होंगे:

• सामान्य मोड में ? string string बराबर है और null या undefined सभी प्रकार के लिए असाइन करने योग्य हैं
• nonNullableType मोड में ? string string | null | undefined बराबर है और null या undefined null या undefined अलावा किसी अन्य प्रकार के लिए असाइन करने योग्य नहीं हैं

फ़्लैग-स्विच्ड फ़ीचर के साथ असंगति कहाँ है?

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

function fn(x: string): number;
function fn(x: number|null): string;

function foo() {
    return fn(null);
}

var x = foo(); // x: number or x: string?

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

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

मुझे पता है कि यह रेट्रो-संगतता को तोड़ देगा, एक मैं @RyanCavanaugh के दृष्टिकोण को समझता फ्लोटाइप के साथ यह ईमानदारी से वास्तव में एक अमूल्य विशेषता है, मुझे आशा है कि यह टाइपस्क्रिप्ट का एक हिस्सा बन जाएगा

रयान कैवानुघ की टिप्पणी के अलावा -> जो मैंने कहीं पढ़ा है, ES7 विनिर्देश/प्रस्ताव में फ़ंक्शन ओवरलोडिंग (समान फ़ंक्शन नाम लेकिन विभिन्न इनपुट पैरामीटर डेटाटाइप) के उपयोग का उल्लेख है। जावास्क्रिप्ट के लिए यह एक अत्यंत आवश्यक विशेषता है।

प्रवाह डॉक्स से :

प्रवाह शून्य को एक विशिष्ट मान मानता है जो किसी अन्य प्रकार का हिस्सा नहीं है

var o = null;
print(o.x); // Error: Property cannot be accessed on possibly null value

किसी भी प्रकार टी को लिखने के द्वारा शून्य (और संबंधित मूल्य अपरिभाषित) को शामिल करने के लिए बनाया जा सकता है? टी

var o: ?string = null;
print(o.length); // Error: Property cannot be accessed on possibly null or undefined value

[प्रवाह] कुछ गतिशील प्रकार के परीक्षणों के प्रभावों को समझता है

(यानी टीएस लिंगो टाइप गार्ड को समझता है)

var o: ?string = null;
if (o == null) {
  o = 'hello';
}
print(o.length); // Okay, because of the null check

सीमाओं

• अलियासिंग की संभावना के कारण वस्तु गुणों पर जाँच सीमित है:

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

• ऑब्जेक्ट गुणों के लिए टाइप गार्ड-स्टाइल चेक बेमानी हो सकते हैं।

[डी] किसी विधि में एक अशक्त क्षेत्र को गैर-शून्य के रूप में पहचाने जाने की अपेक्षा न करें क्योंकि आपके कोड में किसी अन्य विधि में एक शून्य जांच की जाती है, भले ही यह आपके लिए स्पष्ट हो कि शून्य जांच सुरक्षा के लिए पर्याप्त है रन टाइम (कहते हैं, क्योंकि आप जानते हैं कि पूर्व विधि को कॉल हमेशा बाद की विधि के लिए कॉल का पालन करते हैं)।

• undefined चेक नहीं किया गया है।

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

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

@jbondc अच्छा लगता है। हालाँकि इसके साथ समस्या यह है कि यह हर जगह ! साथ समाप्त होगा: p

It's tempting to want to change JavaScript but the reality is a 'string' is nullable or can be undefined.

इसका क्या मतलब है? जेएस में कोई स्थिर प्रकार नहीं हैं। तो, हाँ, तार "शून्य" हैं, लेकिन यह नहीं भूलना चाहिए कि वे संख्या योग्य और आपत्तिजनक और फूबल आदि भी हैं। किसी भी मूल्य का कोई भी प्रकार हो सकता है।

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

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

@metaweta मुझे नहीं लगता कि यह पर्याप्त है, उदाहरण के लिए क्या होता है यदि कोई _non null मॉड्यूल_ एक शून्य का उपभोग करता है:

//module A
export function getData(): string[] {
  return null;
}
//module B
'use nonnull'
import A = require('./A');

var data: string[] = A.getData();

मॉड्यूल बी में data वास्तव में शून्य है, लेकिन चूंकि मॉड्यूल ए में 'use nonnull' का उपयोग नहीं किया गया था, क्या हमें एक त्रुटि की रिपोर्ट करनी चाहिए?
मुझे निर्देश आधारित सुविधा के साथ उस समस्या को हल करने का कोई तरीका नहीं दिख रहा है।

हां,

var data: string[] = A.getData();

त्रुटि का कारण होगा। इसके बजाय, आपको getData() रिटर्न null लिए एक डिफ़ॉल्ट मान प्रदान करना होगा:

var data: string[] = A.getData() || [];

@metaweta ठीक है लेकिन आप कैसे जानते हैं कि यह एक त्रुटि है? :)
getData का प्रकार अभी भी है '() => string[]' क्या आप स्वचालित रूप से 'nullable मॉड्यूल' से आने वाली हर चीज़ को 'nullable' मानेंगे?

हां, बिल्कुल (जब तक कि अशक्त मॉड्यूल से एक प्रकार को स्पष्ट रूप से अन्यथा चिह्नित नहीं किया जाता है)।

ऐसा लगता है कि अब आप प्रति फ़ाइल ध्वज चाहते हैं जो यह निर्धारित करता है कि फ़ाइल डिफ़ॉल्ट रूप से शून्य है या नहीं।

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

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

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

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

मुझे खेद है कि अगर मैं स्पष्ट नहीं था, तो मैं रयान से सहमत था और अपनी चिंताओं को जोड़ रहा था।

ईमानदारी से अगर use not-null जोड़ना सभी शून्य सूचक अपवाद से बचने की कीमत है, तो मैं इसे बिना किसी समस्या के भुगतान करूंगा, null या undefined को किसी भी प्रकार के लिए असाइन करने योग्य मानते हुए बदतर त्रुटि है वह टाइपस्क्रिप्ट मेरी राय में बनाई गई है।

@jbondc मैंने 'सख्त उपयोग' का उपयोग नहीं किया है और इसलिए कुछ धारणाएं बना रहा हूं, अगर मेरी धारणाएं गलत हैं तो कृपया मुझे सही करें:

नॉट नल प्रोग्रामर द्वारा लिखे गए सिंटैक्स को प्रभावित नहीं करता है, लेकिन अगले प्रोग्रामर की क्षमताएं जो उस कोड का उपयोग करने की कोशिश करती हैं (यह मानते हुए कि निर्माता और उपयोगकर्ता अलग-अलग लोग हैं)।

तो कोड:

function myfoo (mynumber: number) {
    return !!mynumber;
} 

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

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

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

सही @jbondc। @ ग्रिफोर्क : क्षमा करें, मैंने उस गलतफहमी को नहीं पकड़ा; एक निर्देश एक शाब्दिक स्ट्रिंग अभिव्यक्ति है जो प्रोग्राम उत्पादन या फ़ंक्शन उत्पादन की पहली पंक्ति के रूप में प्रकट होता है और इसके प्रभाव उस उत्पादन तक सीमित होते हैं।

"use not-null";
// All types in this program production (essentially a single file) are not null

बनाम

function f(n: number) {
  "use not-null";
  // n is not null and local variables are not null
  function g(s: string) {
    // s is not null because g is defined in the scope of f
    return s.length;
  }
  return n.toFixed(2);
}

function h(n: number) {
  // n may be null
  if (n) { return n.toFixed(3); }
  else { return null; }
}

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

@ एलेक्सी-बायकोव ऐसा लगता है कि आप इस बात से अनजान हैं कि जावास्क्रिप्ट के दो शून्य मान हैं, undefined और null । जावास्क्रिप्ट में null मान केवल एक गैर-मिलान वाले regexp पर और JSON में किसी दिनांक को क्रमबद्ध करते समय लौटाया जाता है। जावा एप्लेट्स के साथ बातचीत के लिए भाषा में इसका एकमात्र कारण था। वेरिएबल जिन्हें घोषित किया गया है लेकिन प्रारंभ नहीं किया गया है undefined , न कि null । किसी ऑब्जेक्ट पर गुम गुण undefined लौटाते हैं, न कि null । यदि आप स्पष्ट रूप से चाहते हैं कि undefined एक मान्य मान हो, तो आप propName in obj परीक्षण कर सकते हैं। यदि आप यह जांचना चाहते हैं कि कोई संपत्ति विरासत में प्राप्त होने के बजाय वस्तु पर मौजूद है या नहीं, तो obj.hasOwnProperty(propName) । गुम सबस्ट्रिंग -1: 'abc'.indexOf('d') === -1 लौटाते हैं।

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

यदि हम "उपयोग नहीं-शून्य" निर्देश को अपनाते हैं, तो मैं "उपयोग नहीं-शून्य" (न तो अशक्त और न ही अपरिभाषित) चाहूंगा।

यदि आप अपने कोड को नल से गारंटी देना चाहते हैं तो बस शून्य को प्रतिबंधित करें
शाब्दिक। गैर-शून्य प्रकारों को विकसित करने से यह बहुत आसान है। अपरिभाषित है a
थोड़ा और अधिक जटिल, लेकिन यदि आप जानते हैं कि वे क्या कर रहे हैं तो
आप उनसे बचना जानते हैं। हास्केल में नीचे अमूल्य है! मैं चाहता हूं
जावास्क्रिप्ट (टाइपस्क्रिप्ट) में बिना किसी मूल्य के वैश्विक सुपर प्रकार था। मैनें खो दिया
बुरी तरह से जब मुझे अभिव्यक्ति में फेंकने की ज़रूरत होती है। मैं टाइपस्क्रिप्ट का उपयोग कर रहा हूं
चूंकि वी 0.8 और कभी भी नल का इस्तेमाल नहीं किया गया था, अकेले ही उनकी आवश्यकता थी। बस नज़रअंदाज़ कर दो
उन्हें आप की तरह किसी अन्य बेकार भाषा सुविधा के साथ करते हैं जैसे with
बयान।

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

@metaweta , आप खुद को नल से गारंटी नहीं दे सकते। आपके कोड को संकलित करने से पहले आपके काम को रुलाने के एक गजलियन तरीके हैं: pleaseNonNullablesNumbersOnly(<any> null) । जेएस को संकलित करने के बाद कोई नियम नहीं हैं। दूसरी बात, आप क्यों परवाह करेंगे? इसे ज़ोर से कहें और nulls are not supported, you put a null you will get a crash पहले स्पष्ट करें, एक अस्वीकरण की तरह, आप अपने आप को वहाँ के सभी प्रकार के लोगों से गारंटी नहीं दे सकते हैं, लेकिन आप अपनी जिम्मेदारियों के दायरे की रूपरेखा तैयार कर सकते हैं। तीसरा, मैं शायद ही एक प्रमुख मुख्यधारा के काम के बारे में सोच सकता हूं जो कि जो कुछ भी उपयोगकर्ता इनपुट के रूप में डाल सकता है, उसके लिए बुलेटप्रूफ है, फिर भी यह अभी भी पागल लोकप्रिय है। तो क्या आपका प्रयास परेशानी के लायक है?

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

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

विषय पर:
हमें अन्य कोड में नल 'एस्केपिंग' के साथ कभी कोई समस्या नहीं हुई है, लेकिन हमारे पास यादृच्छिक अपरिभाषित या NaN दिखने के साथ समस्याएं हैं। मेरा मानना ​​है कि इस परिदृश्य में सावधान कोड प्रबंधन ध्वज से बेहतर है।

हालाँकि, पुस्तकालय टाइपिंग के लिए यह अच्छा होगा कि निरर्थक प्रकार का शून्य हो ताकि हम उन कार्यों को एनोटेट करना चुन सकें जो अशक्त हो सकते हैं (इसे संकलक द्वारा लागू नहीं किया जाना चाहिए, लेकिन कोडिंग प्रथाओं द्वारा)।

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

• कोई ! सिंटैक्स का उपयोग उस प्रकार को दर्शाने के लिए कर सकता है जो शून्य नहीं ले सकता, उदाहरण के लिए string! एक शून्य नहीं ले सकता
• noNullsAllowed स्विच चालू है

तो आप अपने सर्वर से अजाक्स पर हर जगह नल के साथ जेसन का एक टुकड़ा प्राप्त करते हैं, नैतिक: जावास्क्रिप्ट की गतिशील प्रकृति को इसके शीर्ष पर एक प्रकार की एनोटेशन द्वारा तय नहीं किया जा सकता है

@ एलेक्सी-बायकोव उसी टोकन द्वारा, यदि मैं एक संख्यात्मक संपत्ति x साथ किसी ऑब्जेक्ट की अपेक्षा कर रहा हूं और मुझे सर्वर से {"x":"foo"} मिलता है, तो टाइप सिस्टम इसे रोकने में सक्षम नहीं होगा . सर्वर पर टाइपस्क्रिप्ट के अलावा किसी अन्य चीज़ का उपयोग करते समय यह आवश्यक रूप से एक रनटाइम त्रुटि और एक अपरिहार्य समस्या है।

यदि, हालांकि, सर्वर टाइपस्क्रिप्ट में लिखा गया है और नोड पर चल रहा है, तो इसे मेरे फ्रंट एंड कोड के लिए .d.ts फ़ाइल की उपस्थिति में ट्रांसपाइल किया जा सकता है और टाइप चेकिंग गारंटी देगा कि सर्वर कभी भी JSON को नल के साथ नहीं भेजेगा। इसमें या कोई वस्तु जिसकी x संपत्ति एक संख्या नहीं है।

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

हां, हमें इसकी सख्त जरूरत है। होरे द्वारा अरब डॉलर की गलती देखें। नल पॉइंटर अपवाद (एनपीई) टाइप की गई प्रोग्रामिंग भाषाओं में सबसे आम त्रुटि है जो गैर-शून्य प्रकारों से अशक्त में भेदभाव नहीं करती है। यह इतना सामान्य है कि जावा 8 ने इसे लड़ने के लिए एक बेताब प्रयास में Optional जोड़ा।

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

अब जबकि TS में यूनियन और टाइप गार्ड हैं, टाइप सिस्टम ऐसा करने के लिए पर्याप्त शक्तिशाली है। सवाल यह है कि क्या इसे पिछड़े-संगत तरीके से किया जा सकता है। व्यक्तिगत रूप से मुझे लगता है कि टाइपस्क्रिप्ट 2.0 के लिए यह सुविधा काफी महत्वपूर्ण है कि इस संबंध में पिछड़ा-असंगत हो।

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

यह नल का उपयोग _नहीं करने के बारे में नहीं है। इसमें शामिल सभी प्रकारों को ठीक से मॉडलिंग करने के बारे में है। वास्तव में यह सुविधा सुरक्षित तरीके से नल के उपयोग की अनुमति देगी - अब उनसे बचने का कोई कारण नहीं होगा! अंतिम परिणाम बीजगणितीय Maybe प्रकार पर मिलान करने वाले पैटर्न के समान होगा (सिवाय इसके कि केस एक्सप्रेशन के बजाय अगर चेक के साथ किया जाएगा)

और यह केवल अशक्त शाब्दिकों के बारे में नहीं है। null और undefined संरचनात्मक रूप से समान हैं (afaik ऐसे कोई फ़ंक्शन/ऑपरेटर नहीं हैं जो एक पर काम करते हैं लेकिन दूसरे पर नहीं) इसलिए उन्हें टीएस में एक शून्य प्रकार के साथ पर्याप्त रूप से अच्छी तरह से मॉडलिंग किया जा सकता है।

@मेटावेटा ,

जावास्क्रिप्ट में शून्य मान केवल एक गैर-मिलान वाले regexp पर और JSON में किसी दिनांक को क्रमबद्ध करते समय लौटाया जाता है।

कतई सच नहीं है।

• डोम के साथ इंटरेक्शन शून्य उत्पन्न करता है:

  console.log(window.document.getElementById('nonExistentElement')); // null

• जैसा कि @ एलेक्सी-बायकोव ने ऊपर बताया, अजाक्स ऑपरेशन अशक्त हो सकता है। वास्तव में undefined मान्य JSON मान नहीं है:

 JSON.parse(undefined); // error
 JSON.parse(null); // okay
 JSON.stringify({ "foo" : undefined}); // "{}"
 JSON.stringify({ "foo" : null}); // '{"foo":null}'

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

यदि, हालांकि, सर्वर टाइपस्क्रिप्ट में लिखा गया है और नोड पर चल रहा है, तो इसे मेरे फ्रंट एंड कोड के लिए .d.ts फ़ाइल की उपस्थिति में ट्रांसपाइल किया जा सकता है और टाइप चेकिंग गारंटी देगा कि सर्वर कभी भी JSON को नल के साथ नहीं भेजेगा। उसमें या कोई वस्तु जिसका x गुण कोई संख्या नहीं है।

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

मैं इस पर @aleksey-bykov से सहमत हूं। हालांकि यह पूरी तरह से शानदार होगा यदि हम टाइपस्क्रिप्ट हमें अशक्त और अपरिभाषित द्वारा शुरू की गई त्रुटियों के बारे में संकलन समय पर सचेत कर सकते हैं, मुझे डर है कि यह केवल आत्मविश्वास की झूठी भावना को प्रेरित करेगा और सामान्य ज्ञान को पकड़ लेगा, जबकि अशक्त के वास्तविक स्रोतों का पता नहीं चल पाता है।

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

यह वास्तव में एक तर्क _for_ गैर-शून्य प्रकार है। यदि आपका भंडारण नल फू वापस कर सकता है, तो उस भंडारण से प्राप्त वस्तु का प्रकार Nullable<Foo> है, फू नहीं। यदि आपके पास एक ऐसा फ़ंक्शन है जो फू को वापस करने के लिए लौटाता है, तो आप _have_ को शून्य को संभालने की ज़िम्मेदारी लेते हैं (या तो आप इसे डालते हैं क्योंकि आप बेहतर जानते हैं या आप शून्य की जांच करते हैं)।

यदि आपके पास गैर-शून्य प्रकार नहीं थे, तो आप जरूरी नहीं सोचेंगे कि संग्रहीत वस्तु को वापस करते समय शून्य की जांच करें।

मुझे डर है कि यह केवल आत्मविश्वास की झूठी भावना को प्रेरित करेगा और सामान्य ज्ञान को पकड़ लेगा, जबकि शून्य के वास्तविक स्रोत ज्ञात नहीं होंगे।

आपको क्या लगता है कि गैर-अशक्त प्रकार किस प्रकार के गैर-सामान्य ज्ञान को याद करेंगे?

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

यदि लगातार भंडारण टाइप किए गए डेटा का समर्थन करता है, तो कोई आवश्यकता नहीं होगी। लेकिन अगर ऐसा नहीं भी होता, तो आपके पास केवल डेटा फ़ेचिंग पॉइंट्स पर चेक होते और फिर आपके अन्य कोड के _all_ में गारंटी होती।

मैं इस पर @aleksey-bykov से सहमत हूं। हालांकि यह पूरी तरह से शानदार होगा यदि हम टाइपस्क्रिप्ट हमें अशक्त और अपरिभाषित द्वारा शुरू की गई त्रुटियों के बारे में संकलन समय पर सचेत कर सकते हैं, मुझे डर है कि यह केवल आत्मविश्वास की झूठी भावना को प्रेरित करेगा और सामान्य ज्ञान को पकड़ लेगा, जबकि अशक्त के वास्तविक स्रोतों का पता नहीं चल पाता है।

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

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

एक और बात कृपया एक भाषा सुविधा के बारे में चर्चा में मूर्खतापूर्ण टिप्पणियों के साथ न जाएं जैसे:

गैर-शून्य प्रकार बेकार हैं। गैर-शून्य प्रकार बेकार हैं। वे बेकार हैं। निकम्मा! आपको इसका एहसास नहीं है, लेकिन आपको वास्तव में उनकी आवश्यकता नहीं है।

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

मैं नॉन-नल टाइप एनोटेशन शुरू करने के बिल्कुल खिलाफ नहीं हूं। इसे C# और अन्य भाषाओं में उपयोगी दिखाया गया है।

ओपी ने निम्नलिखित के साथ चर्चा के पाठ्यक्रम को बदल दिया है:

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

मैं केवल जंगली में null और undefined की व्यापकता की ओर इशारा कर रहा था।

मुझे यह भी जोड़ना चाहिए कि टाइपस्क्रिप्ट के बारे में जिन चीजों की मैं वास्तव में सराहना करता हूं, उनमें से एक भाषा का अहस्तक्षेप-दृष्टिकोण है। यह ताजी हवा की सांस रही है।

इस बात पर जोर देना कि डिफ़ॉल्ट रूप से प्रकार गैर-शून्य हैं, उस भावना के अनाज के खिलाफ जाता है।

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

1) जानना चाहते हैं कि कोई फ़ंक्शन शून्य वापस कर सकता है या नहीं (इसके निष्पादन पैटर्न के कारण, यह टाइपिंग नहीं है)।
2) जानना चाहते हैं कि कोई मान शून्य हो सकता है या नहीं।
3) जानना चाहते हैं कि डेटा ऑब्जेक्ट में शून्य मान हो सकते हैं या नहीं।

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

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

हल 2 भी इसी से हल होता है।

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

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

(फोन से पोस्टिंग, त्रुटियों के लिए खेद है)

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

@spion , बुरी खबर: एफ # नल (.NET की विरासत के रूप में) मिला। अच्छी खबर: कोई उनका उपयोग नहीं करता है। जब आप वहां हों तो आप शून्य का उपयोग कैसे नहीं कर सकते? उनके पास वैकल्पिक हैं (जैसा कि आपने हाल ही में उल्लेख किया है जावा की तरह)। इसलिए यदि आपके पास अपने निपटान में बेहतर विकल्प है तो आपको शून्य की आवश्यकता नहीं है। अंततः मैं यही सुझाव दे रहा हूं: अकेले नल (गैर-नल) छोड़ दें, बस भूल जाएं कि वे मौजूद हैं, और एडीटी को भाषा सुविधा के रूप में लागू करें।

हम नल का उपयोग करते हैं लेकिन उसी तरह नहीं जैसे आप लोग करते हैं। मेरी कंपनी का सोर्स कोड 2 भागों में आता है।

1) जब डेटा (डेटाबेस डेटा की तरह) की बात आती है, तो हम परिवर्तनीय घोषणा के समय रिक्त डेटा के साथ शून्य को प्रतिस्थापित करते हैं।

2) अन्य सभी, प्रोग्राम करने योग्य वस्तुओं की तरह, हम नल का उपयोग करते हैं, इसलिए हम जानते हैं कि जब स्रोत कोड में कोई बग और खामियां होती हैं, जहां ऑब्जेक्ट नहीं बनाए जाते हैं या असाइन करने योग्य होते हैं जो आवश्यक जावास्क्रिप्ट ऑब्जेक्ट नहीं होते हैं। अपरिभाषित जावास्क्रिप्ट ऑब्जेक्ट समस्याएँ हैं जहाँ स्रोत कोड में कोई बग या खामी है।

जिस डेटा को हम अशक्त नहीं बनाना चाहते हैं क्योंकि यह ग्राहक डेटा है और वे शून्य शब्द देखेंगे।

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

दूसरी तरफ यह परिभाषित करना असंभव है कि संघ किस प्रकार शून्य मान का बहिष्करण करता है, इसलिए हमें गैर-शून्य प्रकार की आवश्यकता है।

@fdecampredon , TS में ADT नहीं है, इसमें ऐसे संघ हैं जो योग प्रकार नहीं हैं, क्योंकि, जैसा कि आपने कहा, 1. वे एक खाली मामले को सही ढंग से मॉडल नहीं कर सकते क्योंकि कोई इकाई प्रकार नहीं है, 2. विनाश का कोई विश्वसनीय तरीका नहीं है उन्हें

एडीटी के लिए पैटर्न मिलान इस तरह से कार्यान्वित किया जा सकता है जो जेनरेट की गई जावास्क्रिप्ट के साथ निकटता से जुड़ा हुआ है, वैसे भी मुझे उम्मीद है कि यह तर्क एक महत्वपूर्ण मोड़ नहीं है

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

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

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

@ ग्रिफोर्क विचार यह है कि आपके कोड में हर जगह शून्य जांच से बचें। मान लें कि आपके पास निम्न कार्य है

declare function getName(personId:number):string|null;

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

function doSomethingWithPersonsName(personId:number) {
  var name = getName(personId);
  if (name != null) return doThingsWith(name); // type guard narrows string|null to just string
  else { return handleNullCase(); }
}

और अब तुम महान हो! टाइप सिस्टम गारंटी देता है कि doThingsWith को ऐसे नाम से बुलाया जाएगा जो शून्य नहीं है

function doThingsWith(name:string) {
  // Lets create some funny versions of the name
  return [uppercasedName(name), fullyLowercased(name), funnyCased(name)]
}

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

function justUppercased(personId:number) {
  var name = getName(personId);
  return uppercasedName(name); // error, passing nullable to a function that doesn't check for nulls.
}

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

और अगर आपको ट्रैकिंग पसंद नहीं है क्योंकि आपको लगता है कि यह शून्य मान की संभावना को मॉडलिंग के लायक नहीं है, तो आप अच्छे पुराने असुरक्षित व्यवहार पर वापस लौट सकते हैं:

declare function getName(personId:number):string;

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

uppercasedName(null);

पिछड़े-संगतता को छोड़कर, मैं स्पष्ट रूप से डाउनसाइड्स नहीं देखता।

@jbondc एक है https://github.com/Microsoft/TypeScript/issues/186

@fdecampredon संघ प्रकार बस यही हैं, संघ। वे _disjoint_ यूनियनों उर्फ ​​रकम नहीं हैं। #186 देखें।

@ अलेक्सी-बायकोव

ध्यान दें कि एक विकल्प प्रकार जोड़ना अभी भी एक महत्वपूर्ण परिवर्तन होने जा रहा है।

// lib.d.ts
interface Document {
    getElementById(id: string): Maybe<Element>;
}

...

// Code that worked with 1.3
var myCanvas = <HTMLCanvasElement>document.getElementById("myCanvas");
// ... now throws the error that Maybe<Element> can't be cast to an <HTMLCanvasElement>

आखिरकार, आप एक गरीब आदमी के विकल्प प्रकार अभी विनाशकारी के साथ प्राप्त कर सकते हैं

class Option<T> {
    hasValue: boolean;
    value: T;
}

var { hasValue, myCanvas: value } = <Option<HTMLCanvasElement>> $("myCanvas");
if (!hasValue) {
    throw new Error("Canvas not found");
}
// Use myCanvas here

लेकिन इसका एकमात्र मूल्य यह है कि यदि lib.d.ts (और कोई अन्य .d.ts, और आपका पूरा कोडबेस लेकिन हम मान लेंगे कि हम इसे ठीक कर सकते हैं) भी इसका उपयोग करें, अन्यथा आप यह नहीं जान पाएंगे कि क्या a फ़ंक्शन जो विकल्प का उपयोग नहीं करता है वह शून्य हो सकता है या नहीं जब तक कि आप इसका कोड नहीं देखते।

ध्यान दें कि मैं भी डिफ़ॉल्ट रूप से गैर-शून्य प्रकारों के पक्ष में नहीं हूं (वैसे भी TS 1.x के लिए नहीं)। यह बहुत बड़ा ब्रेकिंग बदलाव है।

लेकिन मान लीजिए कि हम 2.0 के बारे में बात कर रहे हैं। अगर हम वैसे भी एक ब्रेकिंग परिवर्तन करने जा रहे हैं (विकल्प प्रकार जोड़ना), तो डिफ़ॉल्ट रूप से प्रकार को गैर-शून्य क्यों नहीं बनाते? डिफ़ॉल्ट रूप से प्रकार को अशक्त बनाना और विकल्प प्रकार जोड़ना अनन्य नहीं है। उत्तरार्द्ध स्टैंडअलोन हो सकता है (उदाहरण के लिए एफ # में जैसा कि आप इंगित करते हैं) लेकिन पूर्व को बाद वाले की आवश्यकता होती है।

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

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

@ अलेक्सी-बायकोव

मैंने यह नहीं कहा कि हमें हस्ताक्षरों को बदलने की जरूरत है, सभी मौजूदा हस्ताक्षर बरकरार हैं

_I_ ने कहा कि हस्ताक्षरों को बदलने की जरूरत है, और मैंने पहले ही कारण बता दिया है:

लेकिन इसका एकमात्र मूल्य यह है कि यदि lib.d.ts (और कोई अन्य .d.ts, और आपका पूरा कोडबेस लेकिन हम मान लेंगे कि हम इसे ठीक कर सकते हैं) भी इसका उपयोग करें, अन्यथा आप यह नहीं जान पाएंगे कि क्या a फ़ंक्शन जो विकल्प का उपयोग नहीं करता है वह शून्य हो सकता है या नहीं जब तक कि आप इसका कोड नहीं देखते।

डिफ़ॉल्ट रूप से कुछ भी गैर-शून्य नहीं बनाया जा रहा है। कभी।

TS 1.x के लिए, मैं सहमत हूं, केवल इसलिए कि यह बहुत बड़ा परिवर्तन है। 2.0 के लिए, डिफ़ॉल्ट हस्ताक्षर (lib.d.ts आदि) में विकल्प प्रकार का उपयोग करना पहले से ही एक महत्वपूर्ण परिवर्तन होगा। डिफ़ॉल्ट रूप से प्रकार को गैर-शून्य करने योग्य बनाना _in इसके अलावा_ इसके लायक हो जाता है और इसमें कोई डाउनसाइड नहीं होता है।

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

तो आप कह रहे हैं कि यदि मेरे पास एक फ़ंक्शन foo है जो Option<number> लौटाता है और एक फ़ंक्शन बार जो संख्या देता है, मुझे यह विश्वास करने की अनुमति नहीं है कि जब तक मैं बार के कार्यान्वयन को नहीं देखता या दस्तावेज़ीकरण बनाए रखता हूं, तब तक मुझे यह विश्वास करने की अनुमति नहीं है कि बार शून्य नहीं हो सकता "यह फ़ंक्शन कभी शून्य नहीं लौटाता है।"? क्या आपको नहीं लगता कि यह उन कार्यों को दंडित करता है जो कभी भी शून्य नहीं होंगे?

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

Old_lib.d.ts

...
declare function bar(): number; // looks like can return a potentially nullable number
...

संशोधित_lib.d.ts

declare function bar(): !number; // now thank to the knowledge we are 100% certain it cannot return null

अब पुराने ऐप्स old_lib.d.ts का उपयोग करते रहते हैं, नए ऐप्स के लिए एक डेवलपर revised_libs.d.ts चुनने के लिए स्वतंत्र है

दुर्भाग्य से संशोधित_लिब्स.डी.टीएस में 50 अन्य कार्य हैं जिन्हें मैंने अभी तक नहीं देखा है, जिनमें से सभी वापसी संख्या (लेकिन मुझे नहीं पता कि यह वास्तव में संख्या या शून्य संख्या है)। अब क्या?

ठीक है, अपना समय लें, मदद मांगें, वर्जनिंग का उपयोग करें (आपके द्वारा अब तक प्राप्त ज्ञान के स्तर के आधार पर आप इसे लगातार बढ़ती संस्करण संख्या के साथ स्नातक रूप से जारी करना चाह सकते हैं: revised_lib.v-0.1.12.d.ts )

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

मैं का प्रशंसक नहीं हूँ! केवल इसलिए कि यह टाइप करने के लिए अधिक सामान है (कीस्ट्रोक के संदर्भ में और इसका उपयोग करने के लिए याद रखने की आवश्यकता दोनों)। अगर हम 1.x में गैर-शून्यता चाहते हैं तो ! पहले से ही ऊपर चर्चा किए गए विकल्पों में से एक है, लेकिन मैं अभी भी कहूंगा कि 2.0 के साथ एक अंतिम ब्रेकिंग परिवर्तन और गैर-शून्यता को डिफ़ॉल्ट बनाना इसके लायक है।

दूसरी ओर, शायद यह एक पायथन 2/3-एस्क स्थिति की ओर ले जाएगा, जहां कोई भी वर्षों से टीएस 2.0 में अपग्रेड नहीं करता है क्योंकि वे अपने मिलियन-लाइन कोडबेस के माध्यम से जाने का जोखिम नहीं उठा सकते हैं, यह सुनिश्चित करते हुए कि प्रत्येक परिवर्तनीय घोषणा और वर्ग सदस्य और फ़ंक्शन पैरामीटर और... के साथ एनोटेट किया गया है? अगर यह शून्य हो सकता है। यहां तक ​​कि 2to3 (पायथन 2 से 3 माइग्रेशन टूल) को भी इस तरह के व्यापक बदलावों से नहीं जूझना पड़ता है।

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

शायद हमें फ़नस्क्रिप्ट लोगों से पूछना चाहिए कि वे F# के साथ DOM API रिटर्निंग नल को कैसे समेटते हैं (Funscript F# कोड से उपयोग के लिए टाइपस्क्रिप्ट के lib.d.ts और अन्य .d.ts का उपयोग करता है)। मैंने कभी इसका उपयोग नहीं किया है, लेकिन उदाहरण के लिए http://funscript.info/samples/canvas/index.html को देखकर ऐसा लगता है कि टाइप प्रदाता यह नहीं सोचता कि document.getElementsByTagName("canvas")[0] कभी भी हो सकता है अपरिभाषित

संपादित करें: यहां ऐसा लगता है कि document.getElementById() के अशक्त लौटने की उम्मीद नहीं है। कम से कम ऐसा लगता है कि यह विकल्प <तत्व> वापस नहीं आ रहा है, यह देख रहा है कि यह पहुंच रहा है। परिणाम पर क्लिक करें।

@spion
धन्यवाद, मैंने इसके बारे में नहीं सोचा था।

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

@Griffork ने टाइपस्क्रिप्ट कंपाइलर में मुद्दों की इस

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

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

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

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

मैंने अलग-अलग कीवर्ड के साथ फ़िल्टर को कम करने की कोशिश की और मैं (सोचता हूं) उन सभी को प्राप्त करने में कामयाब रहा

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

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

अशक्त रखने के कारण अब उपयोग में आसान हैं:
• यह अपरिभाषित से बेहतर डिफ़ॉल्ट मान है।
. 1) कुछ मामलों में जाँच करना तेज़ है (हमारा कोड बहुत अच्छा होना चाहिए)
. 2) यह लूप में वस्तुओं पर अधिक अनुमानित रूप से काम करता है।
. 3) रिक्त मानों के लिए नल का उपयोग करते समय यह सरणी उपयोग को अधिक समझ में आता है (अनुपलब्ध मानों के विपरीत)। ध्यान दें कि indexOf (और शायद अन्य लोकप्रिय सरणी विधियों) का उपयोग करते समय delete array[i] और array[i] = undefined का व्यवहार अलग-अलग होता है।

मुझे लगता है कि नल बनाने के परिणाम को भाषा में उपयोग करने के लिए अतिरिक्त मार्क अप की आवश्यकता है:
• मुझे एक शून्य त्रुटि के बजाय एक अपरिभाषित त्रुटि मिली (जो कि अधिकांश टाइपस्क्रिप्ट परिदृश्यों में होता है)।

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

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

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

निष्कर्ष:
गैर-अपरिभाषित प्रकारों को परिभाषित किए बिना गैर-अशक्त प्रकारों को घोषित करने में सक्षम होने का कोई मतलब नहीं है। और जावास्क्रिप्ट के काम करने के तरीके के कारण गैर-अपरिभाषित प्रकार संभव नहीं हैं।

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

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

@spion
मुझे विश्वास है कि मैं अंततः समझ रहा हूँ कि आप कहाँ से आ रहे हैं।

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

मैं देख सकता हूं कि यह उपयोगी है।

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

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

आप इस समस्या के समाधान के रूप में फ्लो का उल्लेख करते हैं, लेकिन आपके लिंक को पढ़ते समय मैंने कुछ संबंधित चीजों को देखा:

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

"अपरिभाषित मान, बिल्कुल शून्य की तरह, भी समस्याएं पैदा कर सकते हैं। दुर्भाग्य से, अपरिभाषित मान जावास्क्रिप्ट में सर्वव्यापी हैं और भाषा की उपयोगिता को गंभीर रूप से प्रभावित किए बिना उनसे बचना मुश्किल है [...] फ्लो इस मामले में एक ट्रेडऑफ बनाता है: यह अपरिभाषित स्थानीय चर का पता लगाता है और मान लौटाता है, लेकिन ऑब्जेक्ट प्रॉपर्टी और ऐरे एलिमेंट एक्सेस के परिणामस्वरूप अपरिभाषित की संभावना को अनदेखा करता है ।"

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

पी.एस.

foo(thing: whatiknowaboutmyobject) {
    if (thing.hidden) {
        delete thing.description;
    }
}

if (typeof thing.description === "string") {
    //thing.description is non-nullable now, right?
    foo(thing);
    //What is thing.description?
    console.log(thing.description.length);
}

TS पहले से ही अलियासिंग प्रभावों के प्रति संवेदनशील है (जैसा कि कोई भी भाषा है जो परिवर्तनशील मूल्यों की अनुमति देती है)। यह बिना किसी त्रुटि के संकलित होगा:

function foo(obj: { bar: string|number }) {
    obj.bar = 5;
}

var baz: { bar: string } = { bar: "5" };

foo(baz);

console.log(baz.bar.charAt(0)); // Runtime error - Number doesn't have a charAt method

फ्लो डॉक्स इसे केवल पूर्णता के लिए बता रहे हैं।

संपादित करें: बेहतर उदाहरण।

पुराना:

हां, लेकिन मेरा तर्क है कि किसी चीज़ को अपरिभाषित करने का साधन किसी चीज़ को दूसरे मूल्य पर सेट करने के साधनों से कहीं अधिक है।

मेरा मतलब है,

mything.mystring = 5; // is clearly wrong.
delete mything.mystring; //is not clearly wrong - this is not quite the equivalent of setting mystring to >undefined.

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

@Griffork इस

var mything = {mystring: "5"}; 
delete mything.mystring;
console.log(mything.mystring.charAt(1));

वैसे, डिलीट ऑपरेटर के साथ वैसे ही व्यवहार किया जा सकता है जैसे कि टाइप नल का मान निर्दिष्ट करना और यह आपके मामले को भी कवर करने के लिए पर्याप्त होगा।

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

@spion

विचार यह है कि आपके कोड में हर जगह अशक्त जाँच करने से बचें

अगर मैं समझता हूं कि आप क्या वकालत कर रहे हैं:

ए. डिफ़ॉल्ट रूप से सभी प्रकार को गैर-शून्य बनाएं।
B. फ़ील्ड और वेरिएबल को चिह्नित करें जो अशक्त हैं।
सी. सुनिश्चित करें कि एप्लिकेशन/लाइब्रेरी डेवलपर एप्लिकेशन में सभी प्रवेश बिंदुओं की जांच करता है।

लेकिन क्या इसका मतलब यह नहीं है कि किसी के कोड को शून्य से मुक्त करने के लिए कोड लिखने वाले व्यक्ति पर है, न कि कंपाइलर पर? हम प्रभावी रूप से संकलक को बता रहे हैं "dw, मैं सिस्टम में कोई नल नहीं दे रहा हूं।"

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

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

मेरा मानना ​​​​है कि इस मुद्दे पर मजबूत असहमति है, क्योंकि इस पर निर्भर करता है कि कोई क्या काम कर रहा है, ऊपर आइटम C या तो तुच्छ या अक्षम्य हो सकता है।

@jbondc मुझे खुशी है कि आपने यह पूछा। दरअसल CallExpression को अपरिभाषित या शून्य के रूप में चिह्नित किया गया है। हालांकि, टाइप सिस्टम वर्तमान में इसका कोई फायदा नहीं उठाता है - यह अभी भी typeArguments पर सभी परिचालनों को अनुमति देता है जैसे कि यह शून्य या अपरिभाषित नहीं है।

हालांकि, गैर-शून्य प्रकारों के संयोजन में नए संघ प्रकारों का उपयोग करते समय, प्रकार को NodeArray<TypeNode>|null रूप में व्यक्त किया जा सकता है। तब टाइप सिस्टम उस क्षेत्र पर किसी भी संचालन की अनुमति नहीं देगा जब तक कि एक शून्य जांच लागू न हो:

if (ce.typeArguments != null) {
  callSomethingOn(ce.typeArguments)
}

// callSomethingOn doesn't need to perform any checks

function callSomethingOn(na:NodeArray<TypeNode>) {
...
}

TS 1.4 प्रकार के गार्डों की मदद से, if ब्लॉक के अंदर अभिव्यक्ति के प्रकार को NodeArray<TypeNode> सीमित कर दिया जाएगा जो बदले में उस प्रकार के सभी NodeArray संचालन की अनुमति देगा; इसके अतिरिक्त, उस चेक के भीतर बुलाए गए सभी फ़ंक्शन अपने तर्क प्रकार को NodeArray<TypeNode> निर्दिष्ट करने में सक्षम होंगे, बिना किसी और जांच के, कभी भी।

लेकिन अगर आप लिखने की कोशिश करते हैं

function someOtherFunction(ce: CallExpression) {
  callSomethingOn(ce.typeArguments)
}

संकलक आपको इसके बारे में संकलन समय पर चेतावनी देगा, और बग बस नहीं हुआ होगा।

तो नहीं, @NoelAbrahams , यह निश्चित रूप से सब कुछ जानने के बारे में नहीं है। यह संकलक के बारे में है जो आपको यह बताने में मदद करता है कि एक चर या क्षेत्र में क्या मूल्य हो सकता है, जैसे अन्य सभी प्रकारों के साथ।

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

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

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

@spion , मैं यह _by डिफ़ॉल्ट _ हों?

यह बहाना कि तार पर प्राप्त वस्तु पर एक क्षेत्र (अर्थात् अजाक्स) गैर-शून्य है, का अर्थ है ईश्वर में विश्वास होना

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

ज़रूर। यह इस बात पर निर्भर करता है कि क्या हम किसी फ़ील्ड को अशक्त के रूप में चिह्नित करना चाहते हैं (ऐसी प्रणाली में जहां फ़ील्ड डिफ़ॉल्ट रूप से गैर-शून्य हैं) या क्या हम किसी फ़ील्ड को गैर-शून्य के रूप में चिह्नित करना चाहते हैं (ऐसी प्रणाली में जहां फ़ील्ड डिफ़ॉल्ट रूप से अशक्त हैं)।

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

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

जब आप इसके बारे में थोड़ा सोचते हैं तो एक प्रकार को एक अशक्त प्रकार प्रणाली में गैर-शून्य के रूप में चिह्नित करने का सीमित मूल्य होता है, फिर भी आप परीक्षण करने के लिए मजबूर किए बिना अशक्त टाइप किए गए चर/वापसी प्रकार का उपभोग करने में सक्षम होंगे।
यह परिभाषा लेखक को अधिक कोड लिखने के लिए भी मजबूर करेगा, क्योंकि अधिकांश समय अच्छी तरह से डिज़ाइन की गई लाइब्रेरी कभी भी शून्य या अपरिभाषित मान नहीं लौटाती है।
अंत में अवधारणा भी अजीब है, एक प्रकार की प्रणाली में गैर-शून्य प्रकार के साथ, एक अशक्त प्रकार एक संघ प्रकार के रूप में पूरी तरह से अभिव्यक्त होता है: ?string string | null | undefined के बराबर है। अशक्त प्रकार के साथ एक प्रकार प्रणाली में डिफ़ॉल्ट के रूप में जहां आप प्रकार को गैर अशक्त के रूप में चिह्नित कर सकते हैं आप !string को कैसे व्यक्त करेंगे? string - null - undefined ?

अंत में मैं यहाँ के लोगों की चिंता को वास्तव में नहीं समझता, null एक स्ट्रिंग नहीं है, उसी तरह 5 एक स्ट्रिंग नहीं है, दोनों मान नहीं कर पाएंगे जहां एक स्ट्रिंग की उम्मीद है, वहां इस्तेमाल किया जा सकता है, और पर्ची देना var myString: string = null त्रुटि प्रवण है: var myString: string = 5 ।
किसी भी प्रकार के लिए अशक्त या अपरिभाषित होना शायद एक अवधारणा है जिससे डेवलपर परिचित हैं, लेकिन यह अभी भी एक खराब है।

मुझे नहीं लगता कि मैं अपनी पिछली पोस्ट में पूरी तरह से सही था: मैं इसे समय पर दोष दूंगा।

मैंने यह देखने के लिए अभी हमारे कुछ कोड देखे हैं कि चीजें कैसे काम करेंगी और यह निश्चित रूप से कुछ क्षेत्रों को अशक्त के रूप में चिह्नित करने में मदद करेगी, उदाहरण के लिए:

interface Foo {
        name: string;
        address: string|null; /* Nullable */
}

var foo:Foo = new FooClass();
foo.name.toString(); // Okay
foo.address.toString(); // Error: do not use without null check

लेकिन मैं जिस चीज पर आपत्ति करता हूं वह निम्नलिखित है:

foo.name = undefined; // Error: non-nullable

मुझे लगता है कि यह जावास्क्रिप्ट के साथ काम करने के प्राकृतिक तरीके में हस्तक्षेप करेगा।

ठीक यही संख्या के साथ लागू हो सकता है:

interface Foo {
        name: string;
        address: string|number; 
}
var foo:Foo = new FooClass();
foo.name.toString(); // Okay
foo.address.slice() // error

foo.name  = 5 // error

और यह अभी भी जावास्क्रिप्ट में मान्य है

यथोचित रूप से आप कितनी बार स्वेच्छा से किसी वस्तु के गुण को अशक्त करते हैं?

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

@fdecampredon
वास्तव में बहुत कुछ।

@ ग्रिफोर्क ,

मुझे लगता है कि ज्यादातर चीजों को अशक्त के रूप में चिह्नित किया जाएगा

वह मेरा प्रारंभिक विचार था। लेकिन हमारे कोड के कुछ अनुभागों के माध्यम से जाने के बाद मुझे निम्नलिखित टिप्पणियां मिलीं:

interface MyType {

     name: string;

     /** The date the entry was updated from Wikipedia or undefined for user-submitted content. */
     wikiDate: Date; /* Nullable */
}

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

@fdecampredon

foo.name = 5 // error
और यह अभी भी जावास्क्रिप्ट में मान्य है

सच है, लेकिन यह एक त्रुटि है क्योंकि टाइपस्क्रिप्ट 100% निश्चितता के साथ जानता है कि यह जानबूझकर नहीं किया गया था।

जबकि

foo.name = अपरिभाषित; // सर्वर को नाम न भेजें

पूरी तरह से जानबूझकर है।

मुझे लगता है कि कार्यान्वयन जो हमारी आवश्यकताओं के सबसे करीब से फिट होगा, वह है यूनियन प्रकारों का उपयोग नहीं करना, बल्कि मूल सुझाव के साथ जाना:

 wikiDate: ?Date;

मैं @NoelAbrahams . से सहमत हूं

foo.name = 5 // त्रुटि
और यह अभी भी जावास्क्रिप्ट में मान्य है
सच है, लेकिन यह एक त्रुटि है क्योंकि टाइपस्क्रिप्ट 100% निश्चितता के साथ जानता है कि यह जानबूझकर नहीं किया गया था।

संकलक केवल यह जानता है कि आपने नाम को string रूप में चिह्नित किया है न कि string | number यदि आप एक शून्य मान चाहते हैं तो आप इसे केवल ?string या string | null रूप में चिह्नित करेंगे (जो काफी समकक्ष है)

मुझे लगता है कि कार्यान्वयन जो हमारी आवश्यकताओं के सबसे करीब से फिट होगा, वह है यूनियन प्रकारों का उपयोग नहीं करना, बल्कि मूल सुझाव के साथ जाना:

विकि दिनांक: ?तिथि;

तो हम सहमत हैं कि प्रकार डिफ़ॉल्ट रूप से गैर शून्य हैं और आप ? :) के साथ अशक्त चिह्नित करेंगे।
ध्यान दें कि यह एक संघ प्रकार होगा क्योंकि ?Date Date | null | undefined के बराबर होगा :)

ओह क्षमा करें, मैं डिफ़ॉल्ट रूप से अशक्त होने के लिए सहमत होने की कोशिश कर रहा था और विशेष टाइपिंग के साथ शून्य नहीं था (प्रतीक भ्रमित कर रहे हैं)।

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

var wikiDate: ?Date;

wikiDate.toString(); // error
wikiDate && wikiDate.toString(); // okay

यह एक तोड़ने वाला परिवर्तन नहीं है, क्योंकि हमें अभी भी ऐसा करने में सक्षम होना चाहिए:

 var name: string;   // okay
 name.toString();  // if you think that's fine then by all means

शायद आप मानते हैं कि यूनियन प्रकारों में null पेश किए बिना हमारे पास यह नहीं हो सकता है?

जब आप ऐसा करते हैं तो आपका पहला उदाहरण बिल्कुल सही होता है:

wikiDate && wikiDate.toString(); // okay

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

हालाँकि आपका दूसरा उदाहरण अच्छा नहीं है

var name: string;   // okay
name.toString();  // if you think that's fine then by all means

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

var name: string;   // okay
name.toString();  // error because not initialized

var name: string;
if (something) {
  name = "Hello World";
} else {
  name = "Foo bar";
}
name.toString();  // no error since name will always be initialized.

मुझे नहीं पता कि अवरोध कहाँ लगाया जाए, लेकिन यह निश्चित रूप से किसी प्रकार की सूक्ष्म ट्यूनिंग की आवश्यकता होगी ताकि डेवलपर के रास्ते में न आए।

यह एक को तोड़ने के परिवर्तन है और 2.0 से पहले पेश नहीं किया जा सकता है, 'उपयोग nonnull' निर्देश @metaweta द्वारा प्रस्तावित साथ सिवाय शायद

क्यों नहीं है:

var string1: string; //this works like typescript does currently, doesn't need type-guarding before use, null and undefined can be assigned to it.
string1.length; //works
var string2: !string; //this doesn't work because the string must be assigned to a non-null and non-undefined value, doesn't need type-guarding before use.
var string3: ?string; //this must be type guarded to non-null, non-undefined before use.
var string4: !string|null = null; //This may be null, but should never be undefined (and must be type-guarded before use).
var string5: !string|undefined; //this may never be null, but can be undefined (and must be type-guarded before use).

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

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

विचार?

संपादित करें: मैंने इसे इसलिए लिखा क्योंकि यह प्रत्येक क्रिया में स्पष्ट होने के लिए गैर-शून्य का उपयोग करने के विचार को मजबूर करता है। जो कोई भी किसी अन्य TS प्रोजेक्ट से आने वाले कोड को पढ़ता है, उसे पता होगा कि वास्तव में क्या हो रहा है। इसके अलावा संकलक ध्वज बहुत स्पष्ट हो जाता है यदि यह चालू है (जैसा कि blah: string एक त्रुटि है, लेकिन blah:!string नहीं है, जिस तरह से -noimplicitany काम करता है)।

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

मुझे परवाह नहीं है कि क्या गैर-शून्य और गैर-अपरिभाषित ऑप्ट-इन, ऑप्ट-आउट, के साथ हैं
संशोधक टाइप करें (!?), एक निर्देश, या एक कंपाइलर ध्वज; मैं जो कुछ भी करूँगा
उन्हें प्राप्त करने में _तब तक लगता है जब तक वे व्यक्त करना संभव हो_, जो नहीं है
वर्तमान में मामला।

सोम, 22 दिसंबर, 2014 को दोपहर 2:35 बजे, ग्रिफोर्क नोटिफिकेशन @github.com ने लिखा:

क्यों नहीं है:

वर स्ट्रिंग 1: स्ट्रिंग; // यह टाइपस्क्रिप्ट की तरह काम करता है वर्तमान में।, उपयोग करने से पहले टाइप-गार्डिंग की आवश्यकता नहीं है, इसे अशक्त और अपरिभाषित सौंपा जा सकता है।
स्ट्रिंग1.लंबाई; // वर्क्सवार स्ट्रिंग 2: स्ट्रिंग; // यह काम नहीं करता है क्योंकि स्ट्रिंग को एक गैर-शून्य और गैर-अपरिभाषित मान को असाइन किया जाना चाहिए, उपयोग करने से पहले टाइप-गार्डिंग की आवश्यकता नहीं है। var string3: ?string; // यह उपयोग करने से पहले गैर-शून्य, गैर-अपरिभाषित के लिए संरक्षित प्रकार होना चाहिए। var string4: !string|null = null; // यह शून्य हो सकता है, लेकिन कभी भी अपरिभाषित नहीं होना चाहिए (और उपयोग से पहले टाइप-गार्ड होना चाहिए)।var string5: !string|undefined; // यह कभी भी अशक्त नहीं हो सकता है, लेकिन अपरिभाषित हो सकता है (और उपयोग करने से पहले इसे टाइप-गार्ड किया जाना चाहिए)।

और एक संकलक ध्वज है (जो केवल तभी काम करता है जब -नोइम्प्लिकिटनी चालू हो) जो
-noinferrednulls कहते हैं, जो प्रकारों के लिए सामान्य सिंटैक्स को अक्षम करता है (जैसे
string, और int) और आपको आपूर्ति करनी है a ? या ! उनके साथ (शून्य, अपरिभाषित
और कोई भी अपवाद)।

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

विचार?

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

माइक स्टे - [email protected]
http://www.cs.auckland.ac.nz/~mike
http://reperiendi.wordpress.com

@ ग्रिफोर्क जो एक विकल्प होगा, लेकिन मेरी राय में एक बुरा है, और मैं

• यह परिभाषा फाइलों में बहुत अधिक काम करेगा, क्योंकि अब हमें सही परिभाषा के लिए हर प्रकार की जांच और व्याख्या करनी होगी।
• हम कोड पर हर जगह !string (और कभी-कभी ?string ) लिखना समाप्त कर देंगे जो कोड को बहुत कम पठनीय बना देगा।
• !string एक प्रणाली में जहां प्रकार अशक्त हैं एक अजीब अवधारणा है जिस तरह से आप वास्तव में इसका वर्णन नहीं कर सकते हैं वह है string minus null minus undefined , इसके विपरीत ?string में वर्णन करना बहुत आसान है एक प्रकार की प्रणाली जहां प्रकार डिफ़ॉल्ट रूप से शून्य हैं string | null | undefined ।
• मुझे टाइप-चेक एल्गोरिदम खोजने के लिए बहुत सारे सिरदर्द (और पूर्ण हानि) की उम्मीद है जहां संकलक समझता है कि string | null को एक प्रकार के गार्ड की आवश्यकता होती है लेकिन string नहीं, आप मूल रूप से एक अवधारणा पेश करते हैं जहां कुछ संघ प्रकार को दूसरे की तुलना में अलग तरह से व्यवहार किया जाना चाहिए।
• और अंत में सबसे खराब हिस्सा हम पूरी तरह से ढीले प्रकार का अनुमान var myString = "hello" क्या myString string , ?string या !string ? ईमानदारी से यहाँ परिप्रेक्ष्य में एक बड़ा सिरदर्द।

यदि हमारे पास डिफ़ॉल्ट के रूप में गैर-शून्य प्रकार नहीं है, तो सबसे अच्छा प्रस्ताव जो मैंने यहां देखा है, वह है 'use non-null' @metaweta द्वारा प्रस्तावित निर्देश।
निश्चित रूप से इसे अच्छी तरह से निर्दिष्ट करने की आवश्यकता है लेकिन कम से कम हमारी सभी फाइलों में केवल use non-null स्ट्रिंग के साथ हम एक सरल अनुमानित व्यवहार प्राप्त कर सकते हैं।

@fdecampredon

1. यह परिभाषा फाइलों में बहुत अधिक काम हो सकता है, लेकिन _आपको वह काम वैसे भी करना होगा_ (यह सुनिश्चित करने के लिए कि प्रकार सही हैं) और इस बार संकलक आपको याद दिलाएगा कि आपने अभी तक क्या संपादित नहीं किया है (यदि -noimplicitnull का उपयोग कर रहे हैं) )
2. मैं टिप्पणी के लिए अन्य सुझावों के लिए खुला हूं। मैं ईमानदारी से मानता हूं कि वर्तमान प्रकार की प्रणाली में इसका स्थान है, और इसे _replaced_ नहीं होना चाहिए। मुझे नहीं लगता कि एक ब्रेकिंग बदलाव इसके लायक है। इसके बजाय मुझे लगता है कि हमें यह बताने का एक बेहतर तरीका खोजना चाहिए कि आप क्या चाहते हैं। (मैं वास्तव में, प्रतीकों के साथ इनमें से किसी का प्रतिनिधित्व करने के विचार को वास्तव में नापसंद करता हूं, वे सहज नहीं हैं।)
3. इसके बारे में क्या वर्णन करना मुश्किल है? मैंने टाइपस्क्रिप्ट में कहीं और चर्चाएँ देखी हैं जहाँ यह अनुरोध (कुछ प्रकार के लिए) प्रस्तावित किया गया है (बिना मार्कर के)। एक त्वरित खोज की और मुझे समस्या नहीं मिली, मैं बाद में और खोज करूंगा।
4. 
   यदि आप उस बात का जिक्र कर रहे हैं जो मैंने !string|null रूप में लिखा था, तो यह मौजूदा सिस्टम में काम करेगा यदि नल का इलाज _like_ {} (लेकिन इसे असाइन करने योग्य नहीं था)।
   यदि आप string|null बारे में बात कर रहे हैं जो मेरी सूची में नहीं था, तो मुझे लगता है कि इस मामले में शून्य को अनदेखा किया जाना चाहिए। नल और अपरिभाषित केवल यूनियनों में समझ में आता है जहां प्रत्येक गैर-शून्य और गैर-अपरिभाषित एक से पहले होता है! और कोई भी कोई नहीं है (यह एक कंपाइलर चेतावनी/त्रुटि हो सकता है)।
5. अच्छा प्रश्न, और एक जो केवल तभी उठता है जब आप -noimplicitnull विकल्प का उपयोग कर रहे हैं, मुझे लगता है कि सबसे सुरक्षित विकल्प यह होगा कि इसे किसी भी विकल्प को असाइन किया जाए जिससे प्रारंभिक त्रुटि (शायद अशक्त) होने की सबसे अधिक संभावना हो, लेकिन मुझे मिलता है यह महसूस करना कि एक बेहतर विचार है जिसके बारे में मैं नहीं सोच रहा हूँ। मुझे आश्चर्य है कि अगर किसी और के पास कोई सुझाव है कि इस पर कैसे संपर्क किया जाना चाहिए?

संपादित करें: बिंदु 2 में जोड़ा गया।
संपादित करें: बिंदु 4 में फिक्स्ड टाइपो।

यह परिभाषा फाइलों में बहुत अधिक काम हो सकता है, लेकिन आपको वह काम वैसे भी करना होगा (यह सुनिश्चित करने के लिए कि प्रकार सही हैं) और इस बार संकलक आपको याद दिलाएगा कि आपने अभी तक क्या संपादित नहीं किया है (यदि -noimplicitnull का उपयोग कर रहे हैं) )

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

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

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

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

यदि आप उस बात का जिक्र कर रहे हैं जिसे मैंने !string|null के रूप में लिखा था, तो यह मौजूदा सिस्टम में काम करेगा यदि नल को {} जैसा माना जाता था (लेकिन इसे असाइन करने योग्य नहीं था)। यदि आप स्ट्रिंग | नल के बारे में बात कर रहे हैं जो मेरी सूची में नहीं था, तो मुझे लगता है कि इस मामले में शून्य को अनदेखा किया जाना चाहिए। नल और अपरिभाषित केवल यूनियनों में समझ में आता है जहां प्रत्येक गैर-शून्य और गैर-अपरिभाषित एक से पहले होता है! और कोई भी कोई नहीं है (यह एक कंपाइलर चेतावनी/त्रुटि हो सकता है)।
मैं इस तथ्य की बात कर रहा हूं कि जब आप 3 प्रकारों को विघटित करते हैं:

• !sting : string - null - undefined
• string : string | null | undefined
• ?string : string | null | undefined

2 नवीनतम में मूल रूप से कोई अंतर नहीं है, लेकिन संकलक को पता होना चाहिए कि string इसे टाइप-गार्ड चेक को बाध्य नहीं करना चाहिए और ?string यह होना चाहिए, उस जानकारी को हर जगह प्रचारित करना होगा, एल्गोरिथ्म बहुत अधिक जटिल होगा कि यह वास्तव में है, और मुझे पूरा यकीन है कि मुझे प्रकार के अनुमान के साथ अजीब मामला मिल सकता है।

अच्छा प्रश्न, और एक जो केवल तभी उठता है जब आप -noimplicitnull विकल्प का उपयोग कर रहे हैं, मुझे लगता है कि सबसे सुरक्षित विकल्प यह होगा कि इसे किसी भी विकल्प को असाइन किया जाए जिससे प्रारंभिक त्रुटि (शायद अशक्त) होने की सबसे अधिक संभावना हो, लेकिन मुझे मिलता है यह महसूस करना कि एक बेहतर विचार है जिसके बारे में मैं नहीं सोच रहा हूँ। मुझे आश्चर्य है कि अगर किसी और के पास कोई सुझाव है कि इस पर कैसे संपर्क किया जाना चाहिए?

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

फिर से आप 'use non-null' निर्देश के खिलाफ क्यों हैं, जितना अधिक मैं इसके बारे में सोचता हूं, यह मुझे आदर्श समाधान लगता है।

@fdecampredon
क्योंकि "गैर-शून्य का उपयोग करें" जैसा कि वर्तमान में प्रस्तावित किया गया है, जिस तरह से भाषा _ उपयोग की जाती है, उस तरह से नहीं जिस तरह से भाषा _लिखित_ है। इसका मतलब है कि एक स्थान से दूसरे स्थान पर ले जाने पर फ़ंक्शन अलग-अलग तरीके से काम कर सकता है जब यह _used_ हो। आपको संकलन-समय की त्रुटियां मिलेंगी जो संभावित रूप से 1-3 फाइलें दूर हैं क्योंकि कुछ गलत टाइप किया गया है।

बीच में अंतर:
string
तथा
?string
है कि ? तथा ! प्रतीक इस चर के लिए सख्त प्रकार की जाँच के लिए कह रहा है (जैसा कि आपका "उपयोग गैर-अशक्त" निर्देश होगा, लेकिन प्रति-चर आधार पर)। इसे इस तरह से समझाएं और मुझे लगता है कि लोगों को इसे समझने में आपको ज्यादा परेशानी नहीं होगी।

अंतर निश्चित रूप से है:
फ़ाइल 1:

//...187 lines of code down...
string myfoo(checker: boolean) {
    if(checker){
        return null;
    }
    else {
        return "hello";
    }
}

फ़ाइल 2:

"use nonnull"
//...2,748 lines of code down...
string myfoo(checker: boolean) {
    if(checker){
        return null; //Error!
    }
    else {
        return "hello";
    }
}

डेवलपर्स को अब मानसिक नक्शा रखना होगा कि कौन सी फाइलें अशक्त हैं और कौन सी फाइलें नहीं हैं। मैं ईमानदारी से मानता हूं कि यह एक बुरा विचार है (भले ही अधिकांश _your_ कोड 'उपयोग अशक्त' हो)।

संपादित करें: इसके अलावा जब आप कोई फ़ंक्शन टाइप करना शुरू करते हैं और आपको छोटी विंडो मिलती है जो आपको बताती है कि फ़ंक्शन परिभाषा क्या है, तो आप कैसे जानते हैं कि उस परिभाषा में string अशक्त या अशक्त है?

@ ग्रिफोर्क

• फिर से 'use strict' साथ ऐसा ही है।
• कम से कम विचार सरल है। और टाइप सिस्टम में सरल अवधारणा का परिचय दें।
• यदि कोई डेवलपर किसी अन्य फ़ाइल में किसी फ़ंक्शन को स्थानांतरित करता है तो मेरे लिए एक बहुत ही बढ़िया मामला लगता है, और चूंकि उसे त्रुटि का संकेत दिया जाएगा, वह शून्य जांच के बारे में होगा, वह जल्दी से समझ पाएगा कि क्या हो रहा है ...

फिर से यह सही नहीं है, लेकिन मुझे कोई बेहतर विकल्प नहीं दिख रहा है।

बस स्पष्ट होने के लिए, मैंने जो प्रस्तावित किया है (प्रतिवाद के बाद) जो मैं देख सकता हूं, उसके साथ आपकी एकमात्र समस्याएं हैं:

• हम नहीं जानते कि var mystring = "string" लिए व्यवहार क्या होगा
• आप हर जगह प्रतीकों को टाइप नहीं करना चाहते हैं।

और निर्देश के साथ मेरी चिंताएं हैं:

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

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

संपादित करें: एक बिंदु स्पष्ट किया।
संपादित करें: स्ट्रिंग को उद्धरणों में रखें

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

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

मैं इस तथ्य को चाहता हूं कि string वास्तव में string | null | undefined बिना आपको इसे जांचने के लिए मजबूर किए, स्पष्ट।

डेवलपर्स के लिए यह ट्रैक करना कठिन होगा कि वे जो लिख रहे हैं वह अशक्त है या अशक्त नहीं है।

मुझे संदेह है कि परियोजना में 'गैर-शून्य' का उपयोग किए बिना एक परियोजना में एक फ़ाइल होगी यदि परियोजना गैर-शून्यता का उपयोग करती है, और आपकी फ़ाइल पर शीर्ष पर स्क्रॉल करना इतना कठिन नहीं है (कम से कम जब आप कोड की 500 से कम पंक्तियों के साथ फ़ाइल लिखते हैं जो बहुसंख्यक मामला है ...)

जब आप किसी फ़ंक्शन का आह्वान करते हैं तो आप जो फ़ंक्शन परिभाषा देखते हैं वह अशक्त हो सकती है या नहीं भी हो सकती है और आप बताने में सक्षम नहीं होंगे।

हाँ, यदि यह एक ऐसे मॉड्यूल से आता है जिसमें निर्देश होता है कि 'गैर-शून्य का उपयोग करें' चीज़ तदनुसार टाइप की जाएगी, यदि आप सब कुछ अशक्त नहीं मानते हैं ...

एक बार जब कोई फ़ंक्शन 2 या 3 परतों के माध्यम से लपेटा जाता है, तो आप नहीं जानते कि क्या इसकी परिभाषा अभी भी सही है (क्योंकि आप उन फ़ाइलों के माध्यम से टाइप-अनुमान का उपयोग नहीं कर सकते हैं जिनमें "नॉननल का उपयोग करें" नहीं है)।

मैं यहाँ आपकी बात समझ नहीं पा रहा हूँ।

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

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

और मैं यह नहीं देख सकता कि डेवलपर्स को उनके इरादों के बारे में स्पष्ट होने के लिए मजबूर करने से निर्देश बेहतर क्यों है

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

मेरे दृष्टिकोण से यहाँ 3 व्यवहार्य समाधान हैं:

• 2.0 के लिए ब्रेकिंग परिवर्तन जहां प्रकार गैर-शून्य हो जाते हैं
• कंपाइलर ध्वज जो डिफ़ॉल्ट रूप से गैर-शून्य प्रकार पर स्विच करता है जैसे मैंने कुछ दर्जन टिप्पणियों का प्रस्ताव दिया था, लेकिन @RyanCavanaugh के बारे में एक अच्छी बात थी। (घटना अगर मैं ईमानदारी से सोचता हूं कि यह इसके लायक है)
• 'गैर-शून्य' निर्देश का उपयोग करें

वैसे, झंडा मेरे लिए पूरी तरह से इसके लायक होगा।

function fn(x: string): number;
function fn(x: number|null): string;

function foo() {
    return fn(null);
}

var x = foo(); // x: number or x: string?

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

1. string|null|undefined मेरे प्रस्ताव में ध्वज का उपयोग करते हुए स्पष्ट था, इसलिए मैंने इसे छोड़ दिया।
2. फिर प्रति फ़ाइल क्यों है? मैं अपने सुझाव का सुझाव दे रहा हूं क्योंकि यह _पिछली संगतता को नहीं तोड़ता_ जो मेरे लिए महत्वपूर्ण है, और शायद बहुत से अन्य देव। और यह परियोजना चौड़ा होने के लिए मजबूर किया जा सकता है।
3. मैं बहुत सी फाइलों का उपयोग करता हूं जो मैं नहीं बनाता; मुझे कैसे पता चलेगा कि उस विशेष फ़ाइल में "नॉननल का उपयोग करें" है? अगर मेरे पास अन्य लोगों द्वारा बनाई गई 100 फाइलें हैं, तो मुझे याद रखना होगा कि उन 100 फाइलों में से कौन-सी अशक्त है? (या, _हर बार_ मैं किसी अन्य फ़ाइल से एक चर/फ़ंक्शन का उपयोग करता हूं, मुझे उस फ़ाइल को खोलना होगा और उसे जांचना होगा?)
4. आइए देखें कि क्या मैं इसे स्पष्ट कर सकता हूं: उदाहरण पोस्ट के अंत में।
5. तुम कहाँ रुकते हो? आप इसे कहाँ बुरा कहते हैं? फ़ाइल की शुरुआत में एक स्ट्रिंग या कीवर्ड को फ़ाइल के व्यवहार करने के तरीके को नहीं बदलना चाहिए। "सख्त उपयोग करें" जावास्क्रिप्ट में जोड़ा गया था क्योंकि
   
   
   
   1. उस समय जावास्क्रिप्ट का कोई बड़ा सुपर-सेट (जैसे टाइपस्क्रिप्ट) मौजूद नहीं था जो वह कर सकता था जो वह चाहता था।
   
   
   2. यह जावास्क्रिप्ट के प्रसंस्करण को
      
      "यूज़ स्ट्रिक्ट" को _नहीं अपनाया गया क्योंकि यह करना सही था_ लेकिन क्योंकि यह एकमात्र तरीका था जिससे ब्राउज़र डेवलपर्स की मांगों को पूरा कर सकते थे। मुझे टाइपस्क्रिप्ट को 1 (फिर 2, फिर 3 फिर 4) जोड़ने से नफरत होगी, अन्य निर्देश जो _मौलिक रूप से भाषा के काम करने के तरीके को बदलते हैं_ कुछ मनमाने दायरे में घोषित किए गए तार के रूप में, और कुछ अन्य मनमानी क्षेत्रों को प्रभावित करते हैं। यह वास्तव में खराब भाषा डिजाइन है। मुझे खुशी होगी अगर टाइपस्क्रिप्ट में "सख्त का उपयोग करें" मौजूद नहीं था, और इसके बजाय एक कंपाइलर ध्वज था (और टाइपस्क्रिप्ट ने इसे प्रत्येक फ़ाइल/स्कोप में उत्सर्जित किया जिसकी आवश्यकता थी)।
   
   
6. जावास्क्रिप्ट एक "गैर-शून्य प्रकार प्रणाली" नहीं है, टाइपस्क्रिप्ट एक "गैर-शून्य प्रकार प्रणाली" नहीं है। गैर-शून्य प्रकार घोषित करने की क्षमता का परिचय देने का मतलब यह नहीं है कि पूरी प्रणाली "गैर-शून्य" है। यह टाइपप्रति की बात नहीं है।

File 1:
"use notnull"
export string foo() {
    return "mygeneratedstring";
}
File 2:
export string foo() {
    return file1.foo()
}
File 3:
"use notnull"
file2.foo(); //???

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

ऐसा लगता है कि हम हलकों में बहस कर रहे हैं। अगर मैं आपको समझ नहीं पा रहा हूं तो मुझे खेद है, लेकिन ऐसा लगता है कि आप एक ही मुद्दे को बार-बार उठा रहे हैं, और मैं उन्हें बार-बार जवाब दे रहा हूं।

@spion
उस उदाहरण में स्ट्रिंग एक निहित शून्य नहीं है (मेरा मानना ​​​​है कि यह मानता है कि --noImplicitNull ध्वज चालू है)

स्ट्रिंग | नल | अपरिभाषित मेरे प्रस्ताव में ध्वज का उपयोग करके स्पष्ट था, इसलिए मैंने इसे छोड़ दिया

मेरा मतलब यह है कि वास्तविक प्रणाली में var myString: string परोक्ष रूप से var myString: (string | null | undefined); और इसके शीर्ष पर संकलक आपको टाइपगार्ड का उपयोग करने के लिए मजबूर नहीं करता है जब तक कि अन्य सभी यूनियन प्रकार न हों।

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

मैं बहुत सी फाइलों का उपयोग करता हूं जो मैं नहीं बनाता; मुझे कैसे पता चलेगा कि उस विशेष फ़ाइल में "नॉननल का उपयोग करें" है? अगर मेरे पास अन्य लोगों द्वारा बनाई गई 100 फाइलें हैं, तो मुझे याद रखना होगा कि उन 100 फाइलों में से कौन-सी अशक्त है? (या, हर बार जब मैं किसी अन्य फ़ाइल से एक चर/फ़ंक्शन का उपयोग करता हूं, तो मुझे उस फ़ाइल को खोलना होगा और इसे जांचना होगा?)

यदि आप किसी प्रोजेक्ट में दिशा-निर्देश आदि के साथ हैं जैसे कि हर प्रोजेक्ट सामान्य रूप से व्यवस्थित होता है तो आप जानते हैं ... सबसे खराब स्थिति में आपको बस थोड़ा स्क्रॉल करना होगा ... इतना कठिन नहीं लगता ...

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

भाषा व्यवहार को बदलने और रेट्रो संगतता बनाए रखने के लिए 'सख्त का उपयोग करें' पेश किया गया था, ठीक वही समस्या जो हम अभी सामना कर रहे हैं, और कमोबेश es6 मॉड्यूल के साथ गायब हो जाएंगे (और इसलिए टाइपस्क्रिप्ट के अगले प्रमुख संस्करण के साथ शून्य का उपयोग गायब नहीं हो सकता है) .

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

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

आपके उदाहरण के लिए हाँ हमने फाइलों के बीच कुछ जानकारी खो दी है, यह मेरे लिए स्वीकार्य ट्रेडऑफ है लेकिन मैं आपकी चिंता को समझ सकता हूं।

ऐसा लगता है कि हम हलकों में बहस कर रहे हैं। अगर मैं आपको समझ नहीं पा रहा हूं तो मुझे खेद है, लेकिन ऐसा लगता है कि आप एक ही मुद्दे को बार-बार उठा रहे हैं, और मैं उन्हें बार-बार जवाब दे रहा हूं।

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

@ ग्रिफोर्क जिस तरह से मुझे लगता है कि @spion विचार काम करता है, विचार यह कहना है कि ध्वज के बिना string एक निहित शून्य number | null हमेशा पहले अधिभार पर व्यापकता लेता है, इसलिए दोनों में मामला foo(null) होगा string ।

@RyanCavanaugh क्या आपको लगता है कि यह काम कर सकता है?

@fdecampredon

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

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

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

मुझे प्रति-फ़ाइल निर्देश के बजाय प्रतीकों (मेरे सुझाव के अनुसार) का उपयोग करने का विचार पसंद है, क्योंकि उनमें प्रासंगिक नुकसान के बिना प्रचार करने की क्षमता है।

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

@fdecampredon

चर्चा के लिए धन्यवाद यह था

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

तो समस्या के मेरे प्रस्तावित समाधान के बारे में विस्तार से बताने के लिए @RyanCavanaugh ने वर्णन किया है, अशक्त प्रकार और --noImplicitNull ध्वज को जोड़ने के बाद, ध्वज के बिना चलने पर टाइपचेकर का एक संशोधित व्यवहार होगा:

जब भी किसी प्रकार के अधिभार में |null (दिए गए उदाहरण की तरह) होता है:

function fn(x: string): number;
function fn(x: number|null): string;

टाइपचेकर प्रत्येक अधिभार लेगा और सूची के अंत में जोड़े गए उस तर्क स्थिति पर (अंतर्निहित) शून्य के साथ नए रूपों को बनायेगा:

function fn(x: string): number;
function fn(x: number|null): string;
// implicit signature added at the end, caused by the first overload
function fn(x: null): number;

इसका परिणाम सख्त --noImplicitNull संस्करण के समान व्याख्या के साथ होता है: जब एक शून्य पारित किया जाता है, तो पहला मिलान अधिभार स्पष्ट number|null । प्रभावी रूप से यह स्पष्ट नल को निहित लोगों की तुलना में मजबूत बनाता है।

(हां, मुझे पता है कि |null ओवरलोड वाले तर्कों की संख्या के साथ निहित परिभाषाओं की संख्या तेजी से बढ़ती है - मुझे उम्मीद है कि एक तेज़ कार्यान्वयन है जो दूसरे पास पर "अनुमति देता है" यदि कोई अन्य प्रकार नहीं है मैच, लेकिन मुझे नहीं लगता कि यह किसी भी तरह से कोई समस्या होगी क्योंकि मुझे उम्मीद है कि यह स्थिति दुर्लभ होगी)

इस तरह तैयार किया गया मुझे लगता है कि परिवर्तन पूरी तरह से पिछड़ा-संगत और ऑप्ट-इन होगा।

यहाँ बाकी व्यवहार के बारे में कुछ और विचार दिए गए हैं:

ध्वज को पारित नहीं होने पर किसी भी प्रकार के मूल्यों के लिए अशक्त या अप्रारंभीकृत मूल्यों को छोड़ने की भी अनुमति दी जाएगी।

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

• कंस्ट्रक्टर के अंत तक इनिशियलाइज़ करने की आवश्यकता है, या
• इनिशियलाइज़ेशन को यह जाँच कर ट्रैक किया जा सकता है कि क्या सदस्य विधियाँ जो उन्हें पूरी तरह से इनिशियलाइज़ करती हैं, उन्हें बुलाया गया था।

स्पष्ट अशक्त संघ दोनों मोड में अन्य सभी यूनियनों के समान व्यवहार करेंगे। संघ के प्रकार को कम करने के लिए उन्हें एक गार्ड की आवश्यकता होगी।

मैंने अभी ऊपर _all_ कमेंट्स पढ़े हैं और यह बहुत कुछ है। यह निराशाजनक है कि इतनी सारी टिप्पणियों और 5 महीनों के बाद, हम अभी भी उन्हीं बिंदुओं पर बहस कर रहे हैं: वाक्य रचना और झंडे...

मुझे लगता है कि कई लोगों ने बड़े कोडबेस में कंपाइलर द्वारा स्टैटिक नल चेकिंग के मूल्य के लिए मजबूत तर्क दिए हैं। मैं और कुछ नहीं कहूंगा (लेकिन +1)।

अब तक मुख्य बहस मौजूदा TS कोड और TS लाइब्रेरी परिभाषाओं के टन के साथ सिंटैक्स और संगतता मुद्दे के बारे में रही है। मैं देख सकता हूं कि क्यों एक अशक्त प्रकार और फ्लो सिंटैक्स ?string सबसे साफ और सबसे प्राकृतिक लगता है। लेकिन यह string का अर्थ बदल देता है और इसलिए _all_ मौजूदा कोड के लिए एक _विशाल_ ब्रेकिंग परिवर्तन है।

इस ब्रेकिंग परिवर्तन के लिए ऊपर प्रस्तावित समाधान संकलक झंडे पेश करना है ( @RyanCavanaugh ने एक बहुत अच्छा बिंदु बनाया है कि यह एक भयानक विचार क्यों है) या प्रति-फ़ाइल निर्देश। यह एक बहुत ही हैकिश स्टॉप-गैप उपाय की तरह लगता है। इसके अलावा मैं एक अलग समीक्षा या विशाल फ़ाइल के बीच में कोड पढ़ने से नफरत करता हूं और मैं जिस कोड को देख रहा हूं उसका अर्थ तुरंत जानने में सक्षम नहीं हूं। 'use strict'; को एक उदाहरण के रूप में उद्धृत किया गया था। ऐसा इसलिए नहीं है क्योंकि TS को JS की पिछली गलतियाँ विरासत में मिली हैं, इसलिए हमें उन्हें दोहराना चाहिए।

इसलिए मुझे लगता है कि "नॉट नल" एनोटेशन ( string! , !string , ...) जाने का एकमात्र तरीका है और मैं चर्चा में एक नया तर्क पेश करने की कोशिश करूंगा: शायद यह है इतना बुरा नहीं।

कोई भी पूरे कोड में बैंग्स ( ! ) नहीं चाहता है। लेकिन हमें शायद नहीं करना है। TS टाइपिंग के बारे में बहुत कुछ बताता है।

1. स्थानीय चर
मैं अपने स्थानीय चरों को बैंग्स के साथ एनोटेट करने की उम्मीद नहीं करता। मुझे परवाह नहीं है अगर मैं स्थानीय चर के लिए null असाइन करता हूं, जब तक कि मैं इसे सुरक्षित तरीके से उपयोग करता हूं, जो टीएस जोर देने में पूरी तरह सक्षम है।

var x: string;  // Nullable
x.toString();  // Error: x can be undefined or null
x = "jods";
x.toUpperCase();  // Fine.
notNull(x);  // Fine

अक्सर मैं एक प्रकार के बजाय प्रारंभकर्ता का उपयोग करता हूं।

var x = "jods";  // x: string (nullable)
notNull(x);  // Fine
x = null;  // Fine
notNull(x);  // Error

2. फ़ंक्शन वापसी मान
बहुत बार मैं वापसी मूल्य निर्दिष्ट नहीं करता। जैसे ही TS प्रकार का अनुमान लगाता है, यह अनुमान लगा सकता है कि अशक्त है या नहीं।

function() /* : string! */ {
  return "jods";
}

संपादित करें: विरासत और फ़ंक्शन चर के कारण बुरा विचार, नीचे @Griffork द्वारा टिप्पणी देखें
घटना अगर मैं एक वापसी प्रकार देता हूं, तो टीएस मेरे लिए "शून्य नहीं" एनोटेशन जोड़ने में पूरी तरह सक्षम है।

यदि आप अनुमानित शून्यता को ओवरराइड करना चाहते हैं (उदाहरण के लिए क्योंकि एक व्युत्पन्न वर्ग शून्य हो सकता है, हालांकि आपकी विधि नहीं है), तो आप स्पष्ट रूप से प्रकार निर्दिष्ट करते हैं:

function f() : string {  // f is nullable although this implementation never returns null.
  return "abc";
}

3. फ़ंक्शन पैरामीटर
जैसे आपको स्पष्ट रूप से एक प्रकार निर्दिष्ट करना होता है, वहीं आप _हैव टू_ इंगित करते हैं कि क्या आप नल पैरामीटर स्वीकार नहीं करते हैं:

function (x: string!) { return x.toUpperCase(); } // OK
function (x: string) { return x.toUpperCase(); } // Error

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

4. वर्ग क्षेत्र
यह 3 के समान है। यदि आपको किसी फ़ील्ड को उसकी सामग्री का अनुमान लगाने में सक्षम किए बिना पढ़ने की आवश्यकता है, तो आपको घोषणा पर इसे गैर-शून्य के रूप में चिह्नित करना होगा।

class C {  x: string!; }

function(c: C!) // : string! is inferred
{ return c.x; } // OK, but annotations are required

हम इनिशियलाइज़र के लिए शॉर्टहैंड की कल्पना कर सकते हैं, हो सकता है:

class C {
  x! = "jods"; // Note the bang: x is inferred as !string rather than just string.
}

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

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

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

var a: { s: string } = something(); // Notice s is nullable.
notNull(a.s); // Error
notNull(<!>a.s);  // OK, this is a shorthand "not-null" cast, because the dev knows about something().

मुझे लगता है कि संकलक को संकेत देने की क्षमता - एक सरल तरीके से - कि कुछ अशक्त नहीं है वांछनीय है। यह डिफ़ॉल्ट रूप से नॉट-नल के लिए भी सही है, हालांकि सरल, तार्किक सिंटैक्स के साथ आना कठिन है।

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

आपने जो कुछ कहा @jods4 में से अधिकांश से मैं सहमत हूं लेकिन मेरे कुछ प्रश्न और चिंताएं हैं:

2) यदि संकलक स्वचालित रूप से वापसी प्रकारों पर अशक्त को गैर अशक्त में परिवर्तित कर सकता है, तो आप इसे कैसे ओवरराइड कर सकते हैं (उदाहरण के लिए विरासत या कार्यों को प्रतिस्थापित करने के लिए)?

3 और 5) यदि संकलक अशक्त को गैर अशक्त में परिवर्तित कर सकता है तो एक कोड फ़ाइल में एक फ़ंक्शन हस्ताक्षर अब एक d.ts फ़ाइल में एक ही फ़ंक्शन हस्ताक्षर के लिए अलग तरह से व्यवहार कर सकता है।

6) यूनियन प्रकारों का उपयोग करते समय बैंग कैसे काम करता है/दिखता है?

2) अच्छी पकड़। मुझे नहीं लगता कि यह वास्तव में विरासत (या 'प्रतिनिधि') के साथ अच्छा काम करेगा।
जहां मैं टीएस के साथ अपना अनुभव काम करता हूं वह यह है कि हम लगभग कभी भी कार्यों से वापसी मूल्यों को स्पष्ट रूप से टाइप नहीं करते हैं। टीएस उन्हें समझता है और मुझे लगता है कि टीएस शून्य/शून्य भाग को समझ सकता है।

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

आइए ऊपर दिए गए मेरे प्रस्ताव को बदलें: एक स्पष्ट रूप से टाइप किया गया वापसी मूल्य _not_ अनुमानित नहीं है यदि इसे घोषित नहीं किया गया है। यह आपके द्वारा सुझाए गए मामलों के लिए अच्छा काम करता है। यह एक अनुबंध पर "शून्य नहीं" का उल्लेख करने वाले कंपाइलर को ओवरराइड करने का एक तरीका प्रदान करता है जो बाल वर्गों में शून्य हो सकता है।

3 और 5) उपरोक्त परिवर्तन के साथ, अब ऐसा नहीं है, है ना? कोड और परिभाषाओं में कार्य हस्ताक्षर अब ठीक उसी तरह व्यवहार करते हैं।

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

var x: number | string!; // compiler error
var x: number | string; // x can be null
var x: number! | string!; // x cannot be null
function f<T>() : number | T; // f can be null
function f<T>() : number! | T; // f is nullable if T is nullable
function f<T, G>(): T | G; // f is nullable if T or G is nullable
function f<T>(): T | null; // f is nullable even if T is not nullable.
function f<T>(): T!; // Whatever T is, f never returns null.

// Generics constraint option 1
function f<T!>(x: T!, y: T): T!; // T: not nullable type, x: not-null, y: null, f: not-null
function f<T!>(x: T!, y: T): T;  // T: not nullable type, x: not-null, y: null, f: null

// Generics constraint option 2
function f<T!>(x: T, y: T | null): T; // same as option 1.1
function f<T!>(x: T, y: T | null): T | null;  // same as option 1.2

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

टाइप अक्षर ठीक हैं लेकिन बहुत संतोषजनक नहीं हैं: var x: { name: string }! , खासकर यदि वे एक से अधिक पंक्तियों को फैलाना चाहते हैं :(

और ज्यादा उदाहरण:
अशक्त संख्याओं की सरणी number![]
संख्याओं की शून्य सरणी नहीं: number[]!
कुछ भी खाली नहीं हो सकता: number![]!
जेनरिक: Array<number!>[]

2, 3 और 5) मैं प्रस्ताव में बदलाव से सहमत हूं, ऐसा लगता है कि यह काम करेगा।
6)

function f<T>() : number | T; // f can be null
function f<T>() : number! | T; // f is nullable if T is nullable

मुझे लगता है कि यहाँ आपका मतलब है कि f अशक्त लौट सकता है, न कि f को अशक्त करने के लिए असाइन किया जा सकता है।

यूनियनों के लिए, आप निम्नलिखित सिंटैक्स के बारे में क्या सोचते हैं जो एक अन्य उपलब्ध विकल्प है? (थोड़ा मूर्खतापूर्ण लगता है, लेकिन कुछ मामलों में पालन करने में अधिक संक्षिप्त/आसान हो सकता है)।

var x = ! & number | string;

यह इंगित करने के लिए कि न तो अशक्त हैं।

टाइप लिटरल्स के लिए मैं कहूंगा कि आप शाब्दिक अभिव्यक्ति की शुरुआत के साथ-साथ अंत में भी धमाका कर सकते हैं, जैसा कि var x: !{name: string} , अंत में होने की तुलना में मेरी राय में काम करना आसान होगा।

@ jods4 क्या आपने मेरे "स्पष्ट नल की निहित नल पर प्राथमिकता" प्रस्तावित फिक्स के बारे में पढ़ा है? मुझे लगता है कि अलग-अलग अर्थशास्त्र मुद्दे का ख्याल रखता है।

@ ग्रिफोर्क
हां, "शून्य है" "शून्य वापस आ सकता है" के लिए खराब शब्द था।

जो मुझे लगता है कि function f() {} वास्तव में f की घोषणा है, जिसे बाद में सेट किया जा सकता है ... क्या हम यह व्यक्त करना चाहते हैं कि f कभी भी शून्य पर सेट नहीं होगा ? function f!() {} ? ऐसा लगता है कि मेरी राय में यह बहुत दूर जा रहा है। मुझे लगता है कि टाइपचेकर को यह मान लेना चाहिए कि हमेशा ऐसा ही होता है। अन्य असामान्य किनारे के मामले हैं जिन्हें यह वैसे भी संभाल नहीं सकता है।

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

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

class C {
  name! = "jods";  // Field inferred string, but marked not nullable.
  // Maybe we could do that instead, which works with "!T" convention:
  name : ! = "jods";
  // That kind of make sense with the proposed <!> cast.
}

@spion
हाँ मैंने देखा है।

सबसे पहले मुझे यकीन नहीं है कि यह वास्तव में इस मुद्दे को हल करता है। तो आपकी नई परिभाषा के साथ जो अधिभार fn(null) ? वह 'जेनरेट' जो number लौटाता है? क्या यह इस तथ्य से असंगत नहीं है कि दूसरा ओवरलोड भी null स्वीकार करता है लेकिन string ? या यह एक कंपाइलर त्रुटि है क्योंकि आप ओवरलोड रिज़ॉल्यूशन नहीं कर सकते हैं?

दूसरा, मुझे पूरा यकीन है कि हम कई अन्य मुद्दों के साथ आ सकते हैं। मुझे लगता है कि स्विच के फ्लिप पर सोर्स कोड का वैश्विक अर्थ बदलना सिर्फ काम नहीं कर सकता है। न केवल .d.ts , बल्कि लोग कोड का पुन: उपयोग करना पसंद करते हैं (लाइब्रेरी का पुन: उपयोग या यहां तक ​​कि कॉपी-पेस्ट करना)। आपका सुझाव यह है कि मेरे स्रोत कोड का अर्थपूर्ण अर्थ संकलक ध्वज पर निर्भर करता है और यह मेरे लिए एक बहुत ही त्रुटिपूर्ण प्रस्ताव है।

लेकिन अगर आप यह साबित कर सकते हैं कि कोड संकलित होगा और सभी मामलों में सही ढंग से चलेगा, तो मैं इसके लिए तैयार हूं!

@jods4

दोनों ही मामलों में दूसरा अधिभार इस्तेमाल किया जाएगा

function fn(x: string): number;
function fn(x: number|null): string; 

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

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

@spion
तो अंतर्निहित function fn(x: null): number; साथ क्या मामला था? यदि दूसरा अधिभार हमेशा प्राथमिकता लेता है, तो कोई फर्क नहीं पड़ता कि किस ध्वज का उपयोग किया जाता है, इस पूरे "फिक्स" का कोई प्रभाव नहीं पड़ता है?

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

// null by default flag turned on because of 3rd party libs.
function (x: string)   // <- how do I declare this not null?
{ return x.toUpperCase(); }

फिक्स का असर जरूर होता है। यह ध्वज के साथ और उसके बिना व्यवहार को सुसंगत बनाता है, जो ऊपर वर्णित अर्थ संबंधी समस्या को ठीक करता है।

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

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

declare function wordCount(s: string): number;

मान लें कि आपका कोड इस तरह से इस फ़ंक्शन का उपयोग करता है:

function sumWordcounts(s1:string, s2:string) {
  return wordCount(s1) + wordCount(s2);
}

यह प्रोग्राम दोनों कंपाइलरों के अंतर्गत आता है: भले ही निहित नल अक्षम हों। कोड पूरी तरह से पिछड़ा संगत है।

क्यों? क्योंकि आज के रूप में संकलक को पहले से ही यह विश्वास है कि मूल्य हर जगह शून्य नहीं हैं जहां आप उनका उपयोग करने का प्रयास करते हैं (भले ही वे सैद्धांतिक रूप से शून्य हो सकते हैं)।

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

अब wordCount . के कार्यान्वयन को देखते हैं

function wordCount(s) {
  if (s == '') return null;
  return s.split(' ').length
}

ओह, यह प्रकार पूरी कहानी नहीं बताता है। उस फ़ंक्शन के लिए एक शून्य मान वापस करना संभव है।

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

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

हालाँकि अब हम बेहतर करने में सक्षम होंगे: हम वर्डकाउंट के लिए एक बेहतर प्रकार की परिभाषा लिखने में सक्षम होंगे:

declare function wordCount(s:string):string|null;

और जब भी हम शून्य वापसी मूल्य की जांच किए बिना wordCount का उपयोग करने का प्रयास करते हैं तो एक कंपाइलर चेतावनी प्राप्त करें।

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

(1): टाइप परिभाषा को बेहतर बनाए बिना भी यहाँ पहले से ही एक सुधार है। नई प्रकार की परिभाषाओं के साथ, जब आप wordCount फ़ंक्शन .split() को शून्य करने का प्रयास करते हैं, तो आप गलती से sumWordcounts शून्य पास नहीं कर पाएंगे और एक शून्य सूचक अपवाद प्राप्त नहीं कर पाएंगे।

sumWordcounts(null, 'a'); // error after the change

(2): ठीक है, यह झूठ है। प्रकार की घोषणाएं कार्यों के एक छोटे उपसमुच्चय के लिए बदतर हो जाएंगी: वे जो निरर्थक तर्क लेते हैं जो वैकल्पिक तर्क नहीं हैं।

वैकल्पिक तर्कों के लिए चीजें अभी भी ठीक रहेंगी:

declare function f(a: string, b?:string); 

लेकिन उन तर्कों के लिए नहीं जो वैकल्पिक नहीं हैं और अशक्त हो सकते हैं

declare function f(a: string, b:string); // a can actually be null

मेरा तर्क है कि वे कार्य बहुत दुर्लभ हैं, और आवश्यक सुधार न्यूनतम होंगे।

@spion

फिक्स का असर जरूर होता है। यह ध्वज के साथ और उसके बिना व्यवहार को सुसंगत बनाता है।

आप किस तरह से एक पूरा उदाहरण दे सकते हैं? आपने यह भी कहा:

दोनों ही मामलों में दूसरा अधिभार इस्तेमाल किया जाएगा

मेरे लिए, जिसका अर्थ है कि फिक्स का कोई प्रभाव नहीं है?

यह प्रोग्राम दोनों कंपाइलरों के अंतर्गत आता है: भले ही निहित नल अक्षम हों। कोड पूरी तरह से पिछड़ा संगत है।

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

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

नहीं! यह पूरा बिंदु है: मैं चाहता हूं कि जब मैं संभावित रूप से शून्य मान का उपयोग करता हूं तो संकलक मुझ पर त्रुटि फेंक देता है। यदि यह "मानता है" शून्य नहीं है जैसा कि मैं कोड करते समय करता हूं, तो यह सुविधा बेकार है!

व्यवहार में परिवर्तन केवल तभी प्रभावी होता है जब अशक्त (या अप्रारंभीकृत चर छोड़कर) निर्दिष्ट किया जाता है और फिर उन मानों को उपरोक्त जैसे फ़ंक्शन में पास करने का प्रयास किया जाता है।

मुझे यकीन नहीं है कि मैं समझता हूं, "उपरोक्त की तरह कार्य" वास्तव में नल स्वीकार करता है ...

आपकी अंतिम टिप्पणी के अंत को पढ़कर, मुझे यह आभास होता है कि जब तक हम स्विच चालू नहीं करते, तब तक हमें वास्तविक स्थैतिक शून्य विश्लेषण नहीं मिलेगा, जिसे आप तब तक नहीं कर सकते जब तक कि _all_ आपकी लाइब्रेरी की परिभाषाएं तय नहीं हो जातीं। :(

आम तौर पर सभी मामलों को पूरी तरह से समझना मुश्किल है और कैसे सब कुछ सिर्फ शब्दों के साथ काम करता है। कुछ व्यावहारिक उदाहरण बहुत मददगार होंगे।

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

फ़ंक्शन yes(): string! साथ एक पुस्तकालय मान लें जो कभी भी शून्य नहीं लौटाता है और no(): string? जो शून्य हो सकता है।

.d.ts परिभाषा है:

declare function yes(): string;
declare function no(): string;

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

ऊपर प्रस्तावित अशक्त संशोधक ! का उपयोग करके, मैं ऐसा करने में सक्षम हूं:

function x(s: string!) {  // inferred : string, could be explicit if we want to
  return s.length === 0 ? null : s;  // no error here as s is declared not null
}

x(no());  // error: x called with a possibly null parameter
y(<!>yes());  // no error because of not null cast. When .d.ts is updated the cast can be dropped.

यह आपके विचार के साथ कैसे काम करेगा?

यह धागा एक बहुत लंबी चर्चा (130 टिप्पणियाँ!)

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

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

यहां !T नॉट-नल मार्कर का सार दिया गया है:
https://gist.github.com/jods4/cb31547f972f8c6bbc8b

यह ज्यादातर मेरी टिप्पणी के समान ही है, निम्नलिखित अंतरों के साथ:

• मैंने देखा कि फ़ंक्शन पैरामीटर के ' नॉट -नल' पहलू को कंपाइलर द्वारा सुरक्षित रूप से अनुमान लगाया जा सकता है (उस अंतर्दृष्टि के लिए
• मैंने @Griffork टिप्पणियों को शामिल किया, विशेष रूप से वापसी मूल्यों का उल्लेख करने के बारे में और मैंने !T बजाय T! ।
• मैंने कुछ खंड जोड़े, उदाहरण के लिए कंस्ट्रक्टर व्यवहार के बारे में।

बेझिझक टिप्पणी करें, फोर्क करें और वैकल्पिक प्रस्ताव बनाएं ( ?T )।
आइए इसे आगे बढ़ाने की कोशिश करते हैं।

@jods4

दोनों ही मामलों में दूसरा अधिभार इस्तेमाल किया जाएगा

मेरे लिए, जिसका अर्थ है कि फिक्स का कोई प्रभाव नहीं है?

1. इसका तात्पर्य है कि दोनों झंडों के लिए भाषा शब्दार्थ को सुसंगत बनाने के लिए अधिभार संकल्प को बदल दिया गया है।

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

1. मेरे प्रस्ताव में कोई number! है। दोनों ही मामलों में प्रकार केवल number । जिसका अर्थ है कि ओवरलोड रिज़ॉल्यूशन सामान्य रूप से काम करना जारी रखता है, शून्य मानों को छोड़कर, इस मामले में स्पष्ट नल के लिए नया व्यवहार अंतर्निहित पर प्राथमिकता लेता है जो पिछड़े-संगत तरीके से अर्थशास्त्र को सामान्यीकृत करता है।

नहीं! यह पूरा बिंदु है: मैं चाहता हूं कि जब मैं संभावित रूप से शून्य मान का उपयोग करता हूं तो संकलक मुझ पर त्रुटि फेंक देता है। यदि यह "मानता है" शून्य नहीं है जैसा कि मैं कोड करते समय करता हूं, तो यह सुविधा बेकार है!

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

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

मुझे यकीन नहीं है कि मैं समझता हूं, "उपरोक्त की तरह कार्य" वास्तव में नल स्वीकार करता है ...

आइए इस फ़ंक्शन पर एक नज़र डालें:

function sumWordcounts(s1:string, s2:string) {
  return wordCount(s1) + wordCount(s2);
}

नए कंपाइलर ध्वज के तहत आप इसे शून्य मानों जैसे sumWordCounts(null, null); साथ कॉल करने में सक्षम नहीं होंगे और यही एकमात्र अंतर है। फ़ंक्शन स्वयं संकलित होगा क्योंकि wordCounts की परिभाषा कहती है कि यह एक स्ट्रिंग लेता है और एक संख्या देता है।

आपकी अंतिम टिप्पणी के अंत को पढ़ते हुए, मुझे यह आभास होता है कि जब तक हम स्विच को चालू नहीं करते, तब तक हमें वास्तविक स्थैतिक शून्य विश्लेषण नहीं मिलेगा, जिसे आप तब तक नहीं कर सकते जब तक कि आपकी सभी लाइब्रेरी परिभाषाएँ तय नहीं हो जातीं। :(

कोड का एक विशाल बहुमत वास्तव में नल या अपरिभाषित मानों से निपटता नहीं है, यह जांचने के अलावा कि वे शून्य/अपरिभाषित हैं और कोडबेस में उस मान के प्रसार को पूरी तरह से असंबंधित स्थान पर रोकने के लिए एक त्रुटि फेंक रहे हैं, जिससे यह कठिन हो जाता है डिबग करने के लिए। वैकल्पिक तर्कों का उपयोग करते हुए यहां और वहां कुछ कार्य हैं, जो पहचानने योग्य हैं और संभवतः नए स्विच के अनुसार मॉडलिंग की जा सकती है। ऐसा नहीं है कि अक्सर कार्य मेरे उदाहरण की तरह शून्य मान लौटाते हैं (जिसका उपयोग मैंने केवल सुविधा के बारे में एक बिंदु बनाने के लिए किया था, प्रतिनिधि मामले के रूप में नहीं)

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

ठीक है, तो मौजूदा प्रकार की परिभाषाएं हैं

declare function yes(): string;
declare function no(): string;

और मान लें कि फीचर जोड़ने से पहले आपका कोड भी लिखा गया था:

function x(s: string) {
  return s.length === 0 ? null : s;
}

नए कंपाइलर के तहत, व्यवहार बिल्कुल पुराने जैसा ही होगा

x(no());  // no error
x(yes());  // no error

जब तक आप कुछ ऐसा करने की कोशिश नहीं करते हैं जो संकलक जानता है कि x() के परिणाम की तरह शून्य हो सकता है

x(x(no())) // error, x(something) may be null

आप no() और आप या तो यह तय कर सकते हैं कि जिन मामलों में यह शून्य लौटाता है वे दुर्लभ हैं इसलिए आप इसे मॉडल नहीं करने जा रहे हैं, या आप प्रकार की परिभाषा को ठीक कर सकते हैं।

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

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

जब हम T प्रकार के कुछ चर के लिए शून्य असाइन करने का प्रयास करते हैं, या शून्य को एक तर्क के रूप में पास करते हैं जहां एक प्रकार T की आवश्यकता होती है, तो यह कार्य करता है जैसे कि प्रकार T|null ।

जब हम T प्रकार के मान का उपयोग करने का प्रयास करते हैं, तो यह कार्य करता है जैसे कि प्रकार T और शून्य की कोई संभावना नहीं है।

आपका प्रस्ताव सभी सामान्य प्रकारों T को हमेशा T|null रूप में मानने का सुझाव देता है; मेरा सुझाव है कि उन्हें केवल T । दोनों शब्दार्थ बदलते हैं। दोनों संकलक को "सही ढंग से" व्यवहार करते हैं

मेरा तर्क यह है कि "सिर्फ T " वैरिएंट जितना दिखता है उससे कहीं कम दर्दनाक है और कोड के विशाल बहुमत के अनुरूप है।

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

@spion

1. इसका तात्पर्य है कि दोनों झंडों के लिए भाषा शब्दार्थ को सुसंगत बनाने के लिए अधिभार संकल्प को बदल दिया गया है।

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

1.मेरे प्रस्ताव में कोई number! है। दोनों ही मामलों में प्रकार केवल number ।

यह गलत है, मुझे पता है कि वाक्यविन्यास अलग है लेकिन अंतर्निहित अवधारणाएं समान हैं। जब मैं number! कहता हूं तो मैं एक गैर-शून्य संख्या प्रकार पर जोर दे रहा हूं, जो आपके प्रस्ताव में केवल number । और दूसरा मामला आपके मामले में number नहीं होगा, बल्कि number | null ।

कोड का एक विशाल बहुमत वास्तव में नल या अपरिभाषित मानों से निपटता नहीं है, यह जांचने के अलावा कि वे शून्य/अपरिभाषित हैं और कोडबेस में उस मान के प्रसार को पूरी तरह से असंबंधित स्थान पर रोकने के लिए एक त्रुटि फेंक रहे हैं, जिससे यह कठिन हो जाता है डिबग करने के लिए। वैकल्पिक तर्कों का उपयोग करते हुए यहां और वहां कुछ कार्य हैं, जो पहचानने योग्य हैं और संभवतः नए स्विच के अनुसार मॉडलिंग की जा सकती है। ऐसा नहीं है कि अक्सर कार्य मेरे उदाहरण की तरह शून्य मान लौटाते हैं (जिसका उपयोग मैंने केवल सुविधा के बारे में एक बिंदु बनाने के लिए किया था, प्रतिनिधि मामले के रूप में नहीं)

मुझे लगता है कि इस तरह के विवरण धारणाओं और शॉर्टकट के _lots_ बनाते हैं। इसलिए मुझे लगता है कि प्रगति करने के लिए हमें कोड, सिंटैक्स और सिस्टम के काम करने के तरीके के स्पष्टीकरण के साथ और अधिक ठोस उदाहरणों पर आगे बढ़ने की जरूरत है। आप बताओ:

कोड का एक विशाल बहुमत वास्तव में नल या अपरिभाषित मानों से निपटता नहीं है, यह जांचने के अलावा कि वे शून्य/अपरिभाषित हैं और एक त्रुटि फेंक रहे हैं

बहुत बहस योग्य।

वैकल्पिक तर्कों का उपयोग करते हुए यहां और वहां कुछ कार्य हैं।

और भी बहस योग्य। जेएस पुस्तकालय ऐसे उदाहरणों से भरे हुए हैं।

, जो पहचानने योग्य हैं और संभवतः नए स्विच के साथ तदनुसार मॉडलिंग की जा सकती हैं

अधिक ठोस प्रस्ताव बनाएं क्योंकि यह एक बहुत बड़ा शॉर्टकट है। मुझे लगता है कि मैं देख सकता हूं कि यह वास्तविक जेएस कोड के लिए कहां जा रहा है, लेकिन आप declare function(x: {}); अंदर या interface अंदर एक वैकल्पिक तर्क को "पहचान" कैसे देंगे?

ऐसा नहीं है कि अक्सर कार्य मेरे उदाहरण की तरह शून्य मान लौटाते हैं।

फिर से बहुत बहस योग्य। कई फ़ंक्शन null या undefined मान लौटाते हैं: find (जब आइटम नहीं मिला), getError (जब कोई त्रुटि न हो) और इसी तरह ... यदि आप अधिक उदाहरण चाहते हैं तो मानक ब्राउज़र एपीआई देखें, आपको _plenty_ मिलेगा।

मैं जो कह रहा हूं वह यह है कि अधिकांश प्रकार की परिभाषाएं सही रहेंगी।

जैसा कि आप मेरी पिछली टिप्पणियों से बता सकते हैं, मैं इसके बारे में आश्वस्त नहीं हूं।

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

इस समय यह कथन मुझे तुच्छ नहीं लगता। क्या आप इसका ठोस उदाहरण दे सकते हैं कि यह कैसे काम करता है? खासकर _प्रगतिशील_भाग।

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

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

मान लें कि आप एक मौजूदा कोड आधार लेते हैं जो पुस्तकालय परिभाषाओं का उपयोग करता है और बिना किसी कोड को बदले इसे मेरे प्रस्ताव के साथ संकलित करने का प्रयास करता है:

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

declare function f(): string; // existing declaration, but f will never return null.
var x = f();
x.toUpperCase();  // error, possibly null reference.

लाइब्रेरी की परिभाषाओं को अधिक सटीक बनाने के लिए दीर्घकालिक सुधार है: declare function f(): !string;
शॉर्ट-टर्म फिक्स एक नॉट-नल कास्ट जोड़ना है: var x = <!>f(); ।
और बहुत सारी निर्भरताओं वाली बड़ी परियोजनाओं को अधिक आसानी से अपग्रेड करने में मदद करने के लिए, मैं सुझाव देता हूं कि "कोई निहित कोई नहीं" के समान एक कंपाइलर ध्वज जोड़ना: "चेतावनी के रूप में संभावित शून्य संदर्भों का इलाज करें"। इसका मतलब है कि आप नए कंपाइलर का उपयोग कर सकते हैं और तब तक प्रतीक्षा कर सकते हैं जब तक कि पुस्तकालयों की परिभाषा अपडेट न हो जाए। नोट: आपके प्रस्ताव के विपरीत यह ध्वज संकलक शब्दार्थ को नहीं बदलता है। यह केवल वही बदलता है जो त्रुटि के रूप में रिपोर्ट किया जाता है।

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

इस 130+ टिप्पणियों के अंक में विभिन्न चीजों के बारे में बहुत अधिक चर्चाएं चल रही हैं।

मेरा सुझाव है कि हम यहां _सामान्य_ चर्चा जारी रखें।

टीएस में गैर-शून्य प्रकारों को लागू करने वाले ठोस प्रस्तावों की चर्चा के लिए, मेरा सुझाव है कि हम नए मुद्दों को खोलें, प्रत्येक एक एकल डिजाइन प्रस्ताव के बारे में। मैंने !T सिंटैक्स पर चर्चा करने के लिए #1800 बनाया।

@spion मेरा सुझाव है कि आप अपने डिजाइन के लिए भी एक मुद्दा बनाएं।

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

@ jods4 मुझे ऐसा कहने के लिए खेद है, लेकिन आपके प्रस्ताव का गैर-शून्य प्रकार से कोई लेना-देना नहीं है, यह किसी प्रकार के नियंत्रण-प्रवाह विश्लेषण से संबंधित है, शायद ही अनुमान लगाया जा सकता है, और यह पूरी तरह से रेट्रोकंपैटिबिलिटी को तोड़ देता है (वास्तव में अधिकांश कोड जो मान्य है 1.4 ts आपके सार में वर्णित नियम के तहत विफल हो जाएगा)।
मैं इस तथ्य से सहमत हूं कि चर्चा कहीं नहीं जा रही है, और 130 टिप्पणियाँ+ शायद बहुत अधिक हैं। लेकिन शायद ऐसा इसलिए है क्योंकि यहां चर्चा करने वाले लोगों के 2 समूह हैं:

• जो लोग सोचते हैं कि गैर-शून्य प्रकार डिफ़ॉल्ट होना चाहिए और ऐसा करने का एक तरीका खोजना चाहते हैं (ध्वज या किसी अन्य तंत्र के माध्यम से)
• जो लोग गैर-शून्य प्रकार नहीं चाहते हैं और बस उनके परिचय से बचने की कोशिश करते हैं, या उन्हें एक नए वाक्यविन्यास में धकेलने का प्रयास करते हैं।

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

@fdecampredon
मेरे सार के बारे में, मैंने आपके तर्कों को # 1800 में कॉपी-पेस्ट किया और यदि आप वास्तव में रुचि रखते हैं तो हम चर्चा कर सकते हैं कि यह एक खराब डिज़ाइन क्यों है। मैं वास्तव में आपकी बात को समझ नहीं पा रहा हूं लेकिन मैं यहां चर्चा शुरू नहीं करना चाहता, इसलिए मैंने पहली जगह में #1800 बनाया।

इस सूत्र के संबंध में, मैं आपसे सहमत हूं कि चर्चा कहीं नहीं जा रही है ...

जैसा कि आप मेरी पिछली टिप्पणियों से बता सकते हैं, मैं इसके बारे में आश्वस्त नहीं हूं।

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

अभी आप इसे व्यक्त नहीं कर सकते

declare function err():string;

शून्य लौटाता है। यह असंभव है, क्योंकि टाइपप्रति आपको हमेशा खुशी से err().split(' ') । आप यह कहने में असमर्थ हैं कि "यह मान्य नहीं हो सकता"।

इस परिवर्तन के बाद, आप string को ?string या string|null बदलकर सक्षम होंगे।

लेकिन अगर आप ऐसा नहीं करते हैं, तो _आप कुछ भी नहीं खोते_ जो आपके पास बदलाव से पहले था:

परिवर्तन से पहले आपके पास शून्य जांच नहीं थी, और आपके पास बाद में नहीं है (यदि आप कुछ भी नहीं करते हैं)। मैंने तर्क दिया कि यह ज्यादातर पिछड़ा संगत है। निश्चित रूप से बड़े कोडबेस पर प्रदर्शित होना बाकी है।

अंतर यह है: आप परिवर्तन से पहले अशक्त जाँच को बाध्य नहीं कर सकते थे, लेकिन आप _can_ के बाद (उत्तरोत्तर, पहले उन परिभाषाओं पर जिनकी आप सबसे अधिक परवाह करते हैं, फिर अन्य स्थानों पर)

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

@spion , मैं सभी नल कीवर्ड के साथ घोषित किए जा रहे नल के लिए हूं, लेकिन आपके प्रस्ताव में उस और अपरिभाषित के बीच क्या व्यवहार है?

और @fdecampredon मेरा एकमात्र अनुरोध एक बड़ा ब्रेकिंग परिवर्तन नहीं होने के लिए था, विशेष रूप से एक जिसमें गलत जगह पर त्रुटियां दिखाई गई थीं।

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

@spion
आपकी पिछली टिप्पणी से मुझे जो समझ में आया, वह उससे काफी अलग है जो मैंने पहले समझा था ...

तो : string "आपका पुराना स्ट्रिंग प्रकार है जिसे कभी भी शून्यता के लिए चेक नहीं किया जाएगा, जैसे <any> को कभी भी शुद्धता के लिए चेक नहीं किया जाता है"।

नया सिंटैक्स : string | null पश्चगामी संगत है क्योंकि यह पहले मौजूद नहीं था और इस प्रकार को बिना शून्य जांच के एक्सेस करना एक त्रुटि है।

यह दिलचस्प है और सभी प्रभावों को समझना मुश्किल है। मुझे इसके बारे में कुछ समय सोचना होगा।

पहला सवाल जो दिमाग में आता है वह यह है कि आप इनपुट वैल्यू (जैसे फंक्शन पैरामीटर) पर बाधा कैसे डालते हैं:

declare f(x: string): void;
f(null);

क्या यह ठीक है या कोई त्रुटि है? अगर यह ठीक है, तो मैं इसे एक त्रुटि कैसे कर सकता हूं।

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

@jods जो एक त्रुटि होगी:

declare f(x: string): void; //string must not be null.
declare f(x: string|null): void; //string may be null (not sure about undefined here).
declare f(x?: string): void; //I assume x may be null or undefined.

@ jods4 मुझे नहीं लगता कि हमें एक विषय पर कई मुद्दों को बनाने की जरूरत है, फिर चीजों को ट्रैक करना मुश्किल हो जाएगा क्योंकि आपको 10 अलग-अलग प्रस्तावों पर जाना होगा, यह देखने के लिए कि क्या कुछ हुआ है / 10 अलग-अलग लोगों की सदस्यता लें . और उन सभी को अपने परिचय में अन्य प्रस्तावों के लिंक होने चाहिए ताकि हर कोई जो गैर-शून्यता की तलाश में जाता है, वह न केवल एक को देखता है और न ही उसे वोट देता है।

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

@ ग्रिफोर्क
लेकिन जादू के झंडे को चालू करने के बाद ही, है ना?
तो फ्लैग ऑफ के साथ आपके पास अनियंत्रित कोड है, नए नलबल प्रकारों को छोड़कर जो पहले मौजूद नहीं थे; फिर जब आप ध्वज को चालू करते हैं, तो सभी प्रकार गैर-शून्य और चेक किए जाते हैं?

मुझे लगता है कि अंतिम परिणाम शायद सबसे अच्छा समाधान है। _लेकिन यह आज मौजूद सभी कोड को काफी हद तक तोड़ रहा है।_ कल्पना कीजिए कि मेरे पास कोड की 300K लाइनें हैं ... मुझे ध्वज को चालू करने से पहले हर जगह एक प्रकार का वास्तव में अशक्त एनोटेशन जोड़ना होगा। यह बहुत बड़ी बात है।

अगर मैं सही ढंग से समझूं, तो यह नई परियोजनाओं के लिए अच्छा है (एक बार .d.ts अपडेट हो जाने के बाद) लेकिन मौजूदा कोड के लिए बहुत दर्दनाक है।

@ इस एकल मुद्दे और टिप्पणियों के लंबे धागे के साथ मेरी समस्या

@spion के मूल प्रस्ताव में कोई जादुई झंडा नहीं था। टाइपस्क्रिप्ट के काम करने के तरीके में यह एक मुख्य बदलाव था।

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

आप वास्तव में कार्यान्वयन विवरण द्वारा इस बातचीत को तोड़ नहीं सकते हैं, क्योंकि बहुत सारे प्रस्ताव अक्सर कई अलग-अलग विवरणों को स्पर्श करेंगे जो वर्तमान में चर्चा में हैं।

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

मुद्दा यह है: वार्तालाप को विभाजित करने से लोगों को बहुत सारी पोस्ट दोहरानी पड़ेगी क्योंकि दर्शकों को अन्य सभी लिंक की गई पोस्ट में सब कुछ पढ़ने के लिए बहुत आलसी हैं (यह मानते हुए कि सभी प्रासंगिक पोस्ट अन्य सभी पोस्ट को लिंक करते हैं )

इसके अलावा @ jods4 यह केवल एक ब्रेकिंग बदलाव है जब आप किसी चीज़ को अशक्त करते हैं।

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

यहाँ एक उदाहरण दिया गया है कि "अपग्रेड" प्रक्रिया @jods4 और @spion के प्रस्तावों की तरह क्या हो सकती है (यह मानते हुए कि कोई आवश्यक फ़्लैग चालू है):

function a(arg1: string): string;
a("mystr").toLowerCase(); //errors in <strong i="11">@jods4</strong>'s proposal because a may return null.
a("mystr").toLowerCase(); //fine in <strong i="12">@spion</strong>'s proposal.

a(null).toLowerCase(); //fine in <strong i="13">@jods4</strong>'s proposal because a may accept null.
a(null).toLowerCase(); //errors in <strong i="14">@spion</strong>'s proposal since a doesn't accept null.

अंततः वे दोनों परिवर्तन तोड़ रहे हैं। वे दोनों डिबग करने के लिए उतने ही दर्दनाक हैं, चर घोषणा के बजाय चर उपयोग में होने वाली त्रुटियां। अंतर यह है कि एक त्रुटि जब नल को कुछ (@spion) को सौंपा जाता है, और दूसरी त्रुटियां जब नल को कुछ (@jods4) को नहीं सौंपा जाता है। व्यक्तिगत रूप से मैं चीजों को शून्य से बहुत कम बार असाइन करता हूं जब मैं चीजों को शून्य नहीं देता, इसलिए @spion मेरे साथ काम करने के लिए एक बदलाव से कम नहीं है।

अन्य चीजें जो मुझे पसंद हैं:

• चर के प्रकार मुझ पर गतिशील रूप से नहीं बदल रहे हैं। अगर मैं चाहता था कि मैं प्रवाह का उपयोग करूं:

var s: string;
s.toUpperCase(); // error
var t = (s || "test").toUpperCase(); // ok. Inferred t: string
yes(t);  // ok
t = no();
yes(t);  // error

व्यक्तिगत रूप से मुझे एक त्रुटि चाहिए अगर मैंने नहीं () कहा, प्रकार का एक अंतर्निहित परिवर्तन नहीं।

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

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

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

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

@ jods4 अवास्तविक उप-चर्चाओं को

@spion मुझे लगता है कि मेरे पास '-nonImplicitNull' ध्वज के साथ @RyanCavanaugh समस्या का एक आसान समाधान है, यह विचार बहुत आसान है हमें केवल ?type type|null या type|undefined अनुमति नहीं देनी है

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

@jods4

declare f(x: string): void;
f(null);

प्रस्तावित --noImplicitNull ध्वज का उपयोग करते समय, हाँ, यह एक त्रुटि होगी।

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

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

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

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

मुझे आश्चर्य है कि इस बनाम इसके लाभों के टूटने के पहलू के बारे में आधिकारिक टीएस टीम का रुख क्या है।

यह बहुत कम संभावना है कि हम कभी भी "डिफ़ॉल्ट रूप से सब कुछ गैर-शून्य करने योग्य" के रूप में बड़ा ब्रेक लेंगे। यदि कुछ प्रस्ताव थे जो _only_ उन मामलों में नई त्रुटियां जारी करेंगे जो स्पष्ट रूप से बग हैं, जो टेबल पर हो सकते हैं, लेकिन इस तरह के प्रस्तावों का आना मुश्किल है: पलक:

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

:+1: समझदार व्यक्ति का पता चला: @RyanCavanaugh

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

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

फिर (बाद में शायद?) आप एक --noImplicitNullCast ध्वज जोड़ सकते हैं जो शून्य को उन चरों को असाइन करने से रोकता है जिनके टाइपिंग के हिस्से के रूप में शून्य नहीं है (यह कम या ज्यादा काम करता है जैसे ध्वज सक्षम के साथ @spion का सुझाव)।

मुझे लगता है कि यह सभी सामान्य टाइपिंग और --noImplicitAny ध्वज को जोड़ने से बहुत भिन्न नहीं होगा।

@ ग्रिफोर्क
पैकेज का पहला भाग (एक null प्रकार जोड़ें और बिना गार्ड के मना करें) 100% संगत नहीं है। आप जितना सोचते हैं उससे अधिक कोड तोड़ेंगे। इस पर विचार करो:

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

interface Array<T> {
  find(predicate: (T) => bool) : T | null;
  pop() : T | null;
}
interface Storage {
  getItem(key: string) : any | null;
}

ऐसे कई एपिस हैं: find रिटर्न undefined यदि कोई सरणी तत्व विधेय से मेल नहीं खाता है, तो pop रिटर्न undefined अगर सरणी खाली है, localStorage.getItem यदि कुंजी नहीं मिली तो sessionStorage.getItem दोनों null लौटाते हैं।

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

var xs: string[];
if (xs.length > 0) return xs.pop().trim();  // error xs.pop() may be undefined (false positive)

var items : { id: number }[];
var selectedId : number;
// Assume we are sure selectedId is amongst items
var selectedItem = items.find(x => x.id === selectedId);
selectedItem.toString(); // error selectedItem may be undefined (false positive)

वही विचार यदि आप localStorage से कुछ लाते हैं जो आपको पता है कि वहां है। इस तरह के बहुत सारे कोड हैं और अब इसे संकलित करने और संकलक को बताने के लिए एक कलाकार (या कुछ नया वाक्यविन्यास) की आवश्यकता है: मान लीजिए कि यह शून्य नहीं है, मुझे पता है कि मैं क्या कर रहा हूं।

इसमें कुछ वास्तविक बग शामिल होंगे, निश्चित रूप से। लेकिन इसमें बहुत सारी झूठी सकारात्मकताएं भी शामिल होंगी और ये बदलाव को तोड़ रहे हैं। 100 के + एलओसी में यह एक छोटा कंपाइलर अपग्रेड नहीं है।

इसका शायद मतलब यह है कि एकमात्र तरीका जो काम करेगा वह है: स्क्रैच से लिखा गया नया कोड या माइग्रेट किया गया पुराना कोड शून्य जाँच का पूरा फायदा उठाता है; विरासत कोड का कोई लाभ नहीं है। यह एक कंपाइलर विकल्प (--enableNullAnalysis) द्वारा संचालित किया जा रहा है और कोई "संक्रमण" या "प्रगतिशील" माइग्रेशन पथ नहीं है।

सही है। लेकिन आप किसी प्रोजेक्ट के लिए lib.d.ts को हमेशा फ़्रीज़ कर सकते हैं या किसी पुराने को हड़प सकते हैं।
नई टाइपिंग से पुराना कोड टूट जाएगा, वैसे भी ऐसा ही होगा। पेश किए जाने पर लगभग सभी नए टाइपिंग के लिए आवश्यक है कि पुराना कोड किसी न किसी तरह से सही ढंग से काम करने के लिए अपडेट हो जाए (जैसे यूनियन, जेनरिक)।
इस बदलाव का मतलब है कि जो लोग अपडेट को नज़रअंदाज़ करना चाहते हैं या अपनी लाइब्रेरी/कोड परिभाषाओं को फ्रीज़ करना चाहते हैं, उन्हें नुकसान नहीं होगा।
सैद्धांतिक रूप से उन कार्यों का उपयोग करने वाले अधिकांश कोड को वैसे भी संरक्षित किया जाना चाहिए (और आमतौर पर बड़े कोडबेस में होते हैं) - क्योंकि यदि आप नहीं करते हैं तो आपके कोड में गुप्त बग हैं। इस प्रकार यह परिवर्तन व्यापक रूप से तोड़ने वाले परिवर्तनों की तुलना में त्रुटियों को पकड़ने की अधिक संभावना है।

संपादित करें
@ jods4 आपने एक उदाहरण के रूप में असुरक्षित कोड का उपयोग क्यों किया जबकि यह ठीक उसी तरह का कोड है जो एक त्रुटि का कारण बन सकता है जिसे हम यह परिवर्तन करके पता लगाने की कोशिश कर रहे हैं?

2 संपादित करें
यदि आप _some_ (गलत/असुरक्षित) कोड को नहीं तोड़ते हैं, तो इस विषय में कभी भी कोई बदलाव करने का कोई मतलब नहीं है।

लेकिन फिर, चूंकि यह सिर्फ एक वाक्यविन्यास समस्या है, सब कुछ अभी भी ठीक से संकलित होगा, यह सभी जगह बस त्रुटि होगी।

_नई टाइपिंग से पुराना कोड टूट जाएगा, वैसे भी ऐसा ही होगा।_

ये बात नहीं है। असाधारण परिस्थितियों को छोड़कर हम मौजूदा कोड को तोड़ने वाली नई सुविधाओं को नहीं जोड़ेंगे। जेनेरिक और यूनियनों को lib.d.ts में इस तरह से नहीं जोड़ा गया था कि lib.d.ts के उपभोक्ताओं को कंपाइलर के नए संस्करण का उपयोग करने के लिए अपने कोडबेस को अपडेट करने की आवश्यकता होती है। हाँ लोग पुस्तकालय के पुराने संस्करण का उपयोग करना चुन सकते हैं लेकिन ऐसा नहीं है कि हम भाषा परिवर्तन करने जा रहे हैं जो बहुत सारे मौजूदा कोड को तोड़ते हैं (जैसा कि अनिवार्य रूप से सभी प्रमुख भाषाओं के मामले में है)। इसके लिए कभी-कभार अपवाद होगा (https://github.com/Microsoft/TypeScript/wiki/Breking-Changes) लेकिन वे बहुत कम और बहुत दूर होंगे, अक्सर अगर हमें लगता है कि हम जिस कोड को तोड़ रहे हैं वह केवल हो सकता है एक दोष।

लेकिन आप किसी प्रोजेक्ट के लिए lib.d.ts को हमेशा फ़्रीज़ कर सकते हैं या किसी पुराने को हड़प सकते हैं

फ्रीजिंग lib.d.ts (और कोई भी अन्य .d.ts मैं BTW का उपयोग कर सकता हूं) के बहुत मजबूत निहितार्थ हैं। इसका मतलब है कि मेरे द्वारा उपयोग किए जाने वाले कामों या नए HTML एपिस पर मुझे कोई अपडेट नहीं मिल सकता है। यह हल्के में लेने की बात नहीं है।

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

JS में कई मामलों में undefined (या कभी-कभी null ) वापस करने की परंपरा है जो अन्य भाषाओं में त्रुटि उत्पन्न कर सकती है। इसका एक उदाहरण है Array.prototype.pop । सी # में एक खाली ढेर से पॉपिंग फेंक देगा। तो आप कह सकते हैं कि यह हमेशा एक वैध मान देता है। जावास्क्रिप्ट में एक खाली सरणी पॉपिंग undefined । यदि आपका टाइपसिस्टम इसके बारे में सख्त है तो आपको किसी तरह इसका ख्याल रखना होगा।

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

मैं अभी एक घंटे पहले किसी पुस्तकालय के सूक्ष्म कार्य भाग को देख रहा था। मुख्य भाग मूल रूप से इसके लिए नीचे आता है:

class MicroTasks {
  queue: Array<() => void>;

  flushQueue() {
    while (queue.length > 0) {
      let task = queue.pop();
      task();  // error possible null dereference (not!)
     }
  }
}

ऐसे बहुत से मामले हैं।

आपके संपादन 2 के संबंध में: हाँ, उम्मीद है कि यह परिवर्तन _will_ बग्स को पकड़ेगा और अमान्य कोड को इंगित करेगा। मुझे विश्वास है कि यह उपयोगी है और इसलिए मैं चाहूंगा कि यह किसी तरह हो। लेकिन TS टीम _valid_ कोड में महत्वपूर्ण बदलावों पर विचार करेगी। ऐसे ट्रेड-ऑफ हैं जिन्हें यहां तय करने की आवश्यकता है।

@danquirk मेला, तो मुझे लगता है कि इस सुविधा को कभी भी लागू नहीं किया जा सकता है।
@ jods4 मैं समझता हूं कि आप क्या कह रहे हैं, लेकिन उस कोड को तोड़े बिना

दुख की बात है, क्या मुझे उस मुद्दे को अंत में बंद कर देना चाहिए?

शायद।

मुझे लगता है कि अगर हम निरर्थक और अशक्त तर्क से दूर रहें ...

नई सुविधाओं के एक सेट के साथ समस्या को गैर-दखल तरीके से संबोधित किया जा सकता है (या कम किया जा सकता है):

• null-typeguard प्रतीक ?<type> परिचय दें
  यदि इस प्रतीक के साथ एक प्रकार की व्याख्या की जाती है तो इसे सीधे एक्सेस करने में त्रुटि होती है

``` टाइपस्क्रिप्ट
वर फू: ?स्ट्रिंग;

foo.indexOf ('एस'); // त्रुटि
फू && foo.indexOf('s'); // ठीक
```

• एक झंडा पेश करें --nouseofunassignedlocalvar

``` टाइपस्क्रिप्ट
वर फू: स्ट्रिंग;

foo.indexOf ('एस'); // त्रुटि

फू = 'बार';

foo.indexOf ('एस'); // ठीक
```

दिलचस्प ऐतिहासिक नोट : इसके लिए एक संबंधित मुद्दे को खोजने की कोशिश करते समय मुझे कोडप्लेक्स पर एक पुराना मुद्दा मिला जिसमें फरवरी-2013 में --cflowu कंपाइलर विकल्प का उल्लेख किया गया था। @RyanCavanaugh , मुझे आश्चर्य है कि उस झंडे का क्या हुआ?

• सुरक्षित नेविगेशन ऑपरेटर #16 . का परिचय दें

TypeScript var x = { y: { z: null, q: undefined } }; console.log(x?.y?.z?.foo); // Should print 'null'

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

@ नोएल अब्राहम :
आपका पहला प्रस्ताव अनिवार्य रूप से मेरे पिछले प्रस्ताव जैसा ही है, आप बस एक का उपयोग कर रहे हैं? इसके बजाय |null ( lib.d.ts को अपडेट करने और परिवर्तनों को तोड़ने की समस्याओं पर

आपके दूसरे प्रस्ताव में पहले @RyanCavanaugh (ऊपर) द्वारा संबोधित एक समस्या है:

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

मैं काफी हद तक निश्चित हूं कि एक झंडा अलग नहीं था जिसे पहले प्रस्तावित किया गया था, और फिर @RyanCavanaugh की टिप्पणी के कारण छोड़ दिया गया।

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

क्या सुझाए गए प्रस्तावों में से किसी एक को लागू करना संभव हो सकता है, और नलबल्स (और अन्य libs) का उपयोग करने के लिए lib.d.ts को अपडेट नहीं करना संभव है? तब समुदाय अपने स्वयं के संस्करणों को अशक्त के साथ बनाए/उपयोग कर सकता है यदि वे चाहते हैं?

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

@RyanCavanaugh मैं वापस आऊंगा और चर्चा करूंगा कि अगर मेरे पास एक पैच है जो दर्शाता है कि यह इतना बड़ा बदलाव नहीं है (विशेषकर यदि .d.ts फाइलें अपडेट नहीं हैं)।

@danquirk प्रकार की परिभाषाओं को अद्यतन नहीं करना होगा। वे "गलत" रह सकते हैं और अधिकतर पिछड़े-संगत होंगे।

वैसे भी, ऐसा लगता है कि यह मुद्दा एक खोया हुआ कारण है।

वैसे, एमएसआर द्वारा एक संशोधित कंपाइलर था जिसने अन्य चीजों के साथ ऐसा किया - क्या उनके निष्कर्षों के साथ कोई कागजात उपलब्ध हैं? संपादित करें: इसे मिला: http://research.microsoft.com/apps/pubs/?id=224900 लेकिन दुर्भाग्य से, मुझे यकीन नहीं है कि यह संबंधित है।

@ ग्रिफोर्क , हाँ, मुझे यकीन है कि चर्चा की लंबाई को देखते हुए लगभग हर चीज पर एक या दूसरे रूप में चर्चा की गई है। मेरा सारांश कई संबंधित विशेषताओं को पेश करके शून्य के आसपास की समस्याओं को कम करने के बारे में एक व्यावहारिक है।

हर जगह नए अशक्त या अपरिभाषित चेक नहीं जोड़ना

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

मुझे यह भी लगता है कि टीएस में इसकी संभावना कम है ... :(

एकमात्र समाधान जिसके बारे में मैं सोच सकता हूं वह है अशक्त सुरक्षा को ऑप्ट-इन कंपाइलर ध्वज बनाना। उदाहरण के लिए नया T | null या ?T सिंटैक्स पेश करें, लेकिन _any_ त्रुटि तब तक न बढ़ाएं जब तक कि प्रोजेक्ट ऑप्ट-इन न कर दे। इसलिए नई परियोजनाओं को लाभ मिलता है और इसलिए पुरानी परियोजनाओं को भी जो अपने कोड को नई सुविधा के अनुकूल बनाने का विकल्प चुनते हैं। बड़े कोडबेस जो आसानी से अनुकूलित होने के लिए बहुत बड़े हैं, उन्हें यह सुविधा नहीं मिलती है।

उस ने कहा, फिर भी इस सुविधा को उड़ान भरने के लिए कई मुद्दे बाकी हैं ...

@NoelAbrahams क्षमा करें, मेरी बात यह नहीं थी कि यह एक बुरा सुझाव था, सिर्फ वह उत्तर नहीं जो इस चर्चा की
मैं निश्चित रूप से उस सुविधा का उपयोग कर रहा हूँ जब (/ अगर) यह मूल हो जाता है, तो यह वास्तव में अच्छा लगता है।

@ jods4 जिसकी @RyanCavanaugh टिप्पणी के साथ एक ही समस्या है जिसे मैंने ऊपर उद्धृत किया है (एक ध्वज बदलने पर कहीं और किसी समस्या के कारण असाइनमेंट त्रुटि)।

फिर से, सबसे आसान तरीका अन्य प्रस्तावों में से एक (शायद @spion के) को लागू करना है और .d.ts' में नए प्रकार नहीं जोड़ना है।

@ ग्रिफोर्क
जरूरी नहीं, हालांकि यह बचे हुए "कई मुद्दों" में से एक है। फीचर को इस तरह से डिजाइन किया जाना चाहिए कि फ्लैग को सक्षम करने से कोई भी प्रोग्राम सेमेन्टिक्स _not_ बदल जाए। इसे केवल त्रुटियां उठानी चाहिए।

उदाहरण के लिए यदि हम 'नॉट नल' !T डिज़ाइन के साथ जाते हैं, तो मुझे नहीं लगता कि हमारे पास यह समस्या है। लेकिन यह समस्या के समाधान से कोसों दूर है।

मुझे यह भी बताना चाहिए कि जबकि T | null एक ब्रेकिंग परिवर्तन है ?T नहीं है।

@ jods4 मैं इस धारणा के तहत था कि "चेंजिंग असाइनमेंट -क्षमता बदलना" शामिल है, किसी भी तरह से मेरी (और संभवतः

@ नोएल अब्राहम कैसे?
टी | नल को टाइपगार्ड की आवश्यकता होती है, टी को टाइपगार्ड की आवश्यकता होती है, वे अलग-अलग नामों/प्रतीकों के साथ एक ही चीज़ हैं।
हां, आप दोनों को ध्वज के साथ "चालू" कर सकते हैं।
मैं अंतर देखने में असफल रहा?

@ ग्रिफोर्क , जिस तरह से मैं इसे ?T देखता हूं, इसका सीधा अर्थ है "शून्य की जांच किए बिना एक्सेस न करें"। चेक को लागू करने के लिए कोई भी इस एनोटेशन को नए कोड में जोड़ने के लिए स्वतंत्र है। मैं इसे टाइप एनोटेशन के बजाय एक प्रकार के ऑपरेटर के रूप में सोच रहा हूं।

एनोटेशन T|null मौजूदा कोड को तोड़ता है क्योंकि यह इस बारे में एक बयान देता है कि प्रकार डिफ़ॉल्ट रूप से शून्य हैं या नहीं।

@jbondc
दिलचस्प... मैंने अभी तक आपके प्रस्ताव को बहुत गहराई से नहीं देखा है, लेकिन मुझे लगता है कि मैं करूंगा।

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

@NoelAbrahams
सभी अशक्त लागू करने वाले प्रस्ताव परिवर्तन तोड़ रहे हैं। यहां तक ​​कि ?T जिसका आपने वर्णन किया है। मैंने कई उदाहरण दिखाए कि ऊपर कुछ टिप्पणियां क्यों।

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

मैं वास्तव में इसके साथ ठीक हूँ। टीएस 1.5 के साथ मैं जो चाहता हूं उसे प्राप्त करने में सक्षम हूं:

function isVoid(item:any): item is void { return item == null; }
declare externalUnsafeFunction(...):string|void

function test() {
  var res = externalUnsafeFunction(...);
  var words = res.split(' '); // error
  if (!isVoid(res)) {
    var words = res.split(' '); // ok
  }
}

अब isVoid चेक को externalUnsafeFunction या किसी अन्य फ़ंक्शन या फ़ंक्शन परिभाषा के लिए वापसी मूल्यों पर मजबूर किया जाता है जहां मैं रिटर्न प्रकार में |void जोड़ता हूं।

मैं अभी भी उन कार्यों की घोषणा करने में सक्षम नहीं हूं जो शून्य/अपरिभाषित स्वीकार नहीं करते हैं, लेकिन स्थानीय चर और कक्षा के सदस्यों को प्रारंभ करने के लिए याद रखने के लिए पर्याप्त मेहनती होना संभव है।

क्योंकि @NoelAbrahams हम पहले ही चर्चा कर चुके हैं कि एक अशक्त प्रकार के साथ भी, नल को अभी भी किसी अन्य प्रकार के लिए निहित रूप से डालने की अनुमति

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

और व्यक्तिगत रूप से मुझे प्रतीकों का उपयोग करने के विचार से नफरत है जब हम इसके बजाय शब्दों का उपयोग कर सकते हैं।

@spion वास्तव में यह एक अच्छी बात है। यदि वह वर्तमान में TS में काम करता है तो यकीनन सभी d.ts फाइलों में निर्मित पहले से

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

मैं सावधान करूंगा कि हम किसी भी तरह से T|void को एक वाक्य रचना के रूप में नहीं देखते हैं कि हम भविष्य में टूटने से डरेंगे। यह लगभग बकवास है।

@RyanCavanaugh यह शून्य === अपरिभाषित (एक असाइन करने योग्य मान) के रूप में बकवास है।

आहें।

हमारा कोड T|void आधार पर शुरू करने के लिए बहुत बड़ा है यदि यह जल्द ही टूट जाएगा और प्रतिस्थापित नहीं किया जाएगा। और मैं अन्य प्रोग्रामर को इसका उपयोग करने के लिए मना नहीं पाऊंगा यदि किसी भी सप्ताह यह टूट सकता है।

ठीक है, @spion यदि आप कभी अपना पैच बनाते हैं, तो मुझे बताएं और मैं इसे अपने काम के कोडबेस के विरुद्ध चलाऊंगा। मैं कम से कम आंकड़े दे सकता हूं कि इससे कितनी त्रुटियां होती हैं।

@RyanCavanaugh बकवास, सच में? किस तरह से? और आप अशक्त प्रकारों को व्यक्त करने के लिए क्या सुझाव देंगे जिन्हें अशक्त/अपरिभाषित जांच से पहले किसी भी प्रकार के उपभोग के लिए प्रतिबंधित किया जाना चाहिए?

मेरे पास वास्तव में बहुत सारे पुस्तकालय हैं जो इससे लाभान्वित होंगे।

@Griffork किसी भी तरह से 1.5 से पहले संघ से void को सुरक्षित रूप से निकालना संभव नहीं होगा, उपयोगकर्ता-परिभाषित प्रकार के गार्ड के बिना नहीं, इसलिए इसका उपयोग करना केवल 1.5 के बाद संभव होगा (यदि यह बिल्कुल भी संभव हो)

बकवास जैसा कि क्या आप कभी इस कोड को लिखेंगे?

var foo: void;
var bar: void = doStuff();

बिल्कुल नहीं। तो फिर संभावित प्रकार के संघ में void जोड़ने का क्या अर्थ है? The Void Type (3.2.4) का वर्णन करने वाले खंड में काफी समय से मौजूद भाषा के नमूने के इस हिस्से पर ध्यान दें:

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

यह प्रश्न:

_और अशक्त/अपरिभाषित चेक से पहले किसी भी प्रकार के उपभोग के लिए प्रतिबंधित किए जाने वाले अशक्त प्रकारों को व्यक्त करने के लिए आप क्या सुझाव देंगे?_

पूरा सूत्र इसी के बारे में है। रयान केवल इस ओर इशारा कर रहा है कि string|void वर्तमान भाषा शब्दार्थ के अनुसार बकवास है और इसलिए बकवास शब्दार्थ पर निर्भरता लेना जरूरी नहीं है।

मैंने जो कोड ऊपर लिखा है वह afaik पूरी तरह से मान्य TS 1.5 है, है ना?

मैं एक उदाहरण दूंगा जो निश्चित रूप से बकवास नहीं है। हमारे पास एक (नोडज) डेटाबेस लाइब्रेरी फ़ंक्शन है जिसे हम लिंक के सिंगल() के समान get() जो दुर्भाग्य से आइटम नहीं मिलने पर त्रुटि (एक अस्वीकृत वादा) फेंकने के बजाय Promise<null> लौटाता है। इसका हमारे पूरे कोडबेस में हजारों स्थानों पर उपयोग किया जाता है और इसके बदले जाने या जल्द ही जाने की संभावना नहीं है। मैं एक प्रकार की परिभाषा लिखना चाहता हूं जो मुझे और अन्य डेवलपर्स को मूल्य का उपभोग करने से पहले एक प्रकार के गार्ड का उपयोग करने के लिए मजबूर करता है, क्योंकि हमारे पास गलत तरीके से खपत होने से पहले कोडबेस में दूर जाने वाले शून्य मान से उत्पन्न बग का पता लगाने के लिए दर्जनों कठिन हैं।

interface Legacy { 
  get<T>(...):Promise<T|void>
}

function isVoid(val: any): val is void { return val == null; } // also captures undefined

legacy.get(...).then(val => {
  // val.consumeNormally() is a type error here
  if (!isVoid(val)) { 
    val.consumeNormally(); // OK
  }
  else { handle null case }
});

यह मेरे लिए पूरी तरह से उचित लगता है। जोड़ा जा रहा है void संघ के लिए पर सभी कार्यों का कारण बनता है val , अमान्य हो के रूप में वे किया जाना चाहिए। टाइपगार्ड |void को हटाकर प्रकार को छोटा करता है और T भाग को छोड़ देता है।

शायद कल्पना यूनियनों के प्रभाव को शून्य के साथ खाते में नहीं लेती है?

शून्य चर को अस्वीकार न करें! वे इकाई प्रकार के मूल्यों के रूप में काम करते हैं और उनका उपयोग किया जा सकता है
भावों में (सी # में शून्य के विपरीत जिसके लिए हर चीज के 2 सेट की आवश्यकता होती है: one
कार्यों और एक कार्यों के लिए)। कृपया शून्य को अकेला छोड़ दें, ठीक है?
27 जनवरी 2015 को रात 8:54 बजे, "गोर्गी कोसेव" नोटिफिकेशन @github.com ने लिखा:

मैंने जो कोड ऊपर लिखा है वह afaik पूरी तरह से मान्य TS 1.5 है, है ना?

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

इंटरफ़ेस विरासत {
प्राप्त(...):वादा
}
फ़ंक्शन isVoid (वैल: कोई भी): वैल शून्य है {रिटर्न वैल == अशक्त; }//अपरिभाषित भी कैप्चर करता है

विरासत। प्राप्त करें (...)। तब (वैल => {
// val.consumeNorally() एक त्रुटि है
अगर (! isVoid (वैल)) {
सामान्य रूप से (); // ठीक है
}
अन्य {अशक्त मामले को संभालें}
});

यह मेरे लिए पूरी तरह से उचित लगता है। क्या आप बता सकते हैं कि कौन सा हिस्सा है
बकवास?

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

मैं जो कह रहा हूं वह यह है कि T|void अनिवार्य रूप से अभी अर्थहीन है क्योंकि हमारे पास पहले से ही नियम है कि एक प्रकार और उसके उपप्रकार का संघ केवल सुपरटेप के बराबर है, उदाहरण के लिए Cat|Animal के बराबर है Animal । void को null / undefined मानों के लिए स्टैंड-इन के रूप में मानना ​​सुसंगत नहीं है क्योंकि null और undefined ही _ में हैं सभी T के लिए T _ का डोमेन, जिसका अर्थ है कि वे T उपप्रकार होने चाहिए

दूसरे शब्दों में, T|null|undefined , यदि आप इसे लिख सकते हैं, तो पहले से ही T में ढहने के अधीन होगा। void को null|undefined लिए एक मंत्र के रूप में मानना ​​गलत है क्योंकि अगर वास्तव में ऐसा होता, तो संकलक T|void को पहले ही T ध्वस्त कर देता।

मैं व्यक्तिगत रूप से इसे http://www.typescriptlang.org/Content/TypeScript%20Language%20Specification.pdf पढ़ूंगा

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

जैसा; T|void , टी विशेष रूप से _not_ void का एक सुपरटाइप है क्योंकि एकमात्र सुपरटेप (कल्पना के अनुसार) any ।

संपादित करें: इसे अस्वीकार करना एक अलग मुद्दा है।

संपादित 2: आपने जो कहा है उसे दोबारा पढ़ें, और यह सचमुच समझ में आता है (जिस तरह से दस्तावेज़ीकरण ने शून्य शब्द दिया है), लेकिन यह समझ में नहीं आता है कि दस्तावेज़ीकरण की सामान्य (या सही) व्याख्या क्या मानी जाती है।

@RyanCavanaugh मैं वैसे भी इस सुविधा का उपयोग तब तक करूँगा जब तक कि यह टूट न जाए, क्योंकि इस बीच इसकी बहुत सारी बग खोजने में मेरी मदद करने की संभावना है।

और मैं मदद नहीं कर सकता लेकिन यह कहने की विडंबना को इंगित करता हूं कि T|null|undefined को T "समझ में आता है" जबकि T|void का अस्तित्व नहीं है। (मुझे पता है, यह कल्पना के बारे में है, लेकिन फिर भी ...)

@jbondc

ईसीएमएस्क्रिप्ट में कोई स्थिर संरचनात्मक प्रकार नहीं हैं, ताकि तर्क अमान्य हो। ईसीएमएस्क्रिप्ट में, सभी मान any प्रकार के होते हैं इसलिए कुछ भी कुछ भी असाइन किया जा सकता है या किसी भी चीज़ को पास किया जा सकता है। उस तथ्य को टाइपस्क्रिप्ट की स्थिर प्रकार प्रणाली के बारे में कुछ भी नहीं बताना चाहिए, जो कि जेएस में मौजूद न होने पर सुधार करने के लिए है

यह थोड़ा दुखद है कि मुझे विडंबना की व्याख्या करनी है, लेकिन यहाँ जाता है:

1. आपके पास एक मूल्य है जो किसी भी तरीके और गुणों का समर्थन नहीं करता है, null
2. आप एक प्रकार की प्रणाली बनाते हैं जहां यह मान किसी भी प्रकार के चर के लिए असाइन करने योग्य होता है, उनमें से अधिकतर विभिन्न विधियों और गुणों का समर्थन करते हैं (उदाहरण के लिए स्ट्रिंग संख्याएं या जटिल वस्तुएं var s:string = null )
3. आप एक void प्रकार बनाते हैं जो उस मान को सही ढंग से स्वीकार करता है और कोई विधियों या गुणों की अनुमति नहीं देता है, और परिणामस्वरूप T|void कोई विधियों और गुणों की अनुमति नहीं देता है।

दावा यह है कि (3) बकवास है, जबकि (2) नहीं है। क्या आप यहां वह हिस्सा देखते हैं जो विडंबनापूर्ण है? यदि नहीं, तो मैं एक और उदाहरण आज़माउंगा:

1. आपके पास ऐसे मान हैं जो केवल कुछ विधियों और गुणों का समर्थन करते हैं {}
2. आप एक प्रकार की प्रणाली बनाते हैं जहां यह मान किसी भी प्रकार के चर के लिए असाइन करने योग्य होता है (उदाहरण के लिए स्ट्रिंग नंबर या जटिल ऑब्जेक्ट var s:string = {} ) जिसमें विधियों और गुणों का एक बड़ा सेट होता है
3. आपके पास एक {} प्रकार है जो {} मानों को सही ढंग से स्वीकार करता है और कुछ अंतर्निहित विधियों के अलावा किसी अन्य तरीके या गुणों की अनुमति नहीं देता है, और T|{} स्वाभाविक रूप से किसी अन्य तरीके या गुणों की अनुमति नहीं देता है {} बिल्ट-इन वाले

अब कौन सा बकवास है, (2) या (3)?

दोनों उदाहरणों में केवल क्या अंतर है? कुछ निर्मित विधियों में।

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

@spion ठीक यही मैं सोच रहा था।

यहाँ, मुझे लगता है कि यह चीजों को थोड़ा साफ कर देगा:
युक्ति के अनुसार:

शून्य क्या है?

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

तो, शून्य शून्य नहीं है | अपरिभाषित।

शून्य प्रकार के लिए एकमात्र संभावित मान शून्य और अपरिभाषित हैं

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

शून्य एक प्रकार है।

3.2.5 शून्य प्रकार
नल प्रकार समान नामित जावास्क्रिप्ट आदिम प्रकार से मेल खाता है और शून्य का प्रकार है
शाब्दिक।
अशक्त शाब्दिक अशक्त प्रकार के एक और एकमात्र मान का संदर्भ देता है। नल प्रकार को सीधे संदर्भित करना संभव नहीं है।

अपरिभाषित एक प्रकार है।

3.2.6 अपरिभाषित प्रकार
अपरिभाषित प्रकार समान नामित जावास्क्रिप्ट आदिम प्रकार से मेल खाता है और अपरिभाषित शाब्दिक का प्रकार है।

शून्य शून्य और अपरिभाषित _types_ का केवल एक सुपरटाइप है

. शून्य प्रकार किसी भी प्रकार का एक उपप्रकार है और अशक्त और अपरिभाषित प्रकारों का एक सुपरटाइप है, लेकिन अन्यथा शून्य अन्य सभी प्रकारों से असंबंधित है।

तो टाइपस्क्रिप्ट भाषा विशिष्टता के अनुसार @jbondc, नल एक मान है, नल एक प्रकार है, अपरिभाषित एक मान है, अपरिभाषित एक प्रकार है, और शून्य (लोअर-केस जब कोड में) एक प्रकार है जो नल का एक सुपरटाइप है और अपरिभाषित लेकिन _किसी भी अन्य प्रकार के लिए निहित रूप से कास्ट नहीं करता है ( any को छोड़कर)। वास्तव में, शून्य को विशेष रूप से अशक्त और अपरिभाषित प्रकारों के लिए अलग-अलग व्यवहार करने के लिए लिखा गया है:

शून्य:

शून्य प्रकार किसी भी प्रकार का एक उपप्रकार है और अशक्त और अपरिभाषित प्रकारों का एक सुपरटाइप है, लेकिन अन्यथा शून्य अन्य सभी प्रकारों से असंबंधित है।

शून्य:

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

अपरिभाषित:

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

अब साफ?

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

@jbondc यह विडंबना है: कोई फर्क नहीं पड़ता कि टीएस कंपाइलर क्या कहता है, जेएस में शून्य और अपरिभाषित मान कभी भी किसी भी तरीके या गुणों (अपवादों को फेंकने के अलावा) का समर्थन नहीं करेंगे। इसलिए, उन्हें किसी भी प्रकार के लिए असाइन करने योग्य बनाना बकवास है, उतना ही बकवास है जितना कि {} मान को स्ट्रिंग्स को असाइन करने की अनुमति देना। TS में शून्य प्रकार में कोई मान नहीं है, _but_ null या undefined लिए असाइन करने योग्य हैं, और इसलिए शून्य प्रकार के चर के लिए असाइन किया जा सकता है, इसलिए वहां एक और बकवास है। और यह विडंबना है - कि (टाइप गार्ड और यूनियनों के माध्यम से) दोनों वर्तमान में कुछ ऐसी चीज में गठबंधन करते हैं जो वास्तव में समझ में आता है :)

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

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

@jbondc शून्य और अपरिभाषित मानों के कारण टाइपस्क्रिप्ट कंपाइलर में मुद्दों की ऊपर मेरी टिप्पणी देखें (सूची में पहले वाले को घटाएं)

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

प्रकारों को अशक्त बनाने के लिए उल्लिखित बड़े मुद्दों में से एक यह है कि मौजूदा टाइपस्क्रिप्ट कोड के बारे में क्या किया जाए। यहां दो मुद्दे हैं: 1) मौजूदा कोड को एक नए कंपाइलर के साथ काम करना जो गैर-शून्य प्रकारों का समर्थन करता है और 2) कोड के साथ इंटरऑपरेट करना जिसे अपडेट नहीं किया गया है - पायथन 2/3 स्टाइल दलदल से बचना

हालांकि यह संभव होना चाहिए कि एक उपकरण प्रदान किया जाए जो इसे बनाने के लिए मौजूदा टीएस कोड का एक स्वचालित पुनर्लेखन करता है और इस सीमित मामले के लिए, कुछ ऐसा जो 2to3 की तुलना में बहुत बेहतर काम करता है जो पायथन के लिए किया था।

शायद एक क्रमिक प्रवासन कुछ इस तरह दिख सकता है:

1. संभावित रूप से शून्य प्रकार को इंगित करने के लिए '? टी' वाक्यविन्यास के लिए समर्थन पेश करें। प्रारंभ में इसका टाइप चेकिंग पर कोई प्रभाव नहीं पड़ता है, यह केवल दस्तावेज़ीकरण के लिए है।
2. एक उपकरण प्रदान करें जो '?T' का उपयोग करने के लिए मौजूदा कोड को ऑटो-रीराइट करता है। सबसे विनम्र कार्यान्वयन 'T' के सभी उपयोगों को '?T' में बदल देगा। एक बेहतर कार्यान्वयन यह जांच करेगा कि जिस कोड ने इस प्रकार का उपयोग किया है वह स्पष्ट रूप से माना जाता है कि यह गैर-शून्य था और उस मामले में 'टी' का उपयोग करें। कोड के लिए जो 'T' की अपेक्षा वाले पैरामीटर या संपत्ति के लिए '? T' प्रकार का मान निर्दिष्ट करने का प्रयास करता है, यह प्लेसहोल्डर में मान को लपेट सकता है जो दावा करता है (संकलन समय पर) कि मान गैर-शून्य है - उदाहरण के लिए let foo: T = expect(possiblyNullFoo) या let foo:T = possiblyNullFoo!
3. टूल को सभी प्रकार की परिभाषाओं और निश्चित रूप से टाइप किए गए रिपॉजिटरी में लागू करें
4. एक 'टी' की अपेक्षा वाले स्लॉट को '? टी' असाइन करने का प्रयास करते समय एक कंपाइलर चेतावनी पेश करें।
5. चेतावनियों को जंगली में सेंकने दें और सत्यापित करें कि पोर्टिंग प्रबंधनीय है और देखें कि परिवर्तन कैसे प्राप्त होता है
6. कंपाइलर की एक प्रमुख नई रिलीज़ में, 'T' त्रुटि की अपेक्षा वाले स्लॉट को '?T' असाइन करना।

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

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

मेरे यादृच्छिक विचार:

1. expect() भाग जटिल हो सकता है, इसे अच्छी तरह से सोचने की आवश्यकता होगी। न केवल असाइनमेंट हैं, बल्कि इंटरफेस, जेनरिक या पैरामीटर प्रकार हैं ...
2. मैं _थिंक_ टीएस में कोई चेतावनी नहीं है, केवल त्रुटियां हैं। अगर मैं सही हूं, तो मुझे यकीन नहीं है कि वे केवल उस सुविधा के लिए चेतावनियां पेश करेंगे।
3. यहां तक ​​कि अगर बहुत से लोग अपने कोड को अपग्रेड करते हैं, तो उद्यम ऐसा करने में बहुत धीमे हो सकते हैं, या बड़े मौजूदा कोडबेस के मामले में ऐसा कभी नहीं करना चाहेंगे। यह उस प्रमुख रिलीज़ को एक बड़ा ब्रेकिंग परिवर्तन बनाता है, कुछ ऐसा जो TS टीम नहीं चाहती है।

उस ने कहा, मैं अभी भी सोच रहा हूं कि शून्य त्रुटियों की रिपोर्ट करने के लिए "ऑप्ट-इन" ध्वज एक स्वीकार्य समाधान है। मुद्दा यह है कि ध्वज बंद होने पर समान कोड/परिभाषाओं का समान व्यवहार (त्रुटियों को घटाना) होना चाहिए, कुछ ऐसा जो मेरे पास अभी तक सोचने का समय नहीं है।

@ jods4 - expect() भाग के लिए, मेरी सोच यह है कि जहां भी आपके पास ?T , संकलक T | undefined देखता है ताकि आप यूनियन प्रकारों को संभालने के लिए नियमों का पुन: उपयोग कर सकें संभव।

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

इस चर्चा के लिए प्रासंगिक कुछ और - https://github.com/rwaldron/tc39-notes/blob/master/es6/2015-01/JSExperimentalDirections.pdf क्रोम टीम द्वारा प्रकार की जानकारी का उपयोग करने की जांच पर चर्चा करता है (टाइपस्क्रिप्ट-शैली के माध्यम से निर्दिष्ट) एनोटेशन) JS को ऑप्टिमाइज़ करने के लिए कंपाइलर में। वहाँ अशक्तता के बारे में एक खुला प्रश्न है - वे गैर-शून्य प्रकार चाहते हैं लेकिन व्यवहार्यता के बारे में भी निश्चित नहीं हैं।

बस यहाँ वापस झंकार करने वाला हूँ। मुझे आश्चर्य है कि हमने वास्तव में इसका समाधान नहीं किया है।

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

जैसा कि मैंने ऊपर कहा, शायद इसे केवल एक कोड अनुबंध कार्यान्वयन द्वारा हल किया जा सकता है।

आप अशक्त शाब्दिक का उपयोग करना क्यों नहीं छोड़ सकते और उन सभी स्थानों की रक्षा कर सकते हैं जहाँ
नल आपके कोड में रिसाव कर सकते हैं? इस तरह आप अशक्त से सुरक्षित रहेंगे
संदर्भ अपवाद हर जगह शून्य के लिए जांच किए बिना।
20 फरवरी 2015 को दोपहर 1:41 बजे, "इलेक्ट्रिकेसेंस" नोटिफिकेशन @github.com ने लिखा:

बस यहाँ वापस झंकार करने वाला हूँ। मुझे आश्चर्य है कि हमने वास्तव में हल नहीं किया है
यह वाला।

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

जैसा कि मैंने ऊपर कहा, शायद इसे केवल एक कोड अनुबंध द्वारा हल किया जा सकता है
कार्यान्वयन।

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

अपरिभाषित जांचों की तुलना में अशक्त जांच काफी तेज होती है।
21/02/2015 को 11:54 पूर्वाह्न को, "अलेक्सी बायकोव" नोटिफिकेशन @github.com ने लिखा:

आप अशक्त शाब्दिक का उपयोग करना क्यों नहीं छोड़ सकते और उन सभी स्थानों की रक्षा कर सकते हैं जहाँ
नल आपके कोड में रिसाव कर सकते हैं? इस तरह आप अशक्त से सुरक्षित रहेंगे
संदर्भ अपवाद हर जगह शून्य के लिए जांच किए बिना।
20 फरवरी, 2015 दोपहर 1:41 बजे, "इलेक्ट्रिकेसेंस" नोटिफिकेशन @github.com
लिखा था:

बस यहाँ वापस झंकार करने वाला हूँ। मुझे आश्चर्य है कि हमने वास्तव में हल नहीं किया है
यह वाला।

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

जैसा कि मैंने ऊपर कहा, शायद इसे केवल एक कोड अनुबंध द्वारा हल किया जा सकता है
कार्यान्वयन।

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

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

मेरा कहना है कि वे चेक अनावश्यक हैं (यदि नल कीवर्ड प्रतिबंधित है
और अन्य सभी स्थानों पर जहां वह आ सकता है पहरा दिया जाता है)।

क्यों? 1. बिना चेक वाला कोड कोड की तुलना में काफी तेज चलता है
नल के लिए चेक के साथ। 2. इसमें कम if's है और इसलिए अधिक पठनीय
और रखरखाव योग्य।
20 फरवरी 2015 को शाम 7:57 बजे, "ग्रिफ़ोर्क" नोटिफिकेशन @github.com ने लिखा:

अपरिभाषित जांचों की तुलना में अशक्त जांच काफी तेज होती है।
21/02/2015 को 11:54 पूर्वाह्न को, "अलेक्सी बायकोव" नोटिफिकेशन @github.com ने लिखा:

आप अशक्त शाब्दिक का उपयोग करना क्यों नहीं छोड़ सकते और उन सभी स्थानों की रक्षा कर सकते हैं जहाँ
नल आपके कोड में रिसाव कर सकते हैं? इस तरह आप अशक्त से सुरक्षित रहेंगे
संदर्भ अपवाद हर जगह शून्य के लिए जांच किए बिना।
20 फरवरी, 2015 दोपहर 1:41 बजे, "इलेक्ट्रिकेसेंस" नोटिफिकेशन @github.com
लिखा था:

बस यहाँ वापस झंकार करने वाला हूँ। मुझे आश्चर्य है कि हमने वास्तव में हल नहीं किया है
यह वाला।

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

जैसा कि मैंने ऊपर कहा, शायद इसे केवल एक कोड अनुबंध द्वारा हल किया जा सकता है
कार्यान्वयन।

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

.

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

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

आप बिंदु खो रहे हैं, हम अपरिभाषित जांच से बचने के लिए नल का उपयोग करते हैं।
और चूंकि हमारे आवेदन में एक सुसंगत स्थिति नहीं है, हम करते हैं, और
किसी वस्तु के बजाय अक्सर चीजों को अशक्त / अपरिभाषित होना पड़ता है
उसका प्रतिनिधित्व करते हैं।
21/02/2015 को दोपहर 12:20 बजे, "एलेक्सी बायकोव" नोटिफिकेशन @github.com ने लिखा:

मेरा कहना है कि वे चेक अनावश्यक हैं (यदि नल कीवर्ड प्रतिबंधित है
और अन्य सभी स्थानों पर जहां वह आ सकता है पहरा दिया जाता है)।

क्यों? 1. बिना चेक वाला कोड कोड की तुलना में काफी तेज चलता है
नल के लिए चेक के साथ। 2. इसमें कम if's है और इसलिए अधिक पठनीय
और रखरखाव योग्य।
20 फरवरी 2015 को शाम 7:57 बजे, "ग्रिफ़ोर्क" नोटिफिकेशन @github.com ने लिखा:

अपरिभाषित जांचों की तुलना में अशक्त जांच काफी तेज होती है।
21/02/2015 11:54 पूर्वाह्न पर, "एलेक्सी बायकोव" सूचनाएं @github.com
लिखा था:

आप अशक्त शाब्दिक का उपयोग करना क्यों नहीं छोड़ सकते और सभी स्थानों की रक्षा कर सकते हैं
कहाँ पे
नल आपके कोड में रिसाव कर सकते हैं? इस तरह आप अशक्त से सुरक्षित रहेंगे
संदर्भ अपवाद हर जगह शून्य के लिए जांच किए बिना।
20 फरवरी, 2015 दोपहर 1:41 बजे, "इलेक्ट्रिकेसेंस" नोटिफिकेशन @github.com
लिखा था:

बस यहाँ वापस झंकार करने वाला हूँ। मुझे आश्चर्य है कि हमने वास्तव में नहीं किया है
हल किया
यह वाला।

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

जैसा कि मैंने ऊपर कहा, शायद इसे केवल एक कोड द्वारा हल किया जा सकता है
ठेके
कार्यान्वयन।

इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें
<

https://github.com/Microsoft/TypeScript/issues/185#issuecomment -75295204

.

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

.

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

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

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

class Nothing { public 'i am nothing': Nothing; }
class Something { 
    constructor(
    public name: string,
    public value: number
   ) { }
}
var nothing = new Nothing();
var whoami = Math.random() > 0.5 ? new Something('meh', 66) : nothing;

if (whoami instanceof Nothing) {
    console.log('i am a null killer');
} else if (whoami instanceof Something) {
    console.log(whoami.name + ': ' + whoami.value);
}

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

कितना मजेदार था वो?

क्या आपको लगता है कि चेक का एक इंस्टेंस एक नल चेक की तुलना में तेज़ है, a
एप्लिकेशन जिसे प्रति सेकंड इनमें से सैकड़ों करना है?
मुझे इसे इस तरह से रखने दें: हमें कार्यों के लिए उपनाम बनाना पड़ा है क्योंकि
'.' का उपयोग न करना तेज़ है। एक्सेसर्स
21/02/2015 को दोपहर 12:58 बजे, "अलेक्सी बायकोव" नोटिफिकेशन @github.com ने लिखा:

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

कक्षा कुछ भी नहीं {सार्वजनिक 'मैं कुछ भी नहीं हूं': कुछ भी नहीं; }
कक्षा कुछ {
निर्माता (
सार्वजनिक नाम: स्ट्रिंग,
सार्वजनिक मूल्य: संख्या
) { }
}
वर कुछ नहीं = नया कुछ नहीं ();
वर whoami = Math.random() > 0.5 ? नया कुछ ('मेह', 66): कुछ नहीं;

अगर (जोमी उदाहरण कुछ भी नहीं) {
// हूमी कुछ भी नहीं है
कंसोल.लॉग ('मैं एक अशक्त हत्यारा हूँ');
} और अगर (व्हामी इंस्टेंसऑफ समथिंग) {
// whoami कुछ का उदाहरण है
कंसोल.लॉग (व्हामी.नाम + ':' + whoami.value);
}

तो बस एक अशक्त या अपरिभाषित का उपयोग किए बिना एक लापता मान को एन्कोड किया गया।
यह भी ध्यान दें कि हम इसे _100% स्पष्ट तरीके से_ कर रहे हैं। टाइप करने के लिए धन्यवाद
गार्ड, ऐसा कोई तरीका नहीं है जिससे किसी मूल्य को पढ़ने से पहले कोई चेक छूट न जाए।

कितना मजेदार था वो?

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

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

साथ ही, यह उन मुद्दों पर भी ध्यान नहीं देता है जो अप्रारंभीकृत चर के साथ होंगे जो कि undefined । हास्केल में, समस्या भी मौजूद नहीं है क्योंकि आप "अनियमित" मान नहीं छोड़ सकते हैं।

@ ग्रिफोर्क , मुझे नहीं लगता, मैं परीक्षण चलाता हूं, परीक्षण कहता है कि यह ब्राउज़र पर निर्भर करता है।
http://jsperf.com/nullable-vs-null-vs-undefined-vs-instanceof
हालांकि मुझे लगता है कि आपको सुरक्षा और प्रदर्शन के बीच संतुलन खोजने की जरूरत है। फिर आपको इसे अनुकूलित करने का प्रयास करने से पहले अपने प्रदर्शन को ध्यान से मापने की आवश्यकता है। संभावना है कि आप कुछ ऐसा ठीक कर रहे हैं जो टूटा नहीं है और आपकी अशक्त जाँच है जिसके बारे में आप इतने चिंतित हैं कि समग्र प्रदर्शन का 2% से कम हो सकता है, यदि ऐसा है तो यदि आप इसे दोगुना तेजी से करते हैं तो आपको केवल 1% लाभ होगा।

@spion , सभी चीजों को माना जाता है कि यह आपके कोड में नल का उपयोग करने की तुलना में एक बहुत अच्छा तरीका है, वर्तमान स्थिति और गैर-नलबल उनके साथ आने वाली समस्याओं को देखते हुए

हमारा कोड आधार 800 से अधिक टाइपस्क्रिप्ट फ़ाइलें और कोड की 120000 से अधिक पंक्तियाँ हैं
और जब मॉडलिंग व्यवसाय की बात आती है तो हमें कभी भी शून्य या अपरिभाषित की आवश्यकता नहीं होती है
डोमेन संस्थाएं। और यद्यपि हमें डोम जोड़तोड़ के लिए नल का उपयोग करना था,
ऐसे सभी स्थानों को सावधानीपूर्वक अलग-थलग कर दिया जाता है, ताकि नल के रिसाव का कोई रास्ता न हो
में। मैं आपका तर्क नहीं खरीदता कि नल की आवश्यकता हो सकती है, वहां हैं
बिना नल के (हास्केल) या शून्य के साथ उत्पादन के लिए तैयार भाषाएँ
प्रतिबंधित (एफ #)।
22 फरवरी 2015 को सुबह 9:31 बजे, "जॉन" नोटिफिकेशन @github.com ने लिखा:

@ एलेक्सी-बायकोव https://github.com/aleksey-bykov एक व्यावहारिक से
परिप्रेक्ष्य, आप शून्य को अनदेखा नहीं कर सकते। यहां कुछ पृष्ठभूमि दी गई है कि आप ऐसा क्यों करेंगे
वैसे भी एक शून्य प्रकार की आवश्यकता है:
https://www.google.com/patents/US7627594?ei=P4XoVPCaEIzjsATm4YGoBQ&ved=0CFsQ6AEwCTge

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

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

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

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

यदि आप ऊपर भी पढ़ते हैं, तो गैर-अशक्त प्रस्ताव भी अपरिभाषित को कवर करता है।

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

दोबारा, शायद चिंता करने लायक नहीं है, जब तक (हमारी तरह), आप <10ms में 10,000 चेक कर रहे हैं।

(और हाँ, हम वास्तव में हमारे आवेदन के प्रदर्शन पर नज़र रखने और एक अड़चन खोजने के कारण बदल गए हैं)

मैं इसके बारे में कुछ चर्चा करना चाहता हूं। कल ही बिल्ड वीडियो में मैंने एनालाइज़र को C# में लागू होते देखा। मैंने टाइपस्क्रिप्ट के समान लागू करने के लिए एक मुद्दा #3003 खोला।

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

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

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

प्रतिक्रिया का स्वागत है!

मैंने अभी पूरे सूत्र को पढ़ा।

मुझे लगता है कि प्रस्ताव को non-voidable और voidable शर्तों का उपयोग करना चाहिए, क्योंकि TS युक्ति में void null और undefined मान के लिए एक प्रकार है . (मुझे लगता है कि प्रस्ताव में अपरिभाषित मूल्य भी शामिल है: मुस्कान:)

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

कृपया इसे जोड़ें! और यह सबसे अच्छा होगा यदि यह एक विशेषता बन जाए तो मैं इसे डिफ़ॉल्ट बनाने के लिए एक ध्वज पास कर सकता हूं। यह बहुत से लोगों के लिए बहुत सारे डिबगिंग नरक को बचाएगा।

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

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

मैं इसे समस्या के समाधान के रूप में एडीटी के बारे में सोचने में एक बड़ी खामी के रूप में देखता हूं ...

1. एक डिज़ाइन पैटर्न के माध्यम से एडीटी उपलब्ध कराएं (मूल की कमी के कारण)
   टाइपस्क्रिप्ट से समर्थन)
2. null कीवर्ड को मना करें
3. उन सभी जगहों की रक्षा करें जहां नल बाहर से आपके कोड में लीक हो सकते हैं
4. अच्छी के लिए चली गई null समस्या का आनंद लें

हमारे प्रोजेक्ट पर हम चरण 1, 2 और 3 करने में कामयाब रहे। लगता है कि हम क्या कर रहे हैं
अभी।

@ अलेक्सी-बायकोव

आप (2) undefined साथ कैसे करते हैं? यह कई तरह की स्थितियों में उत्पन्न हो सकता है जिसमें undefined कीवर्ड शामिल नहीं है: अप्रारंभीकृत वर्ग के सदस्य, वैकल्पिक फ़ील्ड, सशर्त शाखाओं में लापता रिटर्न स्टेटमेंट ...

टाइपस्क्रिप्ट की तुलना फ्लोटाइप से करें । कम से कम प्रवाह ज्यादातर मामलों से संबंधित है।

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

यह विभिन्न स्थितियों में उत्पन्न हो सकता है जिसमें अपरिभाषित कीवर्ड शामिल नहीं है...

• अप्रारंभीकृत वर्ग के सदस्य - कक्षाएं निषिद्ध
• वैकल्पिक फ़ील्ड - वैकल्पिक फ़ील्ड/पैरामीटर निषिद्ध
• लापता रिटर्न स्टेटमेंट - एक कस्टम tslint नियम जो सुनिश्चित करता है कि सभी निष्पादन पथ वापस आ जाएं

प्योरस्क्रिप्ट का उपयोग करना बेहतर है

• मेरी इच्छा है, लेकिन यह वह कोड है जो कम से कम चिंता प्रदर्शन उत्पन्न करता है

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

आप वैकल्पिक क्षेत्रों को छोड़ने का जिक्र करते हैं लेकिन उनका उपयोग कई जेएस पुस्तकालयों द्वारा किया जाता है। आपने उन पुस्तकालयों से निपटने के लिए क्या किया?

आप कक्षाओं का उपयोग न करने का भी जिक्र करते हैं। मुझे लगता है कि आप उन पुस्तकालयों से भी बचते हैं जो कक्षाओं पर भरोसा करते हैं (या भरोसा करेंगे) (जैसे प्रतिक्रिया)?

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

यह मजाकिया है कि आपको लगता है कि एडीटी का एकमात्र उद्देश्य एक लापता मूल्य का प्रतिनिधित्व करना है जो अन्यथा शून्य से एन्कोड किया गया होता

मैं इसके बजाय यह कहूंगा कि "शून्य" समस्या चली गई है (और कक्षाएं भी) सभी अच्छी चीजों का उप-उत्पाद है जो एडीटी हमें लाता है

आपकी जिज्ञासा को संबोधित करते हुए, प्रदर्शन के लिए टाइट लूप और बड़े डेटा स्ट्रक्चर जैसे महत्वपूर्ण टुकड़ों का उपयोग हम तथाकथित Nullable<a> एब्स्ट्रैक्शन का उपयोग टाइपस्क्रिप्ट को यह सोचकर मूर्ख बनाकर करते हैं कि यह एक लिपटे मूल्य से संबंधित है, लेकिन वास्तव में (रनटाइम पर) ऐसा मूल्य बस है एक आदिम जिसे नल लेने की अनुमति है, नलबल पर संचालन का विशेष सेट है जो उस नल को लीक होने से रोकता है

अगर आप विवरण जानना चाहते हैं तो मुझे बताएं

interface Nullable<a> {
    'a nullable': Nullable<a>;
    'uses a': a;
}
/*  the following `toNullable` function is just for illustration, we don't use it in our code,
    because there are no values capable of holding naked null roaming around,
    instead we just alter the definition of all unsafe external interfaces:
    // before
    interface Array<T> {
       find(callback: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T;
    }
    // after
    interface Array<a> {
       find(callback: (value: a, index: number, array: a[]) => boolean, thisArg: any): Nullable<a>;
    }
*/
function toNullable<a>(value: a) : Nullable<a> {
    return <any>value;
}
function toValueOrDefault<a>(value: Nullable<a>, defaultValue: a)  : a {
    return value != null ? <any>value : defaultValue;
}

पुनरावर्ती प्रकार की संरचना का उपयोग क्यों करें? 'a nullable': a पर्याप्त होना चाहिए, नहीं?

मुझे लगता है कि आपके पास सभी बाहरी कार्यों से निपटने के लिए callFunctionWithNullableResult<T,U>(f: (T) => U, arg:T):Nullable<U> (विभिन्न धर्मार्थ कार्यों के लिए अन्य सभी अधिभार सहित) है जो नल लौटाते हैं?

और यदि एक लिंटर द्वारा अशक्त कीवर्ड निषिद्ध है, तो आप " Nothing " को एक अशक्त में संग्रहीत कैसे प्राप्त करते हैं? क्या आप विशेष मामले toNullable(null) ?

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

पुनरावर्ती प्रकार की संरचना का उपयोग क्यों करें? 'एक अशक्त': एक पर्याप्त होना चाहिए, नहीं?

ठीक है, इस उदाहरण में यह पर्याप्त है, लेकिन इसे इस तरह करने से ऐसे क्षेत्र का उद्देश्य अधिभारित हो जाता है, जो 2 अलग-अलग मामलों में कार्य करता है:

• नाममात्र में टाइप करने के लिए (आपके उदाहरण में दर्ज नाम): https://gist.github.com/aleksey-bykov/0ab85f0b5e83fc848f85
• इसे एक सामान्य प्रकार के पैरामीटर के बारे में जागरूक करने के लिए, इसलिए इसका हिसाब वस्तु की सतह (आपके उदाहरण में मान का प्रकार) तक है: https://github.com/Microsoft/TypeScript/issues/468

मैं व्यक्तिगत रूप से अतिभारित से नफरत करता हूं, यही कारण है कि मैं 2 अलग छद्म क्षेत्रों के साथ जाता हूं जहां प्रत्येक एक अलग समस्या हल करता है

मुझे लगता है कि आपके पास callFunctionWithNullableResult . भी है(एफ: टी -> यू, तर्क: टी) => अशक्त

नहीं, जैसा कि मैंने कहा, हम परिभाषा (* .d.ts) फाइलों को बदल देते हैं, जो हमारे पास सबूत हैं, बाहरी कोड में Nullable "आवरण" के साथ शून्य हो सकते हैं, टिप्पणी में उदाहरण देखें मेरे पिछले संदेश में

आप एक अशक्त में संग्रहीत "कुछ नहीं" कैसे प्राप्त करते हैं?

हम नल को नलबल में संग्रहीत नहीं करते हैं, नलबल सर्वर से आते हैं (जिस पर हमारा सीमित नियंत्रण होता है) या बाहरी एपीआई से, जैसे ही यह हमारे कोड में होता है यह नलबल में लपेटा जाता है, लेकिन हमारा कोड उत्पादन करने में सक्षम नहीं है वसीयत में एक अशक्त, हम केवल किसी दिए गए अशक्त को दूसरे अशक्त में बदल सकते हैं, लेकिन पतली हवा से बाहर नहीं बना सकते

टाइपस्क्रिप्ट की यूनियनें + उपयोगकर्ता परिभाषित प्रकार के गार्ड नहीं कर सकते हैं

हा! मैं यूनियन प्रकारों का बिल्कुल भी प्रशंसक नहीं हूं और घंटों बात कर सकता हूं कि उन्हें क्या बुरा लगता है

अपने प्रश्न पर वापस, मुझे यूनियनों और टाइप गार्डों का उपयोग करके Either a b पुन: प्रयोज्य समकक्ष दें
(एक संकेत: https://github.com/Microsoft/TypeScript/issues/2264)

आपके उदाहरण के प्रकार अधिक नाममात्र नहीं हैं क्योंकि वे पुनरावर्ती हैं - वे "छद्म-नाममात्र" रहते हैं।

हालांकि आपके प्रश्न का उत्तर देने के लिए: आप सामान्य या तो लागू नहीं करते हैं, ठीक है क्योंकि प्रकार नाममात्र नहीं हैं। आप बस उपयोग करें

type MyType = A | B

और फिर A और B लिए टाइप गार्ड का उपयोग करें ... बोनस के रूप में यह प्रत्येक मौजूदा जेएस लाइब्रेरी के साथ भी काम करता है: उदाहरण के लिए Thenable जांच करने का मूर्खतापूर्ण तरीका है यदि वहां है वस्तु से जुड़ी एक then विधि है। क्या उसके लिए टाइप गार्ड काम करेगा? सबसे निश्चित रूप से।

हा! यह आपकी बहुत अच्छी पकड़ है। खैर, कंपाइलर के हाल के संस्करणों में कुछ बदल गया होगा। यहाँ बुलेटप्रूफ नाममात्र है:

enum GottaBeNonimalBrand {}
interface GottaBeNonimal {
     branded: GottaBeNonimalBrand;
}
function toGottaBeNominal() : GottaBeNominal {
   return <any> {};
}

एक सेकंड रुको! तुमने धोखा दिया ! अच्छा पुराना तरीका अभी भी एक आकर्षण की तरह काम करता है।

हालांकि आपके प्रश्न का उत्तर देने के लिए: आप सामान्य या तो लागू नहीं करते हैं, ठीक है क्योंकि प्रकार नाममात्र नहीं हैं। आप बस उपयोग करें ...

आप जो कहते हैं वह अच्छा है, हालांकि यह Either कैसा है? वह प्रामाणिक Either सामान्य है और इसके चारों ओर कुछ 30 मानक सुविधा कार्य हैं, अब आप कह रहे हैं कि मुझे हल करने की आवश्यकता है (नाममात्र) और उन सभी कार्यों के लिए 30 x number_of_combinations_of_any_2_types_in_my_app सभी संभावित जोड़े के लिए हैं जो मैं कर सकता हूं मुठभेड़?

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

C# अगला विचार मंथन (संक्षेप में)

मूल रूप से, C# में आपके पास गैर-शून्य मान प्रकार हैं, जैसे कि int । फिर C# 2.0 में हमें अशक्त मान प्रकार मिले, जैसे कि int? । संदर्भ हमेशा अशक्त रहे हैं, लेकिन वे इसे बदलने और समान सिंटैक्स लागू करने के बारे में सोच रहे हैं: string कभी भी अशक्त नहीं होता, string? हो सकता है।

बेशक, बड़ा मुद्दा यह है कि इससे string का अर्थ बदल जाता है और कोड टूट जाता है। जहां null को string पर असाइन/वापस करना ठीक था, अब यह एक त्रुटि है। C# टीम उन त्रुटियों को "अक्षम" करने के बारे में सोच रही है जब तक कि आप ऑप्ट-इन नहीं करते। string? में डॉट करना हमेशा एक त्रुटि है, क्योंकि सिंटैक्स नया है और पहले इसकी अनुमति नहीं थी (इसलिए यह एक ब्रेकिंग परिवर्तन नहीं है)।
दूसरी समस्या अन्य पुस्तकालयों आदि के साथ है। इसका समाधान करने के लिए, वे प्रति फ़ाइल या असेंबली में ऑप्ट-इन फ़्लैग बनाना चाहते हैं। इसलिए बाहरी कोड जो सख्त प्रकार की प्रणाली में शामिल होता है, उसे लाभ मिलता है, और पुराने विरासत कोड और पुस्तकालय काम करना जारी रखते हैं।

वह टीएस में कैसे स्थानांतरित हो सकता है?

1. हम एक गैर-शून्य प्रकार के ऑप्ट-इन ध्वज का परिचय देते हैं। यह वैश्विक (कंपाइलर को पास) या प्रति फ़ाइल हो सकता है। यह .d.ts लिए हमेशा प्रति-फ़ाइल होना चाहिए।
2. मूल प्रकार अशक्त नहीं हैं, उदाहरण के लिए number । एक नया null प्रकार है।
3. number? केवल number | null लिए एक शॉर्टकट है।
4. यह सुविधा अशक्त प्रकारों के लिए नई त्रुटियों का परिचय देती है, जैसे (x: string?) => x.length बिना टाइप गार्ड के।
5. यह सुविधा गैर-शून्य प्रकारों के लिए नई त्रुटियां पेश करती है, जैसे असाइन करें let x: string = null;
6. ऑप्ट-इन के दायरे से बाहर घोषित गैर-शून्य प्रकार में हेरफेर करते समय, 5 के तहत रिपोर्ट की गई त्रुटियों को अनदेखा कर दिया जाता है। _यह कहने से थोड़ा अलग है कि string को अभी भी string? माना जाता है।_

यह क्या अच्छा है?

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

जब मैं पुराने कोड का उपयोग करता हूं, तो मैं नई फाइलों के लिए ऑप्ट-इन कर सकता हूं। मैं किसी भी तरह से string? घोषित कर सकता हूं और उचित नल जांच के बिना सदस्यों तक पहुंचने पर त्रुटियां प्राप्त कर सकता हूं। मुझे उन पुस्तकालयों के लिए लाभ और सख्त जाँच भी मिलती है जिनकी परिभाषाएँ अद्यतन की गई हैं। एक बार .d.ts ऑप्ट इन करने के बाद, null को length(x: string): number रूप में परिभाषित फ़ंक्शन में पास करना एक त्रुटि बन जाता है।
_(नोट: string? भी एक त्रुटि है, हालांकि ऑप्ट-आउट कोड से string करना नहीं है।)_

जब तक मैं ऑप्ट-इन नहीं करता, तब तक कोई महत्वपूर्ण परिवर्तन नहीं होता है।

तुम क्या सोचते हो?

बेशक, व्यवहार में यह सुविधा कैसे काम करेगी, इस पर विचार करने के लिए बहुत कुछ है। लेकिन क्या ऐसी ऑप्ट-इन योजना कुछ ऐसी है जिस पर TS टीम विचार भी कर सकती है?

यह आश्चर्यजनक है कि कैसे लोग एक ऑटोमोबाइल के बजाय एक तेज़ घोड़ा चाहते हैं..

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

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

@ एलेक्सी-बायकोव और निश्चित रूप से बेहतर प्रकार के प्रतिबंध प्राप्त करने के लिए आप उच्च प्रकार के प्रकार लागू करते हैं, और व्युत्पन्न उदाहरण प्राप्त करने के लिए आप टाइपक्लास लागू करते हैं और इसी तरह आगे। यह टाइपस्क्रिप्ट के "ES6+ के साथ संरेखित करें" डिज़ाइन लक्ष्य के साथ कैसे फिट बैठता है?

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

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

प्योरस्क्रिप्ट के साथ आपकी प्रदर्शन समस्या क्या है? क्या यह व्यापक करी द्वारा उत्पादित क्लोजर है?

@ jods4 इसका मतलब यह है कि वर्तमान में मौजूद सभी .d.ts फाइलों को आउट-ऑफ-वर्क फ्लैग के साथ अपडेट करने की आवश्यकता होगी, या यह कि प्रोजेक्ट-वाइड सेटिंग .d.ts (और .d.ts) को प्रभावित नहीं करती है। बिना झंडे के हमेशा 'पुराना' तरीका माना जाता है।
यह कितना समझ में आता है (क्या यह कई परियोजनाओं पर काम करने वाले लोगों के लिए समस्या या .d.ts फाइलें पढ़ते समय भ्रम पैदा करने वाला है)?
नए और पुराने (लाइब्रेरी) कोड के बीच इंटरफ़ेस कैसा दिखेगा। क्या यह (कुछ मामलों में) अनावश्यक जांच और कास्ट (शायद एक बुरी बात नहीं है, लेकिन यह भाषा से शुरुआती लोगों को बंद कर सकता है) के एक समूह से अटे पड़े होंगे?
अधिकतर मैं (अब) गैर-शून्य प्रकारों के विचार को पसंद करता हूं, और @ jods4 और ! सुझाव द्वारा सुझाव ही एकमात्र तरीका है जिससे मैं गैर-शून्य प्रकारों को काम कर रहा हूं (विज्ञापनों को अनदेखा कर रहा हूं)।

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

दूसरी छोटी बात यह है कि हर कोई undefined को एक स्थिरांक या एक कीवर्ड मान रहा है। तकनीकी रूप से यह भी नहीं है। वैश्विक संदर्भ में, एक चर/संपत्ति undefined जो आदिम प्रकार की है undefined । null एक शाब्दिक है (जो कि आदिम प्रकार का भी होता है null , हालांकि यह एक लंबे समय से चली आ रही बग रही है कि इसे typeof "object" वापस करने के लिए लागू किया गया है)। ईसीएमएस्क्रिप्ट में, ये दो चीजें काफी अलग हैं।

@kitsonk
समस्या यह है कि सभी प्रकार शून्य हो सकते हैं, और सभी प्रकार अपरिभाषित हो सकते हैं, लेकिन एक विशिष्ट प्रकार पर काम करने वाले सभी ऑपरेशन शून्य या अपरिभाषित मानों (जैसे विभाजित) पर काम नहीं करते हैं, जिससे त्रुटियां होती हैं।
वे जो चाहते हैं वह एक प्रकार को निर्दिष्ट करने की क्षमता है "एक संख्या है और कभी भी शून्य या अपरिभाषित नहीं है" ताकि वे यह सुनिश्चित कर सकें कि किसी फ़ंक्शन का उपयोग करते समय जिसमें शून्य या अपरिभाषित प्रोग्रामर शुरू करने की संभावना है, अमान्य मानों के खिलाफ सुरक्षा करना जानता है।
मान निर्दिष्ट करने में सक्षम होने के लिए दो मुख्य तर्क हैं जैसे "यह प्रकार है लेकिन शून्य या अपरिभाषित नहीं हो सकता" ये हैं:
ए) कोड का उपयोग करने वाले सभी प्रोग्रामर के लिए यह स्पष्ट है कि यह मान कभी भी शून्य या अपरिभाषित नहीं होना चाहिए।
बी) संकलक लापता प्रकार के गार्ड को पकड़ने में मदद करता है।

एक चर/संपत्ति अपरिभाषित है जो आदिम प्रकार की अपरिभाषित है। नल एक शाब्दिक है (जो कि आदिम प्रकार का भी होता है null

@kitsonk यह इस मुद्दे के लिए एक महान तर्क है; null एक number , यह Person तुलना में Car है। यह अपने ही प्रकार का है और यह मुद्दा टाइपस्क्रिप्ट को यह भेद करने की अनुमति देने के बारे में है।

@kitsonk मुझे लगता है कि सबसे आम त्रुटि में से एक शून्य संदर्भ/पहुंच अपरिभाषित त्रुटियां है। किसी गुण या चर को शून्य/अपरिभाषित न होने के लिए निर्दिष्ट करने की क्षमता होने से सॉफ़्टवेयर कोड अधिक ध्वनिमय हो जाएगा। और LS जैसे टूल को भी इस तरह के बग्स को पकड़ने दें https://github.com/Microsoft/TypeScript/issues/3692।

स्पष्टीकरण के लिए धन्यवाद। हो सकता है कि मैं यहाँ फिर से कुछ याद कर रहा हूँ, इस पर पीछे मुड़कर देखने के बाद ... चूंकि टाइपस्क्रिप्ट में पहले से ही एक "वैकल्पिकता" तर्क है, निम्नलिखित प्रस्ताव के रूप में काम क्यों नहीं करेंगे?

interface Mixed {
    optional?: string;
    notOptional: string;
    nonNullable!: string;
}

function mixed(notOptional: string, notNullable!: string, optional?: string): void {}

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

चूंकि टाइपस्क्रिप्ट में पहले से ही एक "वैकल्पिकता" तर्क है, निम्नलिखित प्रस्ताव के रूप में काम क्यों नहीं करेंगे?

टीएस में अभी विकल्पों को स्पष्ट करने के लिए केवल आरंभीकरण के दौरान वैकल्पिक हैं। Null और undefined अभी भी सभी प्रकार के लिए असाइन करने योग्य है।

ये वैकल्पिक के कुछ अनपेक्षित मामले हैं

interface A {
   a?: string;
}
let a: A = {} // ok as expected

interface B {
   b: string;
}
let b1: B = { b: undefined } //ok, but unintuitive
let b2: B = { b: null } // ok, but unintuitive
let b3: B = {} // error as expected

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

? को संपत्ति/तर्क नाम से रखा गया है क्योंकि यह उस नाम के _existence_ को संदर्भित करता है या नहीं। @tinganho ने इसे अच्छी तरह समझाया। अपना उदाहरण बढ़ाते हुए:

function foo(arg: string, another?: string) {
  return arguments.length;
}

var a: A = {};
a.hasOwnProperty('a') // false
foo('yo') // 1, because the second argument is _non-existent_.
foo(null) // this is also ok, but unintuitive

गैर-शून्य ! किसी नाम के _existence_ से असंबंधित है। यह प्रकार से संबंधित है, इसलिए इसे प्रकार द्वारा रखा जाना चाहिए। प्रकार गैर-शून्य है।

interface C {
  c: !string;
}

let c1: C = { }; // error, as expected
let c2: C = { c: null }; // error, finally!
let c3: C = { c: 'str' }; // ok! :)

function bar(arg: !string) {
  return arg.length;
}

bar(null) // type error
bar('foo') // 3

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

@kitsonk यह हल करने वाली समस्या बग को कम कर रही है क्योंकि लोग मानते हैं कि जब कुछ हो सकता है तो कुछ शून्य नहीं है, या उन कार्यों में नल पास करें जो इसका समर्थन नहीं करते हैं। यदि आप कई लोगों के साथ बड़ी परियोजनाओं पर काम करते हैं तो आप उन कार्यों का उपभोग कर सकते हैं जिन्हें आपने नहीं लिखा था। या आप तृतीय पक्ष पुस्तकालयों का उपभोग कर सकते हैं जिन्हें आप अच्छी तरह से नहीं जानते हैं। जब आप करते हैं: let x = array.sum(x => x.value) , क्या आप मान सकते हैं कि x कभी भी शून्य नहीं होता है? शायद यह 0 है अगर सरणी खाली है? आपको कैसे मालूम? क्या आपके संग्रह में x.value === null ? क्या यह sum() फ़ंक्शन द्वारा समर्थित है या यह एक त्रुटि होने जा रहा है?
इस सुविधा के साथ उन मामलों की सांख्यिकीय रूप से जाँच की जाती है और किसी ऐसे फ़ंक्शन के लिए संभावित रूप से शून्य मान पास करना जो इसका समर्थन नहीं करता है या बिना चेक के संभावित रूप से शून्य मान का उपभोग करता है, त्रुटियों के रूप में रिपोर्ट किया जाता है।
मूल रूप से, पूरी तरह से टाइप किए गए प्रोग्राम में, अब कोई "NullReferenceException" नहीं हो सकता है (दुर्भाग्य से undefined से संबंधित माइनस कॉर्नर केस)।

वैकल्पिक मापदंडों के बारे में चर्चा असंबंधित है। अशक्त या नहीं की अनुमति देना प्रकार प्रणाली से संबंधित है, न कि चर/पैरामीटर घोषणाओं से और यह टाइप गार्ड, यूनियन और चौराहे के प्रकारों आदि के साथ अच्छी तरह से एकीकृत होता है।

टाइप _void_ का कोई मान नहीं है लेकिन null और undefined मान इसे असाइन करने योग्य हैं

यहाँ एक अच्छा सारांश है: https://github.com/Microsoft/TypeScript/issues/185#issuecomment -71942237

@jbondc मुझे लगता है कि मैंने हाल ही में कल्पना की जाँच की। void null और undefined लिए एक छत्र शब्द है। void 0 बारे में नहीं जानते, लेकिन मुझे लगता है कि void भी इसकी छतरी के नीचे है।

संदर्भ: https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#324 -the-void-type

अनुमान any । लेकिन null और undefined अभी भी सभी प्रकार के लिए असाइन करने योग्य है।

void 0 हमेशा undefined भी http://stackoverflow.com/a/7452352/449132 लौटाता है

@jbondc यदि प्रश्न एक पोटेंशियल नल-

function returnsNull() {
  return null;
}

null प्रकार का अनुमान लगाना चाहिए।

undefined आसपास बहुत सारे कोने के मामले हैं और ईमानदार होने के लिए मैं (अभी तक?) निश्चित नहीं हूं कि इससे निपटने का सबसे अच्छा तरीका क्या है। लेकिन इसके बारे में सोचने में बहुत समय बिताने से पहले मैं जानना चाहता हूं कि टीएस टीम ऑप्ट-इन रणनीति के साथ ठीक होगी या नहीं।

पिछली बार जब मैंने इस चर्चा में भाग लिया था, तो यह समाप्त हो गया था: "हम ब्रेकिंग परिवर्तन नहीं करेंगे और हम परिवेश के झंडे/विकल्पों के आधार पर स्रोत कोड के अर्थ को बदलना नहीं चाहते हैं"। ऊपर जो विचार मैं वर्णित कर रहा हूं वह एक ब्रेकिंग परिवर्तन नहीं है और स्रोत व्याख्या के संबंध में अपेक्षाकृत अच्छा है, हालांकि 100% नहीं। वह ग्रे क्षेत्र इसलिए मैं पूछता हूं कि TS टीम क्या सोचती है।

@ jods4 मैं अनुमानित any पसंद करूंगा, जो मौजूदा सिंटैक्स को बनाए रखेगा। और एक ऑप्ट-इन रणनीति बेहतर होगी। [1]

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

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

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

@impinball

मैं अनुमानित अशक्त any पसंद करूंगा, जो मौजूदा सिंटैक्स को बनाए रखेगा। और एक ऑप्ट-इन रणनीति बेहतर होगी।

मैंने अपना जवाब यहां संपादित किया है। इसके बारे में और सोचने पर, मुझे कोई उपयोगी मामला नहीं दिख रहा है जहां आप केवल null प्रकार का अनुमान लगा सकते हैं। जैसे: () => null या let x = null या function y() { return null } ।

इसलिए मैं सहमत हूं कि any का अनुमान लगाना जारी रखना शायद एक अच्छी बात है।

1. यह पिछड़ा संगत है।
2. वैसे भी वे सभी मामले noImplicitAny तहत त्रुटियां हैं।
3. यदि आपके पास एक अजीब मामला है जहां आप ऐसा करना चाहते हैं और यह आपके लिए उपयोगी है, तो आप स्पष्ट रूप से इस प्रकार की घोषणा कर सकते हैं: (): null => null या let x: null = null या function y(): null { return null } ।

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

यह कहना कि string वास्तव में अर्थ है string! | null एक और विकल्प हो सकता है। यह ध्यान दिया जाना चाहिए कि यदि आप उपरोक्त सभी चर्चाओं को पढ़ते हैं, तो यह पहली बार प्रस्तावित था क्योंकि उम्मीद थी कि यह मौजूदा कोड के साथ अधिक संगत होगा ( string का वर्तमान अर्थ नहीं बदल रहा है)। लेकिन वास्तव में निष्कर्ष यह था कि फिर भी, बड़ी मात्रा में कोड वैसे भी तोड़ा जाएगा।

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

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

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

[1] इसे डिफ़ॉल्ट बनाने के लिए एक ध्वज पेश करना व्यावहारिक कारणों से पहली जगह में अच्छी तरह से काम नहीं करेगा।

हां यह बिना किसी बदलाव के मौजूदा कोड बेस के लिए अच्छा काम नहीं करेगा। लेकिन:

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

@jods4

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

मेरा मतलब उस अर्थ में नहीं था। मेरा मतलब था कि अशक्त तारों की तुलना में अशक्त संख्याओं के लिए उपयोग का मामला कम है। मैं उस सुझाव से जुड़ा नहीं हूं, वैसे भी (मुझे किसी भी तरह से परवाह नहीं है)।

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

किस माध्यम से? मुझे विश्वास नहीं है कि आप वर्तमान में फ़ाइल-दर-फ़ाइल आधार पर कंपाइलर को कॉन्फ़िगर कर सकते हैं। मैं यहां गलत साबित होने के लिए तैयार हूं।

@impinball

किस माध्यम से? मुझे विश्वास नहीं है कि आप वर्तमान में फ़ाइल-दर-फ़ाइल आधार पर कंपाइलर को कॉन्फ़िगर कर सकते हैं। मैं यहां गलत साबित होने के लिए तैयार हूं।

शायद मैं गलत हूँ। मैंने कभी उनका उपयोग नहीं किया है, लेकिन परीक्षण मामलों को देखते समय मुझे // <strong i="9">@module</strong> amd जैसी बहुत सी टिप्पणियां दिखाई देती हैं। मैंने हमेशा माना है कि यह एक ts फ़ाइल के अंदर से विकल्प निर्दिष्ट करने का एक तरीका था। हालाँकि, मैंने इसे करने की कभी कोशिश नहीं की, इसलिए शायद मैं पूरी तरह से गलत हूँ! उदाहरण के लिए यहां देखें:
https://github.com/Microsoft/TypeScript/blob/master/tests/cases/conformance/externalModules/amdImportAsPrimaryExpression.ts

यदि यह प्रति-फ़ाइल विकल्पों को निर्दिष्ट करने का कोई तरीका नहीं है, तो हमें कुछ नया करने की आवश्यकता हो सकती है। .d.ts फ़ाइलों के लिए प्रति फ़ाइल, _at कम से कम_ इस विकल्प को निर्दिष्ट करना आवश्यक है। फ़ाइल के शीर्ष पर एक विशेष स्वरूपित टिप्पणी हो सकती है, आखिरकार हमारे पास पहले से ही /// <amd-dependency /> और सह के लिए समर्थन है।

संपादित करें : मैं गलत हूँ। स्रोत कोड को स्पेलुंक करने से मुझे पता चला है कि उन चीजों को मार्कर कहा जाता है और फोरस्लैश रनर द्वारा पूर्व-पार्स किया जाता है। तो यह केवल परीक्षणों के लिए है, यह संकलक के अंदर नहीं है। इसके लिए कुछ नया करना होगा।

कुछ मामलों में व्यावहारिक सीमाएँ भी हैं - यह ES6 सुविधाओं जैसे कुछ तर्कों के लिए सबसे व्यावहारिक नहीं है, क्योंकि इसके लिए फ़ाइल को पूरी तरह से फिर से पार्स करने की आवश्यकता होगी। और IIUC टाइप चेकिंग उसी पास में की जाती है जिसमें AST निर्माण पहले स्थान पर होता है।

यदि आप पार्सर कोड को देखते हैं, तो /// <amd-dependency /> और /// <amd-module /> टिप्पणियों को किसी फ़ाइल में किसी अन्य चीज़ को पार्स करने से पहले पढ़ा जाता है। /// <non-null-types /> जैसा कुछ जोड़ना संभव होगा। ठीक है, यह भयानक नामकरण है और मैं मनमाने ढंग से "जादू" विकल्पों के प्रसार के लिए नहीं हूं, लेकिन यह सिर्फ एक विचार है।

@ jods4 मुझे लगता है कि @I 'मी पिनबॉल कह रही है कि IDEs कैसे वाक्य रचना काम करता है पर प्रकाश डाला में बड़े बदलाव के बिना इसे समर्थन नहीं करेंगे।

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

सभी के लिए खुशखबरी, टाइपस्क्रिप्ट 1.6 में लापता मान को मॉडल करने और सुरक्षित रूप से ट्रैक करने के लिए पर्याप्त अभिव्यंजक शक्ति है (जो अन्यथा null और undefined मानों द्वारा एन्कोडेड हैं)। अनिवार्य रूप से निम्नलिखित पैटर्न आपको गैर-शून्य प्रकार देता है:

declare module Nothing { export const enum Brand {} }
interface Nothing { 'a brand': Nothing.Brand }
export type Nullable<a> = a | Nothing;
var nothing : Nothing = null;
export function isNothing(value: Nullable<a>): value is Nothing {
    return value == null;
}
var something = Math.random() > 0.5 ? 'hey!' : nothing;
if (isNothing(something)) {
    // missing value
    // there is no way you can get anything out of it
    // there is also NO WAY to get a null reference exception out of it
    // because it doesn't have any methods or properties that could be examined
    // it is 100% explicit and typesafe to use
} else {
    // value is present, it is 100% GUARANTEED being NON-NULL
    // you just CANT get a null reference exception here either
    console.log(something.toLowerCase());
}

/** turns any unsafe values into safe ones */
export function sanitize<a>(unsafe: a) : Nullable<a> {
    return unsafe;
}

var safe = sanitize(toResultFromExternalCodeYouCannotTrust()); // <-- 100% safe to use

इसके साथ ही अनुरोध को बंद कर दिया जाना चाहिए क्योंकि अब कोई समस्या नहीं है। केस बंद, क्लास खारिज।

@ अलेक्सी-बायकोव

इसके साथ ही कहा कि अनुरोध बंद कर दिया जाना चाहिए क्योंकि अब कोई समस्या नहीं है।

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

मैं _not_ अपने कोड में प्रत्येक var x: number को Nullable<number> या इससे भी बेहतर NonNullable<x> लपेटने जा रहा हूं। यह अभी बहुत अधिक उपरि है। फिर भी मैं जानना चाहता हूं कि x *= 2 करना 100% सुरक्षित है, मेरे कोड में कहीं भी ऐसा होता है।

आपका कोड तृतीय पक्ष लाइब्रेरी का उपयोग करने की समस्या का समाधान नहीं करता है। मैं _not_ _हर_ तृतीय पक्ष लाइब्रेरी पर sanitize पर कॉल करने जा रहा हूं, या यहां तक ​​कि अंतर्निहित डोम एपीआई, जिसे मैं कॉल करता हूं। इसके अलावा मैं isNothing(safe) _all the place_ नहीं जोड़ना चाहता। मैं जो चाहता हूं वह let squares = [1,2,3].map(x => x*x) पर कॉल करने में सक्षम हो रहा है और संकलन समय पर 100% सुनिश्चित हो सकता है कि squares.length सुरक्षित है। मेरे द्वारा उपयोग किए जाने वाले _any_ API के साथ।

इसी प्रकार मैं तृतीय पक्ष जेएस पुस्तकालयों के लिए दस्तावेज़ीकरण चाहता हूं कि कोई फ़ंक्शन null इनपुट के रूप में स्वीकार करता है या नहीं। मैं संकलन समय पर जानना चाहता हूं कि $(element).css(null) ठीक है या कोई त्रुटि है।

मैं टीम के वातावरण में काम करना चाहता हूं, जहां मैं यह सुनिश्चित नहीं कर सकता कि हर कोई आपके जैसे जटिल पैटर्न का लगातार उपयोग करता है। आपका Nulllable प्रकार एक देव को let x: number = null; x.toString() (या कुछ कम बेवकूफ, लेकिन उसी प्रभाव के लिए) करने से रोकने के लिए बिल्कुल कुछ नहीं करता है।

और इस प्रकार आगे भी। यह टिकट बंद से _far_ दूर है और समस्या अभी भी 100% है।

आप गंभीर नहीं हो सकते, है ना?

मैं काफी गंभीर हूं।

मैं हर एक को लपेटने वाला नहीं हूं ...

क्यों नहीं? ! सिंटैक्स के साथ या जो कुछ भी आप लोग जोर दे रहे हैं, आपको इसे वैसे भी करना होगा।

या इससे भी बेहतर NonNullable

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

यह अभी बहुत अधिक उपरि है।

कहां?

आपका कोड तृतीय पक्ष लाइब्रेरी का उपयोग करने की समस्या का समाधान नहीं करता है।

ऐसा होता है।

मैं प्रत्येक तृतीय पक्ष पुस्तकालय, या यहां तक ​​​​कि अंतर्निहित डोम एपीआई, जिसे मैं कॉल करता हूं, पर स्वच्छता को कॉल नहीं करने जा रहा हूं।

आपको नहीं करना है। आपको केवल Nullable<*> साथ शून्य होने वाली हर चीज को बदलकर उस तृतीय पक्ष lib की परिभाषा फ़ाइल को ठीक करना है

इसी प्रकार मैं तृतीय पक्ष जेएस पुस्तकालयों के लिए दस्तावेज़ीकरण चाहता हूं कि कोई फ़ंक्शन इनपुट के रूप में शून्य को स्वीकार करता है या नहीं।

वही चीज। उस विधि को एक सादे string बजाय Nullable<string> स्वीकार करने के रूप में परिभाषित करें।

आपका Nullable प्रकार किसी देव को let x: number = null; x.toString ()

यह वास्तव में नहीं है। आपको लिंटर का उपयोग करके null कीवर्ड पर प्रतिबंध लगाने की आवश्यकता है।

आओ मेरा समाधान 95% काम कर रहा है और 100% व्यावहारिक है और यह कठिन निर्णय लिए बिना और सभी को एक ही पृष्ठ पर लाए बिना आज उपलब्ध है। यह सवाल है कि आप क्या चाहते हैं: एक कामकाजी समाधान जो वह नहीं दिखता जो आप उम्मीद करते हैं लेकिन फिर भी काम करता है, या इसे ठीक उसी तरह से प्राप्त करना जैसे आप शीर्ष पर सभी बैक जैक और चेरी के साथ चाहते हैं

1.4 और 1.5 में, शून्य प्रकार ऑब्जेक्ट के किसी भी सदस्य को .toString () सहित अनुमति नहीं देता है, इसलिए मॉड्यूल की आवश्यकता के बजाय type Nothing = void; पर्याप्त होना चाहिए (जब तक कि यह 1.6 में फिर से नहीं बदला)। http://bit.ly/1OC5h8d

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

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

if (isNothing(something)) {
  console.log(something.toString())
}

मैं हर एक को लपेटने वाला नहीं हूं ...

क्यों नहीं? साथ ! सिंटैक्स या जो कुछ भी आप लोग जोर दे रहे हैं, वैसे भी आपको इसे करना होगा।

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

या इससे भी बेहतर NonNullable

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

ऐसा नहीं है कि मैं सिर्फ अशक्त अपवादों से छुटकारा पाना चाहता हूं। मैं स्थिर सुरक्षा के साथ गैर-शून्य प्रकारों को भी व्यक्त करने में सक्षम होना चाहता हूं।
मान लें कि आपके पास एक ऐसा तरीका है जो हमेशा एक मान लौटाता है। जैसे toString() हमेशा एक गैर शून्य स्ट्रिंग देता है।
वहां आपके विकल्प क्या हैं?
let x: string = a.toString();
यह अच्छा नहीं है क्योंकि कोई स्थिर सत्यापन नहीं है कि x.length सुरक्षित है। इस मामले में यह है, लेकिन जैसा कि आपने कहा था कि बिल्ट-इन string अच्छी तरह से null हो सकता है, इसलिए यह _status quo_ है।
let x = sanitize(a.toString());
ठीक है, अब मैं इसे बिना किसी जांच के उपयोग नहीं कर सकता, इसलिए कोड _is_ सुरक्षित है। लेकिन मैं हर जगह if (isNothing(x)) नहीं जोड़ना चाहता मैं अपने कोड में x का उपयोग करता हूं! यह बदसूरत और अक्षम दोनों है, क्योंकि मैं बहुत अच्छी तरह से जान सकता था कि संकलन-समय पर x शून्य नहीं है। (<string>x).length करना अधिक कुशल है लेकिन नरक के रूप में यह अभी भी बदसूरत है कि कहीं भी आप x का उपयोग करना चाहते हैं।

मैं जो करना चाहता हूं वह है:

let x = a.toString(); // documented, non-null type string (string! if you want to)
x.length; // statically OK

आप इसे उचित भाषा समर्थन के बिना प्राप्त नहीं कर सकते, क्योंकि JS (और TS 1.6) में सभी प्रकार हमेशा अशक्त होते हैं।

मैं यह कहना चाहूंगा कि गैर-वैकल्पिक (अशक्त) प्रकारों के साथ प्रोग्रामिंग एक बहुत अच्छा अभ्यास है, जितना आप कर सकते हैं। तो मैं यहां जो वर्णन कर रहा हूं वह एक आवश्यक परिदृश्य है, अपवाद नहीं।

यह अभी बहुत अधिक उपरि है।

कहां?

मेरा पिछला उत्तर देखें।

आपका कोड तृतीय पक्ष लाइब्रेरी का उपयोग करने की समस्या का समाधान नहीं करता है।

ऐसा होता है।

आधी ही समस्या का समाधान होता है। यह मानते हुए कि पुस्तकालय परिभाषाएँ जहाँ आपके द्वारा प्रस्तावित की गई हैं: प्रत्येक अशक्त इनपुट या लौटाए गए मूल्य को X के बजाय Nullable<X> से बदल दिया जाता है।

मैं अभी भी null को ऐसे फ़ंक्शन में पास कर सकता हूं जो null पैरामीटर स्वीकार नहीं करता है। ठीक है यह तथ्य अब _documented_ है (जिसे हम पहले से ही JSDoc टिप्पणियों या जो कुछ भी कर सकते हैं) लेकिन मैं इसे संकलन-समय पर _enforced_ चाहता हूं।
उदाहरण: declare find<T>(list: T[], predicate: (T) => bool) । दोनों पैरामीटर शून्य नहीं होने चाहिए (मैंने Nullable उपयोग नहीं किया है) फिर भी मैं find(null, null) कर सकता हूं। एक और संभावित त्रुटि यह है कि घोषणा कहती है कि मुझे विधेय से एक गैर-शून्य bool वापस करना चाहिए, फिर भी मैं यह कर सकता हूं: find([], () => null) ।

आपका Nullable प्रकार किसी देव को let x: number = null; x.toString ()

यह वास्तव में नहीं है। आपको लिंटर का उपयोग करके नल कीवर्ड पर प्रतिबंध लगाने की आवश्यकता है।

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

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

आपको अभी भी उन सभी मूल्यों को साफ करने के लिए सावधान रहना होगा जो संभवतः शून्य हैं।

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

यदि आप ऐसा करना भूल जाते हैं तो आपको कोई चेतावनी नहीं मिलेगी।

वही चीज। वही चीज।

वर्णन करें कि कैसे हैक्स वास्तव में आपको बहुत दूर नहीं ले जाएंगे, बस कोशिश करें

यद्यपि आप जिस तरह से मैंने परिभाषित किया है, उसके साथ आप सही हैं, जिसमें toString से Object , लेकिन .. अगर हम @Arnavion का विचार Nothing लिए void का उपयोग करना) Nothing ) यह सब अचानक क्लिक करता है

घड़ी

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

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

@ अलेक्सी-बायकोव
मैं देख रहा हूं कि आप क्या करने की कोशिश कर रहे हैं, हालांकि मुझे ऐसा लगता है कि आपने अभी तक सभी मामलों को सुलझाया नहीं है और आप रास्ते में समाधान बना रहे हैं जब कोई छेद बताता है (जैसे null के प्रतिस्थापन की तरह) void से)।

अंत में _maybe_ आप इसे वैसे ही काम करेंगे जैसा मैं चाहता हूं। आप अशक्त प्रकारों के लिए एक जटिल सिंटैक्स का उपयोग करेंगे, आपने प्रोग्राम में null किसी भी स्रोत को लिंटर के साथ प्रतिबंधित कर दिया होगा जो अंततः अशक्त प्रकार को गैर-शून्य बना सकता है। जिस तरह से आपको अपने गैर-मानक सम्मेलन का उपयोग करके सभी को अपने पुस्तकालयों को अपडेट करने के लिए राजी करना होगा, अन्यथा इसका कोई फायदा नहीं है (ध्यान रखें, यह शून्य समस्या के _all_ समाधानों के बारे में सच है, न कि केवल आपकी)।

अंत में आप अंतर्निहित null प्रकार से बचने के लिए टाइप सिस्टम को घुमाने में सफल हो सकते हैं और चेक हम आपके Nothing प्रकार से संलग्न करना चाहते हैं।

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

इस बिंदु पर, क्या आपको नहीं लगता कि भाषा को इसका समर्थन करना चाहिए?

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

क्या मैं अब भी चाहता हूं कि टाइपस्क्रिप्ट में हमारे पास गैर-शून्यताएं हों? पक्की बात मैं करता हूँ।

फिर आप इस मुद्दे को क्यों बंद करना चाहते हैं? :स्माइली:

इसके साथ ही अनुरोध को बंद कर दिया जाना चाहिए क्योंकि अब कोई समस्या नहीं है। केस बंद, क्लास खारिज।

मुझे खुशी है कि आपको अपनी जरूरतों का समाधान मिल गया लेकिन आप की तरह मुझे अब भी उम्मीद है कि एक दिन TS को कुछ उचित समर्थन मिलेगा। और मुझे विश्वास है कि यह अभी भी हो सकता है (जल्द ही नहीं, आप पर ध्यान दें)। C# टीम वर्तमान में वही विचार-मंथन कर रही है और शायद इससे चीजों को आगे बढ़ाने में मदद मिल सकती है। यदि सी # 7 गैर-शून्य प्रकार प्राप्त करने का प्रबंधन करता है (जो अभी तक निश्चित नहीं है) तो कोई कारण नहीं है कि टीएस ऐसा नहीं कर सकता है।

@ अलेक्सी-बायकोव

तो सरल करने के लिए

var nothing: void = null;
function isNothing<a>(value: a | void): value is void {
    return value == null;
}
var something = Math.random() > 0.5 ? 'hey!' : nothing;

और अब आप इसे बिना किसी फ़ंक्शन रैपर के भी उपयोग कर सकते हैं - उचित प्रकार की परिभाषाएं पर्याप्त हैं।

यह मूल रूप पर भरोसा करने से हतोत्साहित होने तक थोड़े खुश किया ।

आपको अपनी सभी परिभाषा फाइलों की समीक्षा करनी होगी और ! जहां उपयुक्त हो। यह कैसे अलग है?

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

मैं " --noImplicitNull " की वकालत कर रहा हूं। यह किसी भी मौजूदा कोड में संभावित समस्याओं के बारे में तुरंत प्रतिक्रिया देने के लिए सभी प्रकार को गैर-शून्य करने योग्य बना देगा। यदि "!" है, तो टाइपचेकर को नल की संभावना को अनदेखा करने के लिए स्विफ्ट की तरह व्यवहार करना चाहिए (गैर-शून्य के लिए असुरक्षित कास्ट) - हालांकि ईएस 7+ के साथ संघर्ष में "अंतिम प्रेषण" ऑपरेटर वादे पर है, इसलिए यह सबसे अच्छा नहीं हो सकता है विचार।

अगर यह पिछड़ा-संगतता टूटने के मामले में बहुत कट्टरपंथी लगता है, तो यह वास्तव में मेरी गलती है। मुझे वास्तव में समय खोजने की कोशिश करनी चाहिए और यह साबित करने के लिए एक कांटा में कोशिश करनी चाहिए कि यह वास्तव में उतना कट्टरपंथी नहीं है जितना दिखता है। वास्तव में "!" अधिक कट्टरपंथी है: इसका लाभ उठाने के लिए और अधिक परिवर्तनों की आवश्यकता होगी क्योंकि अधिकांश मूल्य वास्तव में शून्य नहीं हैं; --noImplicitNull अधिक क्रमिक है क्योंकि आप प्रकार की परिभाषाओं को ठीक करके अधिक त्रुटियों की खोज करेंगे जो गलत तरीके से गैर-शून्य मानों का दावा करते हैं और उन सुधारों के बिना आपको समान व्यवहार मिलेगा, सिवाय अशक्त असाइनमेंट, अप्रारंभिक मूल्यों और वैकल्पिक ऑब्जेक्ट फ़ील्ड के लिए भूल गए चेक को छोड़कर .

चर्चा में अपनी आवाज जोड़ते हुए, मुझे पसंद है कि कैसे कोटलिन ने इस मुद्दे को हल किया है, अर्थात

• स्वयं के चरों में डिफ़ॉल्ट रूप से अशक्त प्रकार नहीं होते हैं, एक '?' परिवर्तन जो
• बाहरी चर अशक्त हैं, एक '!!' ओवरराइड
• एक नल चेक एक प्रकार का कास्ट है
• बाहरी कोड का विश्लेषण एक उपकरण द्वारा किया जा सकता है जो एनोटेशन उत्पन्न करता है

तुलना करना:
1
2

• अगर a|void पर प्रतिबंध लगा दिया जाता है तो कोई भी a|Nothing स्विच कर सकता है

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

• यह नहीं देख सकता कि 100% वैध सुविधाओं का उपयोग करना हैक क्यों है
• समुदाय के कौशल को अधिक महत्व न दें, कई (यदि अधिकतर नहीं) परिभाषाएं निम्न गुणवत्ता की हैं और यहां तक ​​​​कि वे भी कहते हैं, jQuery को अक्सर कुछ बदलावों के बिना लिखित रूप में उपयोग नहीं किया जा सकता है
• फिर से, एक पैटर्न कभी भी एक पूर्ण विशेषता के रूप में उतना अच्छा नहीं होगा, आशा है कि हर कोई इसे प्राप्त करेगा, इसमें कोई संदेह नहीं है
• एक पैटर्न आज आपकी समस्याओं का समाधान कर सकता है जबकि एक सुविधा निकट हो भी सकती है और नहीं भी
• यदि किसी स्थिति को AB और C को नियोजित करके कुशलतापूर्वक (95% तक) हल किया जा सकता है, तो किसी को भी ऐसा करने के लिए D की आवश्यकता क्यों होगी? कुछ चीनी की लालसा? हम उस चीज़ पर ध्यान क्यों नहीं देंगे जिसे एक पैटर्न द्वारा हल नहीं किया जा सकता है?

वैसे भी, समस्या हल करने वाले और पूर्णतावादी हैं, जैसा कि दिखाया गया था कि समस्या हल करने योग्य है

(यदि आप शून्य प्रकार पर भरोसा नहीं करना चाहते हैं, तो कुछ भी class Nothing { private toString: any; /* other Object.prototype members */ } हो सकता है जिसका प्रभाव समान होगा। #1108 देखें)

_नोट: यहां सिंटैक्स को बाइकशेड करने के बारे में कुछ भी नहीं है। कृपया इसे न लें
जैसे की।_

मैं इसे सीधे शब्दों में कहूँगा: यहाँ प्रस्तावित TS 1.6 समाधान के साथ समस्या है
यहां: यह व्यावहारिक रूप से काम कर सकता है, लेकिन यह मानक पुस्तकालय पर लागू नहीं होता है या
अधिकांश परिभाषा फ़ाइलें। यह गणित ऑपरेटरों पर भी लागू नहीं होता है। अगर आप चाहते हैं
अनावश्यक प्रकार/रनटाइम बॉयलरप्लेट के बारे में शिकायत करने के लिए, सामान्य करने का प्रयास करें
संग्रह सी ++ में काम करते हैं - यह तुलना में कम है, खासकर यदि आप चाहते हैं
आलसी पुनरावृत्ति या संग्रह जो सरणियाँ नहीं हैं (या इससे भी बदतर, कोशिश करें
दोनों को मिलाकर)।

वर्तमान में @aleksey-bykov द्वारा प्रस्तावित समाधान के साथ समस्या यह है कि
यह भाषा कोर में लागू नहीं है। उदाहरण के लिए, आप नहीं कर सकते
Object.defineProperty(null, "name", desc) - आपको से एक TypeError मिलेगा
null लक्ष्य वस्तु। एक और बात: आप किसी संपत्ति को असाइन नहीं कर सकते a
null ऑब्जेक्ट, जैसे var o = null; o.foo = 'foo'; । आपको मिलेगा
संदर्भ त्रुटि आईआईआरसी। यह प्रस्तावित समाधान उन मामलों के लिए जिम्मेदार नहीं हो सकता है।
इसलिए हमें इसके लिए भाषा समर्थन की आवश्यकता है।

_अब, थोड़ी हल्की बाइक शेडिंग..._

और वाक्य रचना के लिए, मुझे "?string" और . की संक्षिप्तता पसंद है
"!स्ट्रिंग" वाक्य रचना, लेकिन जहां तक ​​अंतिम परिणाम की बात है, मुझे तब तक परवाह नहीं है जब तक मैं हूं
ThisIsANullableType<T, U, SomeRidiculousAndUnnecessaryExtraGeneric<V, W>> नहीं लिख रहे हैं।

बुधवार को 29 जुलाई, 2015, 16:10 अलेक्सी बायकोव नोटिफिकेशन @github.com ने लिखा:

• अगर a|void प्रतिबंधित है तो कोई एक पर स्विच कर सकता है|कुछ भी नहीं

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

  यह नहीं देख सकता कि 100% वैध सुविधाओं का उपयोग करना हैक क्यों है

  समुदाय के कौशल को अधिक महत्व न दें, कई (यदि अधिकतर नहीं)
  परिभाषाएँ निम्न गुणवत्ता की हैं और यहाँ तक कि वे भी, जैसे, jQuery काफी

  अक्सर कुछ परिवर्तनों के बिना लिखित रूप में उपयोग नहीं किया जा सकता है

  फिर से, एक पैटर्न कभी भी एक पूर्ण विशेषता के रूप में उतना अच्छा नहीं होगा, आशा है

  हर कोई इसे प्राप्त करता है, इसमें कोई शक नहीं

  एक पैटर्न आज आपकी समस्याओं का समाधान कर सकता है जबकि एक विशेषता हो सकती है या हो सकती है

  पास नहीं होना

  यदि एबी को नियोजित करके किसी स्थिति को कुशलता से (95% तक) हल किया जा सकता है
  और सी ऐसा करने के लिए किसी को भी डी की आवश्यकता क्यों होगी? कुछ चीनी की लालसा? क्यों होता
  हम किसी ऐसी चीज पर ध्यान केंद्रित करते हैं जिसे एक पैटर्न द्वारा हल नहीं किया जा सकता है?

वैसे भी, समस्या हल करने वाले और पूर्णतावादी हैं, जैसा कि दिखाया गया था
समस्या हल करने योग्य है

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

और क्या हम कम से कम इस बात का अंदाजा लगा सकते हैं कि बाइक शेड की संरचना कैसी दिखेगी, इससे पहले कि हम इस बात पर ध्यान दें कि इसे किस रंग में रंगना है? पहली ~ 10 टिप्पणियों के बाद अब तक मैंने जो कुछ देखा है, वह है "अरे, हम एक बाइक शेड बनाना चाहते हैं! हमें इसे किस रंग में रंगना चाहिए?" यह सुनिश्चित करने के बारे में कुछ भी नहीं है कि डिज़ाइन संरचनात्मक रूप से ध्वनि है। (इसके कुछ अन्य उदाहरणों के लिए #3192 और #1206 की पहली छमाही देखें - जब मैंने तार्किक रूप से बनाए गए सिंटैक्स और पूरी तरह से निर्दिष्ट शब्दार्थ के साथ एक गंभीर प्रस्ताव बनाया तो अधिकांश शोर समाप्त हो गया।)

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

बेशक मैं यहाँ अपने सिर के ऊपर हूँ। फिर भी, मैंने "अशक्त जावास्क्रिप्ट" और "शून्यता जावास्क्रिप्ट" के लिए विद्वान.गूगल की खोज की:
टाइपस्क्रिप्ट को समझना
टाइपस्क्रिप्ट (मॉड्यूल जेनरिक) में प्रकारों की एक अच्छी तालिका है।

जावास्क्रिप्ट के लिए आश्रित प्रकार
महत्वपूर्ण प्रतीत होता है। स्रोत कोड गायब हो गया

विश्वास करें, लेकिन सत्यापित करें: डायनामिक के लिए दो-चरण टाइपिंगबोली
स्क्रिप्टिंग भाषाओं के लिए शोधन प्रकार
टाइपप्रति के आधार पर एक समाधान प्रदान करता है।
("आशुलिपि टी? टी + नल के लिए खड़ा है।" ; #186 जैसा लगता है)

@afrische इनमें से अधिकांश का पहले से ही JS टाइप चेकर्स में व्यावहारिक रूप से उपयोग किया जा रहा है। उदाहरण के लिए, फ़्लो "विश्वास करें, लेकिन सत्यापित करें" में अधिकांश मुहावरों का उपयोग करता है। एक WIP JS टाइप चेकर Infernu भी है, जो इसके प्रकारों का अनुमान लगाने के लिए बड़े पैमाने पर Hindley-Milner प्रकार के अनुमान 1 पर निर्भर करता है। लेकिन मैं पीछे हटा...

[1] हास्केल, ओकैमल, आदि अपने प्रकार के सिस्टम के लिए एक संशोधित संस्करण का भी उपयोग करते हैं।

मैं वर्तमान में एक टीएस कांटा के साथ कर रहा हूं जो मानता है कि प्रकार डिफ़ॉल्ट रूप से शून्य नहीं हैं और यह (मौजूदा) शून्य प्रकार को null साथ संदर्भित करता है, उदाहरण के लिए string | null । मैंने string? लिए सिंटैक्स भी जोड़ा जो कि समान यूनियन प्रकार के लिए केवल एक शॉर्टकट है।

जब आप इसके बारे में गहराई से सोचते हैं, तो यह @aleksey-bykov जैसा ही होता है, लेकिन जहां null Nothing प्रकार, अंतर्निहित होता है।

और ऐसा करना जटिल भी नहीं है क्योंकि इस सब को संभालने में टाइप सिस्टम पहले से ही काफी अच्छा है!

जहां चीजें बालों वाली होती हैं, वह यह है कि हम एक आसान संक्रमण पथ चाहते हैं। हमें कुछ पिछड़ी संगतता की आवश्यकता है, _at कम से कम_ मौजूदा परिभाषा फाइलों के साथ (परियोजना के साथ संगतता स्वयं एक ऑप्ट-इन ध्वज हो सकती है, हालांकि यह बेहतर होगा यदि कोड के एक टुकड़े का अर्थ - इंटरनेट पर कहें - किया ' t वैश्विक कंपाइलर झंडे पर निर्भर करता है)।

अपने स्वयं के प्रोजेक्ट में string? का उपयोग करने का @afrische का विचार लेकिन string! में .d.ts का उपयोग करना एक नया दृष्टिकोण हो सकता है। हालाँकि मुझे यह मनमानी द्वैत पसंद नहीं है जो यह पैदा करता है। क्यों string अशक्त और कुछ फाइलें और दूसरों में गैर-शून्य है? अजीब लगता है।

अगर कुछ फाइलों में स्ट्रिंग को अशक्त नहीं रखना पसंद करते हैं और दूसरों में नहीं।
मुझे @impinball का कंपाइलर में ऑप्ट-आउट फ़्लैग रखने और इसे ब्रेकिंग चेंज के रूप में पेश करने का विचार पसंद है (

यह धागा एक वर्ष से अधिक पुराना है और यह पता लगाना कठिन है कि सभी प्रासंगिक डिजाइन और चिंताएं लगभग 300 टिप्पणियों के साथ क्या हैं और केवल टीएस टीम से कुछ ही हैं।

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

पूरे धागे को पढ़े बिना मैं यह नहीं समझ सकता कि ! और ? दोनों को जोड़ने में क्या गलत है, जबकि मौजूदा व्यवहार को बनाए रखने के लिए मौजूदा व्यवहार को बनाए रखना है, इसलिए यहां यह एक प्रस्ताव के रूप में है :

प्रस्ताव

declare var foo:string // nullability unspecified
declare var foo:?string // nullable
declare var foo:!string // non-nullable

साथ ?string एक के सुपरसेट !string , और string यानी बीच के रिश्ते दोनों एक सुपरसेट और दोनों के सबसेट, string और दोनों ?string और !string any और अन्य सभी प्रकारों के बीच के संबंध के समान है, अर्थात ! या ? बिना एक नंगे प्रकार any अशक्तता के संबंध में।

निम्नलिखित नियम लागू होते हैं:

| प्रकार | शामिल है | प्रदान करता है | null असाइन कर सकते हैं? | नहीं मान सकते हैं null ? |
| --- | --- | --- | --- | --- |
| T | T , !T , ?T | T , ?T , !T | हाँ | हाँ |
| ?T | T , !T , ?T | T , ?T | हाँ | नहीं (टाइप गार्ड की आवश्यकता है) |
| !T | T , !T | T , ?T , !T | नहीं | हाँ |

यह मौजूदा कोड को तोड़े बिना शून्य सुरक्षा प्रदान करता है, और मौजूदा कोडबेस को वृद्धिशील रूप से शून्य सुरक्षा प्रदान करने में सक्षम बनाता है, ठीक उसी तरह जैसे any मौजूदा कोडबेस को टाइप सुरक्षा को क्रमिक रूप से पेश करने में सक्षम बनाता है।

उदाहरण

शून्य संदर्भ त्रुटि वाला कुछ कोड यहां दिया गया है:

function test(foo:Foo) { foo.method(); }
test(null);

यह कोड अभी भी गुजरता है। null अभी भी Foo लिए असाइन करने योग्य है और Foo को अभी भी गैर-शून्य माना जा सकता है।

function test(foo:!Foo) { foo.method(); }
test(null);

अब test(null) त्रुटिपूर्ण है, क्योंकि null !Foo को असाइन करने योग्य नहीं है।

function test(foo:?Foo) { foo.method(); }
test(null);

अब foo.bar() त्रुटि में है, क्योंकि ?Foo पर एक विधि कॉल की अनुमति नहीं है (यानी कोड को null लिए जांचना चाहिए)।

आपको धन्यवाद! और मुझे यह विचार वास्तव में पसंद है। हालांकि, अनुकूलता के लिए,
क्या हम ?T और T केवल उपनाम बना सकते हैं, जैसे Array<T> और T[] ? यह
चीजों को सरल करेगा, और अघोषित संस्करण अभी भी तकनीकी रूप से है
अशक्त।

शुक्र, अगस्त 28, 2015, 07:14 को जेसी शाल्केन नोटिफिकेशन @github.com ने लिखा:

यह धागा एक वर्ष से अधिक पुराना है और यह पता लगाना कठिन है कि ये सभी क्या हैं
प्रासंगिक डिजाइन और चिंताएं लगभग 300 टिप्पणियों और केवल कुछ के साथ हैं
टीएस टीम से ही।

मैं एक बड़े कोडबेस को फ्लो, क्लोजर कंपाइलर या में माइग्रेट करने की योजना बना रहा हूं
टाइपस्क्रिप्ट लेकिन टाइपस्क्रिप्ट में टाइप सेफ्टी की कमी एक वास्तविक डील ब्रेकर है।

पूरे सूत्र को पढ़े बिना मैं यह नहीं समझ सकता कि क्या गलत है
दोनों को जोड़ने के साथ! तथा ? अशक्तता विनिर्देशक को बनाए रखते हुए
उनके अभाव के प्रकारों के लिए मौजूदा व्यवहार, इसलिए यहाँ एक प्रस्ताव के रूप में है:
प्रस्ताव

var foo घोषित करें string // अशक्त, घोषित var foo:!string // गैर-शून्य

?स्ट्रिंग के साथ !स्ट्रिंग का एक सुपरसेट, और एक सुपरसेट और सबसेट दोनों को स्ट्रिंग करें
दोनों का, यानी स्ट्रिंग और दोनों के बीच संबंध?स्ट्रिंग और !स्ट्रिंग
किसी भी और सभी प्रकार के बीच के संबंध के समान है, अर्थात a
बिना नंगे प्रकार! या ? शून्यता के संबंध में किसी की तरह है।

निम्नलिखित नियम लागू होते हैं:
प्रकार शामिल है प्रदान करता है शून्य असाइन कर सकते हैं? शून्य नहीं मान सकते हैं? टीटी,!टी,?टीटी,
?T, !T हाँ हाँ ?TT, !T, ?TT, ?T हाँ नहीं (टाइप गार्ड आवश्यक) !TT, !TT,
?टी, !टी नहीं हां

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

शून्य संदर्भ त्रुटि वाला कुछ कोड यहां दिया गया है:

फ़ंक्शन टेस्ट (फू: फू) {foo.method (); }परीक्षण (शून्य);

यह कोड अभी भी गुजरता है। नल अभी भी फू को असाइन करने योग्य है और फू अभी भी कर सकता है
गैर-शून्य माना जा सकता है।

फंक्शन टेस्ट (फू:!फू) {foo.method (); }परीक्षण (शून्य);

अब परीक्षण (नल) त्रुटिपूर्ण है, क्योंकि नल !Foo को आबंटित करने योग्य नहीं है।

फंक्शन टेस्ट (फू:?फू) {foo.method (); }परीक्षण (शून्य);

अब foo.bar() त्रुटि में है, क्योंकि एक विधि कॉल चालू है? फू की अनुमति नहीं है
(यानी कोड को शून्य के लिए जांचना चाहिए)।

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

@impinball

आपको धन्यवाद! और मुझे यह विचार वास्तव में पसंद है। हालांकि, संगतता के लिए, क्या हम ?T और T केवल उपनाम बना सकते हैं, जैसे Array<T> और T[] ? यह चीजों को सरल करेगा, और अघोषित संस्करण अभी भी तकनीकी रूप से अशक्त है।

_संपूर्ण विचार_ यह है कि T , ?T और !T तीन अलग-अलग चीजें हैं, और वह _is_ संगतता के लिए (मौजूदा TS कोड के साथ संगतता)। मुझे नहीं पता कि इसे और बेहतर तरीके से कैसे समझाया जाए, क्षमा करें। मेरा मतलब है, मैंने एक छोटी सी मेज और सब कुछ बनाया है।

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

शुक्र, अगस्त 28, 2015, 11:43 को जेसी शाल्केन नोटिफिकेशन @github.com ने लिखा:

@impinball https://github.com/impinball

आपको धन्यवाद! और मुझे यह विचार वास्तव में पसंद है। हालांकि, अनुकूलता के लिए,
क्या हम ?T और T केवल उपनाम बना सकते हैं, जैसे Arrayऔर टी[]? यह होगा
चीजों को सरल बनाएं, और अघोषित संस्करण अभी भी तकनीकी रूप से अशक्त है।

_संपूर्ण विचार_ यह है कि T, ?T और !T तीन अलग-अलग चीजें हैं,
और वह _is_ संगतता के लिए (मौजूदा TS . के साथ संगतता)
कोड)। मुझे नहीं पता कि इसे और बेहतर तरीके से कैसे समझाया जाए, क्षमा करें। मेरा मतलब है, मैंने एक बनाया है
छोटी मेज और सब कुछ।

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

स्मार्ट गधा होने के लिए खेद है, लेकिन इसका कोई मतलब नहीं है

?string का सुपरसेट !string , और string दोनों का सुपरसेट और सबसेट दोनों

समुच्चय सिद्धांत से हम जानते हैं कि समुच्चय A एक उपसमुच्चय है और समुच्चय B का अतिसमुच्चय तब होता है जब और केवल जब A = B

यदि हां, तो जब आप "दोनों का" कहते हैं, तो इसका मतलब केवल सब कुछ-की-?स्ट्रिंग = सब कुछ-की-स्ट्रिंग और सब कुछ-की-!स्ट्रिंग = सब कुछ-की-स्ट्रिंग हो सकता है

तो अंततः सब कुछ-की-?स्ट्रिंग = सब कुछ-की-!स्ट्रिंग

जहां से सभी उतरते हैं, बस कहीं नहीं जा रही है, बस सेवा से बाहर है

@ एलेक्सी-बायकोव शायद खराब वाक्यांशों का मामला है। मुझे लगता है कि उसका मतलब है कि string अधिक पसंद है ?string | !string , सबसे अधिक अनुमेय बाधाओं को लेते हुए।

यह पूरी बात जावा के तेजी से आम @Nullable और @NonNull / @NotNull संकलन-समय प्रकार के एनोटेशन के दायरे में समान है, और वे कैसे अघोषित प्रकारों के साथ काम करते हैं।

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

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

@impinball

लोग अभी भी विकास में टाइपस्क्रिप्ट 1.4 का उपयोग करते हैं, खासकर बड़ी परियोजनाओं में।

मुझे लगता है कि इस सुविधा के लिए संगतता कहानी पुराने कंपाइलरों के साथ नई परिभाषाओं को संगत बनाने की कोशिश किए बिना पहले से ही काफी कठिन है (एफडब्ल्यूआईडब्ल्यू गैर-शून्य प्रकार वर्तमान टीएस कंपाइलर में जोड़ने के लिए लगभग तुच्छ हैं)।

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

बीटीडब्ल्यू मुझे आश्चर्य है कि लोग 1.4 पर बने रहते हैं, 1.5 में प्यार करने के लिए बहुत कुछ है।

@ अलेक्सी-बायकोव

स्मार्ट गधा होने के लिए खेद है, लेकिन इसका कोई मतलब नहीं है

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

any को किसी भी प्रकार को सौंपा जा सकता है (यह सभी प्रकार के सुपरसेट के रूप में व्यवहार करता है) और किसी भी प्रकार के रूप में माना जाता है (यह सभी प्रकार के सबसेट के रूप में व्यवहार करता है)। any अर्थ है "इस मान के लिए प्रकार की जांच से ऑप्ट आउट करें"।

string को !string या ?string दोनों से असाइन किया जा सकता है (यह उनमें से एक सुपरसेट के रूप में व्यवहार करता है) और इसे !string और ?string दोनों के रूप में माना जा सकता है string अर्थ है "इस मान के लिए अशक्तता जांच से बाहर निकलना", यानी वर्तमान टीएस व्यवहार।

@impinball

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

@RyanCavanaugh ने स्पष्ट रूप से कहा:

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

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

इसलिए मेरा प्रस्ताव उन प्रकारों के लिए मौजूदा व्यवहार को बनाए रखता है जिनमें अशक्तता विनिर्देशक नहीं है ( ! या ? )। जोड़ने के लिए _only_ सुरक्षित ध्वज वह होगा जो अशक्तता विनिर्देशक की कमी वाले प्रकारों को अस्वीकार करता है, अर्थात यह केवल पासिंग कोड लेता है और इसे त्रुटि का कारण बनता है, यह इसका अर्थ नहीं बदलता है। मुझे लगता है कि उसी कारण से noImplicitAny की अनुमति दी गई थी।

@jesseschalken

मेरा मतलब था कि निहित रूप से टाइप किए गए चर के संदर्भ में प्रारंभ नहीं किया गया था
इस तरह के मामलों में null या undefined :

var a = new Type(); // type: !Type
var b = 2; // type: !number
var c = 'string'; // type: !string
// etc...

गलतफहमी के लिए खेद है।

शुक्र, अगस्त 28, 2015, 19:54 को जेसी शाल्केन नोटिफिकेशन @github.com ने लिखा:

@impinball https://github.com/impinball

और मैं निश्चित रूप से प्रकार के लिए एक नए ध्वज के पक्ष में रहूंगा
परोक्ष रूप से गैर-अशक्त, विशेष रूप से आदिम के रूप में लिया गया।

@RyanCavanaugh https://github.com/RyanCavanaugh ने स्पष्ट रूप से कहा:

किसी भाषा के शब्दार्थ को बदलने वाले झंडे एक खतरनाक चीज हैं। [...]
यह महत्वपूर्ण है कि कोड के एक टुकड़े को देखने वाला कोई व्यक्ति "अनुसरण करें"
प्रकार प्रणाली के साथ और किए जा रहे अनुमानों को समझें। अगर
हमारे पास झंडों का एक गुच्छा होना शुरू हो जाता है जो भाषा के नियमों को बदल देता है,
यह असंभव हो जाता है।

करने के लिए एकमात्र सुरक्षित प्रकार का शब्दार्थ रखना है
समनुदेश्यता समान है और जो त्रुटि है उसे बदल दें बनाम जो निर्भर नहीं है
एक झंडे पर, ठीक उसी तरह जैसे आज noImplicitAny कैसे काम करता है।

इसलिए मेरा प्रस्ताव मौजूदा व्यवहार को उन प्रकारों के लिए बनाए रखता है जिनमें कमी है
एक अशक्तता विनिर्देशक (! या?) जोड़ने के लिए _only_ सुरक्षित ध्वज होगा
एक जो अशक्तता विनिर्देशक की कमी वाले प्रकारों को अस्वीकार करता है, अर्थात यह केवल
पासिंग कोड लेता है और इसे त्रुटि का कारण बनता है, यह इसका अर्थ नहीं बदलता है। मैं
मान लें कि noImplicitAny को उसी कारण से अनुमति दी गई थी।

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

@jeffmcaffer शब्दों के मूल अर्थ को बदलकर सुपरसेट और सबसेट के मूल अर्थ को बदलकर आप जो कहना चाह रहे हैं उसे अभी भी सेट के संदर्भ में आसानी से व्यक्त किया जा सकता है: string के मूल्यों का सेट !string के मूल्यों का एक संघ है !string और ?string अर्थ है !string या/और ?string से कुछ भी string

@impinball फिर, ऐसा ध्वज मौजूदा कोड का अर्थ बदल देगा, जो ( @RyanCavanaugh की टिप्पणियों को पढ़ने से) की अनुमति नहीं है। export var b = 5; अब एक !number निर्यात करेगा जहां पहले यह number निर्यात करता था।

हाँ, एक मायने में। थोड़ा और तकनीकी होने के लिए, यह संघ को स्वीकार करता है, लेकिन
यह चौराहे प्रदान करता है। मूल रूप से, किसी भी प्रकार को a . के रूप में गिना जा सकता है
string , और एक string किसी भी प्रकार के लिए पारित किया जा सकता है।

शुक्र, अगस्त 28, 2015, 20:20 को अलेक्सी बायकोव नोटिफिकेशन @github.com ने लिखा:

@impinball https://github.com/impinball आप क्या कहना चाह रहे हैं
सुपरसेट और सबसेट शब्दों के मूल अर्थ को बदलना अभी भी हो सकता है
सेट के संदर्भ में आसानी से व्यक्त किया गया: स्ट्रिंग के मानों का सेट है a
_union_ !string और ?string के मानों का !string . से कुछ भी अर्थ है
या/और ?स्ट्रिंग string . के अंतर्गत आता है

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

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

शुक्र, अगस्त 28, 2015, 20:21 को जेसी शाल्केन नोटिफिकेशन @github.com ने लिखा:

@impinball https://github.com/impinball फिर से, ऐसा झंडा बदल जाएगा
मौजूदा कोड का अर्थ, जो (पढ़ने से @RyanCavanaugh
https://github.com/RyanCavanaugh की टिप्पणियों) की अनुमति नहीं है। निर्यात विविधता
बी = 5; अब एक !नंबर निर्यात करेगा जहां पहले यह एक नंबर निर्यात करता था।

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

जाहिर है, यह डिफ़ॉल्ट रूप से चालू होने के लिए नहीं है।

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

इसलिए मेरा प्रस्ताव उन प्रकारों के लिए मौजूदा व्यवहार को बनाए रखता है जिनमें अशक्तता विनिर्देशक नहीं है ( ? या ! )।

@jesseschalken
यदि आप मौजूदा कोड के अर्थ को 100% निष्ठा के साथ संरक्षित करना चाहते हैं (और प्रबंधित करते हैं), तो आपको टाइपस्क्रिप्ट पर शून्य सुरक्षा के विचार को छोड़ देना चाहिए। व्यवहार में कोई समाधान प्रयोग करने योग्य नहीं होगा।

प्रत्येक प्रकार के एनोटेशन पर ? और ! डालना मेरे लिए पहले से ही पर्याप्त है, मैं इसे नहीं करना चाहता, लेकिन आपको सभी प्रकार के अनुमानों को भी छोड़ना होगा। let x = 3 अनुमान आज number है। यदि आप यहां किसी बदलाव को स्वीकार नहीं करते हैं, तो इसका मतलब है कि आपको शून्य सुरक्षा के लाभों को प्राप्त करने के लिए स्पष्ट रूप से सब कुछ टाइप करना होगा। ऐसा कुछ नहीं जो मैं करने को तैयार हूं।

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

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

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

मुझे वह दृष्टिकोण पसंद है और यह भाषा को विकसित करने का एक तार्किक तरीका लगता है। मुझे उम्मीद है कि समय के साथ यह वास्तविक मानक बन जाएगा जिस तरह टाइपिंग आमतौर पर noImplicitAny को ध्यान में रखकर लिखी जाती है।

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

तो इसके बारे में कैसे:

• -noImplicitNull के साथ, T !T लिए उपनाम बन जाता है। अन्यथा T की अशक्तता अज्ञात है।
• शीर्ष पर एक एनोटेशन जोड़कर ध्वज प्रति-मॉड्यूल आधार पर ओवरराइड करने योग्य होना चाहिए, उदाहरण के लिए। <strong i="18">@ts</strong>:implicit_null । यह उसी तरह है जैसे फ्लो प्रति-मॉड्यूल आधार पर टाइप चेकिंग को सक्षम बनाता है।
• मौजूदा कोडबेस को कनवर्ट करना पहले -noImplicitNull कंपाइलर विकल्प को जोड़कर किया जाता है, फिर सभी मौजूदा मॉड्यूल को ' @ts :implicit_null' ध्वज के साथ
• मॉड्यूल आयात करते समय, इस बारे में एक नीति बनाने की आवश्यकता है कि यदि आयातित और आयात करने वाले मॉड्यूल में अलग-अलग निहितार्थ सेटिंग्स हैं, तो प्रकारों को कैसे परिवर्तित किया जाए।

उस अंतिम बिंदु के लिए अलग-अलग विकल्प हैं यदि स्पष्ट नल वाला मॉड्यूल एक अंतर्निहित नल के साथ आयात करता है।

• एक चरम दृष्टिकोण यह होगा कि T प्रकारों की अशक्तता को अज्ञात माना जाए और आयातक को इस प्रकार को स्पष्ट रूप से ?T या !T डालने की आवश्यकता हो। इसके लिए कैली में बहुत सारी टिप्पणियों की आवश्यकता होगी लेकिन सुरक्षित रहें।
• एक और तरीका यह होगा कि सभी आयातित T प्रकारों को ?T रूप में माना जाए। इसके लिए कॉलर में बहुत सारे एनोटेशन की भी आवश्यकता होगी।
• अंत में, सभी आयातित T प्रकारों को !T माना जा सकता है। यह निश्चित रूप से कुछ मामलों में गलत होगा लेकिन यह सबसे व्यावहारिक विकल्प हो सकता है। जिस तरह से करने के लिए इसी तरह की है कि प्रकार के एक चर any प्रकार का एक मूल्य को सौंपा जा सकता T ।

विचार?

@ jods4 noImplicitAny ध्वज _does not_ मौजूदा कोड का अर्थ नहीं बदलता है, इसके लिए कोड को केवल उस चीज़ के बारे में स्पष्ट होना आवश्यक है जो अन्यथा निहित होगा।

| कोड | झंडा | अर्थ |
| --- | --- | --- |
| interface Foo { blah; } | | interface Foo { blah:any; } |
| interface Foo { blah; } | noImplicitAny | त्रुटि, स्पष्ट प्रकार की आवश्यकता |
| var foo = 'blah' | | var foo:string = 'blah' |
| var foo = 'blah' | noImplicitNull | var foo:!string = 'blah' |

noImplicitNull , इससे पहले कि आपके पास एक वेरिएबल था जिसे शून्य लिखा जा सकता था। अब आपके पास एक वेरिएबल है जिस पर null _cannot_ लिखा जा सकता है। यह noImplicitAny के लिए एक पूरी तरह से अलग जानवर है।

@RyanCavanaugh ने पहले ही उन

@jesseschalken क्षमा करें, लेकिन मैं अंतर देखने में विफल रहा।
noImplicitAny आपके पास यह आपके कोड में हो सकता है:
let double = x => x*2;
यह संकलित करता है और ठीक काम करता है। लेकिन एक बार जब आप noImplicitAny चालू करते हैं, तो संकलक यह कहते हुए आप पर एक त्रुटि फेंकता है कि x परोक्ष रूप से कोई है। नए झंडे के साथ काम करने के लिए आपको अपना कोड संशोधित करना होगा:
let double = (x: any) => x*2 या बेहतर अभी तक let double = (x: number) => x*2 ।
ध्यान दें कि हालांकि संकलक ने एक त्रुटि उठाई, फिर भी यह पूरी तरह से काम कर रहे जेएस कोड को उत्सर्जित करेगा (जब तक कि आप त्रुटियों पर उत्सर्जन बंद नहीं करते)।

मेरी राय में नल के साथ स्थिति काफी समान है। आइए चर्चा के लिए मान लें कि नए ध्वज के साथ, T गैर-शून्य है और T? या T | null प्रकार के संघ को दर्शाता है T और null ।
इससे पहले कि आपके पास हो सकता है:
let foo: string; foo = null; या यहां तक ​​​​कि सिर्फ let foo = "X"; foo = null जो कि string के समान ही अनुमान लगाया जाएगा।
यह संकलित करता है और ठीक काम करता है। अब नया noImplicitNull झंडा चालू करें। अचानक TS एक त्रुटि देता है जो यह दर्शाता है कि आप null को किसी ऐसी चीज़ को असाइन नहीं कर सकते जिसे स्पष्ट रूप से इस तरह घोषित नहीं किया गया था। लेकिन टाइपिंग त्रुटि को छोड़कर आपका कोड अभी भी _the same_, सही JS कोड उत्सर्जित करता है।
ध्वज के साथ आपको अपना इरादा स्पष्ट रूप से बताना होगा और कोड को संशोधित करना होगा:
string? foo; foo = null;

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

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

@robertknight मेरी वर्तमान सोच के बहुत करीब है।

उन मॉड्यूल/परिभाषाओं के लिए जिन्होंने सख्त गैर-शून्य प्रकारों को नहीं चुना है, T का मूल रूप से अर्थ होना चाहिए: इस प्रकार की सभी प्रकार की शून्य त्रुटियों को बंद करें। इसे T? लिए मजबूर करने का प्रयास अभी भी संगतता समस्याएं पैदा कर सकता है।

समस्या यह है कि आज कुछ T वास्तव में अशक्त हैं और कुछ अशक्त हैं। विचार करना:

// In a strict module, function len does not accept nulls
function len(x: string): number { return x.length; }
// In a legacy module, some calls to len
let abc: string = "abc";
len(abc);

यदि आप लीगेसी मॉड्यूल में string से string? उर्फ ​​हैं, तो कॉल एक त्रुटि बन जाती है क्योंकि आप एक संभावित अशक्त चर को एक गैर-अशक्त पैरामीटर में पास करते हैं।

@ jods4 मेरी टिप्पणी दोबारा पढ़ें। मेज पर देखो। मुझे नहीं पता कि इसे और अधिक स्पष्ट रूप से कैसे व्यक्त किया जाए।

आपके उदाहरण को स्पष्ट रूप से foo की परिभाषा और foo को एक दूसरे के बगल में रखकर आपके निष्कर्ष पर पहुंचने के लिए तैयार किया गया था। noImplicitAny , परिणाम में एकमात्र त्रुटियां विशेष रूप से उस कोड से होती हैं जिसे बदलने की आवश्यकता होती है (क्योंकि इसका अर्थ नहीं बदला है, इसे केवल इसे और अधिक स्पष्ट रूप से व्यक्त करने की आवश्यकता है)। noImplicitNull , त्रुटि का कारण बनने वाला कोड _असाइनमेंट_ से foo लेकिन इसे ठीक करने के लिए (पुराने अर्थ के लिए) जिस कोड को बदलने की आवश्यकता थी, वह foo का _definition_ था foo _ की परिभाषा का अर्थ बदल दिया है। असाइनमेंट और परिभाषा स्पष्ट रूप से एक पुस्तकालय सीमा के विभिन्न पक्षों पर हो सकती है, जिसके लिए noImplicitNull ध्वज ने उस पुस्तकालय के सार्वजनिक इंटरफ़ेस के _meaning_ को बदल दिया है!

ध्वज ने फू की परिभाषा का अर्थ बदल दिया।

हां यह सच है। यह "मेरे पास थोड़ा सा भी विचार नहीं है कि चर शून्य हो सकता है या नहीं - और मुझे परवाह नहीं है" से "यह चर शून्य-मुक्त है"। 50/50 संभावना है कि यह सही था और यदि ऐसा नहीं है, तो आपको घोषणा में अपना इरादा स्पष्ट करना होगा। अंत में, परिणाम noImplicitAny के समान ही है: आपको घोषणा में अपना इरादा अधिक स्पष्ट करना होगा।

असाइनमेंट और परिभाषा स्पष्ट रूप से एक पुस्तकालय सीमा के विभिन्न पक्षों पर हो सकती है

दरअसल, आम तौर पर पुस्तकालय में घोषणा और मेरे कोड में उपयोग। अभी:

1. यदि पुस्तकालय ने सख्त नल का विकल्प चुना है तो उसे इसके प्रकारों को सही ढंग से घोषित करना होगा। यदि पुस्तकालय कहता है कि इसमें सख्त अशक्त प्रकार हैं और x अशक्त है, तो मैं एक अशक्त _is असाइन करने का प्रयास कर रहा हूं जो वास्तव में एक त्रुटि है जिसे रिपोर्ट किया जाना चाहिए।
2. यदि पुस्तकालय ने सख्त नल का विकल्प नहीं चुना है तो संकलक को इसके उपयोग के लिए कोई त्रुटि नहीं उठानी चाहिए।

यह ध्वज (जैसे noImplicitAny ) आपके कोड को समायोजित किए बिना चालू नहीं किया जा सकता है।

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

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

गैर अशक्त प्रकारों के लिए अच्छी खबर है! ऐसा लगता है कि TS टीम TS अपडेट में ब्रेकिंग परिवर्तन पेश करने के साथ ठीक है!
यदि आप इसे देखते हैं:
http://blogs.msdn.com/b/typescript/archive/2015/09/02/announcing-typescript-1-6-beta-react-jsx-better-error-checking-and-more.aspx
वे एक नए फ़ाइल प्रकार के साथ एक ब्रेकिंग चेंज (पारस्परिक रूप से अनन्य वैकल्पिक सिंटैक्स) पेश करते हैं, और वे एक ब्रेकिंग चेंज _बिना_ नई फ़ाइल प्रकार (सभी को प्रभावित करते हैं) पेश करते हैं।
यह एक मिसाल है जिसके साथ हम गैर-अशक्त प्रकारों पर बहस कर सकते हैं (उदाहरण के लिए एक .sts या सख्त टाइपस्क्रिप्ट एक्सटेंशन और संबंधित .sdts)।

अब हमें केवल यह पता लगाने की आवश्यकता है कि क्या हम चाहते हैं कि संकलक अपरिभाषित प्रकारों या केवल अशक्त प्रकारों (और क्या सिंटैक्स) की जाँच करने का प्रयास करे और हमारे पास एक ठोस प्रस्ताव है।

@jbondc बहुत दिलचस्प पढ़ा। यह देखकर खुशी हुई कि एनएनबीडी (डिफ़ॉल्ट रूप से गैर-शून्य) में प्रवासन के बारे में मेरा अंतर्ज्ञान वैकल्पिक गैर-शून्य में प्रवासन की तुलना में आसान है, अध्ययनों द्वारा पुष्टि की गई है (माइग्रेट करने के लिए परिमाण कम परिवर्तन का एक क्रम, और डार्ट के मामले में, 1- कोड की प्रति 1000 पंक्तियों में 2 एनोटेशन के लिए शून्य परिवर्तन की आवश्यकता है, शून्य-भारी कोड में भी 10 से अधिक नहीं)

मुझे यकीन नहीं है कि दस्तावेज़ की जटिलता वास्तव में गैर-शून्य प्रकारों की जटिलता को दर्शाती है। उदाहरण के लिए, जेनेरिक अनुभाग में वे 3 प्रकार के औपचारिक प्रकार के मापदंडों पर चर्चा करते हैं, फिर दिखाते हैं कि आपको वास्तव में उनकी आवश्यकता नहीं है। टीएस में, null पूरी तरह से खाली रिकॉर्ड का प्रकार होगा (कोई गुण नहीं, कोई विधि नहीं) जबकि {} रूट गैर-शून्य प्रकार होगा, और फिर गैर-शून्य जेनरिक बस हैं G<T extends {}> - कई प्रकार के औपचारिक प्रकार के मापदंडों पर बिल्कुल भी चर्चा करने की आवश्यकता नहीं है।

इसके अतिरिक्त ऐसा लगता है कि वे बहुत सारी गैर-आवश्यक चीनी का प्रस्ताव करते हैं, जैसे var !x

एक ही समस्या से निपटने वाली मौजूदा भाषाओं का सर्वेक्षण हालांकि असली रत्न है।

दस्तावेज़ को पढ़कर मैंने महसूस किया कि Optional / Maybe प्रकार अशक्त प्रकारों की तुलना में अधिक शक्तिशाली हैं, विशेष रूप से एक सामान्य संदर्भ में - ज्यादातर Just(Nothing) को एन्कोड करने की क्षमता के कारण। उदाहरण के लिए, हम एक सामान्य मानचित्र इंटरफ़ेस उस प्रकार के मान शामिल है, तो T और समर्थन get जो कर सकते हैं या एक चाबी की उपस्थिति के आधार पर एक मूल्य वापस नहीं हो सकता है:

interface Map<T> {
  get(s:string):Maybe<T>
}

T को Maybe<U> प्रकार के होने से रोकने वाली कोई बात नहीं है; कोड पूरी तरह से अच्छी तरह से काम करेगा और यदि कोई कुंजी मौजूद है तो Just(Nothing) लौटाएगा लेकिन इसमें Nothing मान होगा, और यदि कुंजी बिल्कुल मौजूद नहीं है तो Nothing वापस आ जाएगी।

इसके विपरीत, यदि हम अशक्त प्रकारों का उपयोग करते हैं

interface Map<T> {
  get(s:string):T?
}

तब लापता कुंजी और शून्य मान के बीच अंतर करना असंभव है जब T शून्य है।

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

@jbondc यह एक बहुत ही

मुझे इस बात से सुकून मिलता है कि अध्ययनों से पता चलता है कि 80% घोषणाएँ वास्तव में गैर-शून्य हैं या प्रति KLOC (पृष्ठ 21) में केवल 20 अशक्तता एनोटेशन हैं। जैसा कि दस्तावेज़ में उल्लेख किया गया है, यह डिफ़ॉल्ट रूप से गैर-शून्य के लिए एक मजबूत तर्क है, जो मेरी भी भावना थी।

: गैर-शून्य के पक्ष में एक और तर्क है कि यह एक क्लीनर प्रकार प्रणाली बनाता है null अपना अलग प्रकार का है, T है गैर-शून्य और T? के लिए एक पर्याय है T | null । क्योंकि TS में पहले से ही यूनियन टाइप है, सब अच्छा है, साफ है और अच्छी तरह से काम करता है।

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

मुझे ऑपरेटर का विचार T! पेचीदा और संभवतः उपयोगी लगा। मैं एक ऐसी प्रणाली के बारे में सोच रहा था जहां T एक गैर-शून्य प्रकार है, T? T | null । लेकिन इसने मुझे परेशान किया कि आप वास्तव में एक सामान्य एपीआई नहीं बना सकते जो एक शून्य इनपुट के सामने भी एक गैर-शून्य परिणाम की गारंटी देता है। मेरे पास अच्छे उपयोग के मामले नहीं हैं, लेकिन सिद्धांत रूप में मैं इसे ईमानदारी से मॉडल नहीं कर सका: function defined(x) { return x || false; } ।
नॉन-नल रिवर्सल ऑपरेटर का उपयोग करके, कोई यह कर सकता है: function defined<T>(x: T): T! | boolean । इसका मतलब यह है कि अगर defined एक T defined लौटाता है तो यह गैर-शून्य होने की गारंटी है, भले ही सामान्य T बाधा शून्य हो, string? कहें। और मुझे नहीं लगता कि टीएस में मॉडल करना मुश्किल है: T! , अगर T एक संघ प्रकार है जिसमें null प्रकार शामिल है, तो null को हटाने के परिणामस्वरूप प्रकार वापस करें संघ की ओर से

@spion

दस्तावेज़ को पढ़कर मैंने महसूस किया कि वैकल्पिक/शायद प्रकार अशक्त प्रकारों की तुलना में अधिक शक्तिशाली हैं

आप Maybe संरचनाओं को घोंसला बना सकते हैं, आप वास्तव में null घोंसला नहीं बना सकते हैं।

नए एपिस को परिभाषित करने के संदर्भ में यह एक दिलचस्प चर्चा है, लेकिन मौजूदा एपिस को मैप करते समय बहुत कम विकल्प होते हैं। भाषा के नक्शे को शून्य से Maybe तक बनाना उस लाभ का लाभ नहीं उठाएगा, जब तक कि फ़ंक्शन पूरी तरह से फिर से लिखा न जाए।

Maybe दो अलग-अलग सूचनाओं को एनकोड करता है: क्या कोई मूल्य है और क्या मूल्य है। अपना Map उदाहरण लेना और C# को देखना यह स्पष्ट है, Dictionary<T,K> :
bool TryGet(K key, out T value) ।
ध्यान दें कि यदि सी # में टुपल्स (शायद सी # 7) थे, तो यह मूल रूप से वही है:
(bool hasKey, T value) TryGet(K key)
जो मूल रूप से Maybe और null स्टोर करने की अनुमति देता है।

ध्यान दें कि इस मुद्दे से निपटने के लिए JS का अपना तरीका है और यह बहुत सारी नई दिलचस्प समस्याएं पैदा करता है: undefined । एक सामान्य JS Map यदि कुंजी नहीं मिलती है तो undefined वापस आ जाएगी, इसका मूल्य अन्यथा, null ।

सी#7 के लिए संबंधित प्रस्ताव - https://github.com/dotnet/roslyn/issues/5032

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

@ ग्रिफोर्क

आपकी सभी अशक्त समस्याओं को अपरिभाषित समस्याओं से बदल दिया जाएगा

नहीं, वे क्यों करेंगे?
मेरी शून्य समस्याएं दूर हो जाएंगी और मेरी अपरिभाषित समस्याएं बनी रहेंगी।

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

मैं लगभग बिना किसी अपरिभाषित कोड के साथ कोड करता हूं सिवाय इसके कि जहां ब्राउज़र उन्हें मुझ पर मजबूर करता है

मैंने सोचा होगा कि जावास्क्रिप्ट हर मोड़ पर एक पर undefined को मजबूर करता है।

• अप्रारंभीकृत चर। let x; alert(x);
• छोड़े गए फ़ंक्शन तर्क। let foo = (a?) => alert(a); foo();
• गैर-मौजूद सरणी तत्वों तक पहुंचना। let x = []; alert(x[0]);
• गैर-मौजूद वस्तु गुणों तक पहुँचना। let x = {}; alert(x['foo']);

दूसरी ओर, अशक्त, कम और अधिक अनुमानित स्थितियों में होता है:

• डोम पहुंच। alert(document.getElementById('nonExistent'));
• तृतीय-पक्ष वेब सेवा प्रतिक्रियाएं ( JSON.stringify स्ट्रिप्स undefined )। { name: "Joe", address: null }
• रेगेक्स।

इस कारण से, हम null के उपयोग को प्रतिबंधित करते हैं, वायर पर प्राप्त सभी null को undefined कनवर्ट करते हैं, और हमेशा undefined लिए सख्त समानता जांच का उपयोग करते हैं। इसने व्यवहार में हमारे लिए अच्छा काम किया है।

नतीजतन मैं सहमत हूं कि undefined समस्या अधिक प्रचलित है।

@NoelAbrahams कोडिंग शैली, मैं आपको बताता हूँ :)

अप्रारंभीकृत चर

मैं हमेशा चर प्रारंभ करता हूं और मेरे पास noImplicitAny चालू है, इसलिए let x वैसे भी एक त्रुटि होगी। मैं अपने प्रोजेक्ट में जितना करीब उपयोग करूंगा वह है let x: any = null , हालांकि वह कोड है जिसे मैं अक्सर नहीं लिखूंगा।

वैकल्पिक फ़ंक्शन पैरामीटर

मैं वैकल्पिक पैरामीटर के लिए डिफ़ॉल्ट पैरामीटर मानों का उपयोग करता हूं, यह मुझे लगता है कि अधिक समझ में आता है (आपका कोड _will_ किसी भी तरह पैरामीटर को पढ़ता है और उपयोग करता है, है ना?) तो मेरे लिए: function f(name?: string = null, options?: any = {}) ।
कच्चे undefined पैरामीटर मान तक पहुंचना मेरे लिए एक _exceptional_ मामला होगा।

गैर-मौजूद सरणी तत्वों तक पहुंचना

यह ऐसा कुछ है जो मैं अपने कोड में नहीं करने का प्रयास करता हूं। मैं सीमा से बाहर नहीं जाने के लिए अपनी सरणी लंबाई की जांच करता हूं और मैं स्पैस सरणी का उपयोग नहीं करता (या null , 0 , ... जैसे डिफ़ॉल्ट मानों के साथ खाली स्लॉट भरने का प्रयास करता हूं)।
दोबारा, आप एक विशेष मामले के साथ आ सकते हैं जहां मैं ऐसा करूंगा, लेकिन यह एक अपवाद_ होगा, नियम नहीं।

गैर-मौजूद वस्तु गुणों तक पहुँचना।

बहुत कुछ वैसा ही जैसा कि सरणियों के लिए है। मेरे ऑब्जेक्ट टाइप किए गए हैं, यदि कोई मान उपलब्ध नहीं है तो मैंने इसे null सेट किया है, न कि undefined । फिर से आपको किनारे के मामले मिल सकते हैं (जैसे शब्दकोश जांच करना) लेकिन वे _edge case_ हैं और मेरी कोडिंग शैली के प्रतिनिधि नहीं हैं।

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

let cats: Cat[];
// Note that find returns undefined if there's no cat named Kitty
let myFavoriteCat = cats.find(c => c.name === 'Kitty'); 
if (myFavoriteCat === undefined) {
  // Immediately do something to compensate here:
  // return false; or 
  // myFavoriteCat = new Cat('Kitty'); or
  // whatever makes sense.
}
// Continue with assurance that myFavoriteCat is not null (it was an array of non-nullable cats after all).

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

इससे मैं समझता हूं कि आप मेरी तुलना में बहुत अलग कोडिंग शैली का उपयोग करते हैं। यदि आप मूल रूप से हर जगह undefined उपयोग करते हैं तो हाँ, आपको सांख्यिकीय रूप से चेक किए गए नल प्रकारों से बहुत कम लाभ होगा I
चाहेंगे।

हां, undefined की वजह से बात 100% निर्विवाद नहीं है और मुझे विश्वास नहीं है कि कोई उचित रूप से प्रयोग करने योग्य भाषा बना सकता है जो इस संबंध में 100% सही है। JS कई जगहों पर undefined पेश करता है।

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

@ jods4 , आपके दृष्टिकोण को पढ़ना दिलचस्प था।

मुझे लगता है कि मुझे उस दृष्टिकोण पर आपत्ति है कि बहुत सारे नियम हैं जिनका पालन करने की आवश्यकता है - यह साम्यवाद बनाम मुक्त बाजार की तरह है: मुस्कान:

TS टीम के पास अपनी शैली के लिए आंतरिक रूप

@NoelAbrahams " undefined का उपयोग करें" उतना ही एक नियम है जितना " null उपयोग करें"।

किसी भी मामले में, निरंतरता महत्वपूर्ण है और मुझे ऐसी परियोजना पसंद नहीं है जहां मुझे यकीन नहीं है कि चीजें null या undefined (या एक खाली स्ट्रिंग या शून्य) होनी चाहिए। खासकर जब से TS वर्तमान में इस मुद्दे पर मदद नहीं करता है...

मुझे पता है कि TS के पास undefined से अधिक null का पक्ष लेने का नियम है, मैं उत्सुक हूं कि क्या यह एक मनमाना "स्थिरता के लिए" पसंद है या यदि पसंद के पीछे और तर्क हैं।

क्यों मैं का उपयोग करना चाहते null बजाय undefined :

1. यह हमारे देवों के लिए एक परिचित तरीके से काम करता है, कई स्थिर ओओ भाषाओं जैसे सी # से आते हैं।
2. गैर-आरंभिक चर को आमतौर पर कई भाषाओं में कोड गंध के रूप में माना जाता है, यह सुनिश्चित नहीं है कि यह जेएस में अलग क्यों होना चाहिए। अपनी मंशा स्पष्ट करें।
3. हालांकि जेएस एक गतिशील भाषा है, लेकिन स्थिर प्रकारों के साथ प्रदर्शन बेहतर होता है जो नहीं बदलते हैं। किसी संपत्ति को null तुलना में delete null पर सेट करना अधिक कुशल है।
4. यह null बीच स्पष्ट अंतर का समर्थन करता है जिसे परिभाषित किया गया है लेकिन मूल्य की अनुपस्थिति को दर्शाता है, और undefined , जो कि... अपरिभाषित है। एक ऐसी जगह जहां दोनों के बीच का अंतर स्पष्ट है: वैकल्पिक पैरामीटर। undefined में पैरामीटर परिणाम पास नहीं करने पर। यदि आप अपने कोड बेस में इसके लिए undefined उपयोग करते हैं तो आप खाली मूल्य को _pass_ कैसे करते हैं? null का उपयोग करना यहां कोई समस्या नहीं है।
5. यह अशक्त जाँच के लिए एक साफ रास्ता देता है, जैसा कि इस धागे में चर्चा की गई है, जो वास्तव में व्यावहारिक नहीं है undefined । हालांकि शायद मैं इस पर सपना देख रहा हूं।
6. आपको निरंतरता के लिए चुनाव करना होगा, IMHO null जितना अच्छा है undefined ।

मुझे लगता है कि undefined से null को प्राथमिकता देने का कारण यह है कि
obj.nonexistentProp रिटर्निंग के साथ डिफ़ॉल्ट तर्क और स्थिरता
undefined ।

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

मंगल सितम्बर 8, 2015, पर 6:48 jods [email protected] लिखा है:

@NoelAbrahams https://github.com/NoelAbrahams "अपरिभाषित का उपयोग करें" इस प्रकार है
"शून्य का प्रयोग करें" के रूप में बहुत अधिक नियम।

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

मुझे पता है कि टीएस के पास शून्य पर अपरिभाषित का पक्ष लेने का नियम है, मैं उत्सुक हूं अगर यह
एक मनमाना "स्थिरता के लिए" पसंद है या यदि और भी हैं
पसंद के पीछे तर्क।

क्यों _I_ अपरिभाषित के बजाय अशक्त का उपयोग करना पसंद करते हैं:

1. यह हमारे डेवलपर्स के लिए एक परिचित तरीके से काम करता है, कई स्थिर ओओ से आते हैं
   सी # जैसी भाषाएं।
2. अप्रारंभीकृत चर को आमतौर पर कोड गंध के रूप में माना जाता है
   कई भाषाएं, यह सुनिश्चित नहीं है कि यह जेएस में अलग क्यों होनी चाहिए। अपना बनाएं
   इरादा साफ।
3. हालांकि JS एक गतिशील भाषा है, इसके साथ प्रदर्शन बेहतर है
   स्थिर प्रकार जो नहीं बदलते हैं। संपत्ति को इस पर सेट करना अधिक कुशल है
   इसे हटाने से शून्य।
4. यह अशक्त के बीच स्वच्छ अंतर का समर्थन करता है जिसे परिभाषित किया गया है लेकिन
   मूल्य की अनुपस्थिति को दर्शाता है, और अपरिभाषित, जो कि... अपरिभाषित है।
   एक ऐसी जगह जहां दोनों के बीच का अंतर स्पष्ट है: वैकल्पिक
   पैरामीटर। अपरिभाषित में एक पैरामीटर परिणाम पारित नहीं करना। तुम कैसे हो
   _pass_ खाली मान यदि आप अपने कोड में इसके लिए अपरिभाषित का उपयोग करते हैं
   आधार? नल का उपयोग करना यहां कोई समस्या नहीं है।
5. यह शून्य जाँच के लिए एक स्वच्छ मार्ग प्रदान करता है, जैसा कि इसमें चर्चा की गई है
   धागा, जो अपरिभाषित के साथ वास्तव में व्यावहारिक नहीं है। हालांकि शायद
   मैं इस पर दिन-सपने देख रहा हूँ।
6. आपको स्थिरता के लिए एक विकल्प बनाना होगा, आईएमएचओ नल उतना ही अच्छा है
   अपरिभाषित

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

@impinball
क्या हम हर जिथब चर्चा में "बाइकशेडिंग" का उपयोग करना बंद कर सकते हैं? हम सुरक्षित रूप से कह सकते हैं कि undefined या null का उपयोग करना टीम की प्राथमिकता है; लेकिन मुद्दा यह है कि undefined को शून्य जांच (या नहीं) में शामिल करने का प्रयास किया जाए और यह कैसे काम करेगा, यह मामूली नहीं है। तो मुझे समझ में नहीं आता कि यह पहली बार में बाईकशेडिंग कैसे हो रही है?

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

1. हम undefined साथ क्या करते हैं? (मेरी राय: यह अभी भी हर जगह है और अनियंत्रित है)
2. हम मौजूदा कोड के साथ संगतता को कैसे संभालते हैं, विशेष परिभाषाओं में? (मेरी राय: ऑप्ट-इन फ़्लैग, कम से कम प्रति परिभाषा फ़ाइल। फ़्लैग को चालू करना "ब्रेकिंग" है क्योंकि आपको शून्य एनोटेशन जोड़ना पड़ सकता है।)

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

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

मंगल सितम्बर 8, 2015, पर 13:28 jods [email protected] लिखा है:

@impinball https://github.com/impinball
क्या हम हर जिथब चर्चा में "बाइकशेडिंग" का उपयोग करना बंद कर सकते हैं? हम सुरक्षित रूप से कर सकते हैं
कहें कि अपरिभाषित या शून्य का उपयोग करना एक टीम वरीयता है; लेकिन मुद्दा
अपरिभाषित को अशक्त जांचों में शामिल करने का प्रयास करना है या नहीं (या नहीं) और कैसे
यह काम करेगा तुच्छ नहीं है। तो मुझे समझ में नहीं आता कि यह बाइक शेडिंग कैसे है
पहले स्थान पर?

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

1. हम अपरिभाषित के साथ क्या करते हैं? (मेरी राय: यह अभी भी हर जगह है
   और अनियंत्रित)
2. हम मौजूदा कोड के साथ संगतता कैसे संभालते हैं, विशेष रूप से
   परिभाषाएं? (मेरी राय: ऑप्ट-इन ध्वज, कम से कम प्रति परिभाषा फ़ाइल।
   फ़्लैग को चालू करना "ब्रेकिंग" है क्योंकि आपको नल जोड़ना पड़ सकता है
   एनोटेशन।)

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

@ jods4 मैं इसे आपके बिंदु 2 से

क्या आप कृपया इसे लिंक कर सकते हैं? मैं इसे आजमाना चाहूंगा।

@impinball
मुझे undefined खिलाफ भी (कुछ) सुरक्षा देखना अच्छा लगेगा, लेकिन यह काफी व्यापक है।

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

क्या हमें null और undefined प्रकारों में अंतर करना चाहिए? यह मुश्किल नहीं है: T | null , T | undefined , T | null | undefined और उपरोक्त प्रश्न का आसान उत्तर प्रदान कर सकते हैं। लेकिन फिर शॉर्टहैंड सिंटैक्स के बारे में क्या: T? अर्थ है? शून्य और अपरिभाषित दोनों? क्या हमें दो अलग-अलग शॉर्टहैंड चाहिए?

@ अर्नवियन
TS में अशक्त और अपरिभाषित प्रकार पहले से मौजूद हैं।
मेरा लेना था:

1. सभी प्रकार को अशक्त बनाएं (अनुमानित प्रकारों सहित);
2. अशक्त प्रकार को एक नाम दें ( null ) जिसे आप प्रकार की घोषणाओं में उपयोग कर सकते हैं;
3. null से any तक चौड़ा करना निकालें;
4. सिंटैक्स शॉर्टहैंड पेश करें T? जो कि T | null ;
5. अंतर्निहित रूपांतरणों को null से किसी अन्य प्रकार में निकालें।

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

मैंने अभी तक जीथब पर अपना काम नहीं किया है, इसलिए मैं अभी के लिए एक लिंक साझा नहीं कर सकता। मैं पहले संगतता स्विच को कोड करना चाहता था लेकिन मैं अन्य चीजों में बहुत व्यस्त रहा हूं :(
संगतता स्विच बहुत अधिक शामिल है <_<। लेकिन यह महत्वपूर्ण है क्योंकि अभी TS कंपाइलर बहुत सारी त्रुटियों के साथ खुद को संकलित करता है और बहुत सारे मौजूदा परीक्षण विफल हो जाते हैं।
लेकिन ऐसा लगता है कि वास्तव में बिल्कुल नए कोड पर अच्छी तरह से काम करता है।

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

मैं नहीं देखता कि इसे संभवतः समाधान कैसे माना जा सकता है जब अपरिभाषित शून्य से कहीं अधिक समस्या है!

अस्वीकरण: यह यहां हर किसी के दृष्टिकोण को नहीं दर्शाता है, यह सिर्फ इतना है कि मैं इसे उजागर करना चाहता था।
इसे स्वीकार करने का एकमात्र तरीका यह है कि यह किसी समस्या का समाधान है, न कि किसी समस्या के छोटे हिस्से का समाधान।

डांग फोन!
*सब लोग

*यह काफी सामने आया है कि मैं इसे उजागर करना चाहता था।

साथ ही अंतिम पैराग्राफ को "इस प्रस्ताव का एकमात्र तरीका" पढ़ना चाहिए

@ jods4 मैं कहूंगा कि यह कुछ निर्माणों पर निर्भर करेगा। कुछ मामलों में, आप उन मामलों में गैर-शून्यता की गारंटी दे सकते हैं, जैसे कि निम्नलिखित:

declare const list: T![];

for (const entry of list) {
  // `entry` is clearly immutable here.
}

list.forEach(entry => {
  // `entry` is clearly immutable here.
})

list.map(entry => {
  // `entry` is clearly immutable here.
})

इस मामले में, संकलक को यह सुनिश्चित करने के लिए तर्क का एक टन होना चाहिए कि सरणी सीमा में चेक की गई है:

declare const list: T![]

for (let i = 0; i < list.length; i++) {
  // This could potentially fail if the compiler doesn't correctly do the static bounds check.
  const entry: T![] = list[i];
}

और इस मामले में, ऐसा कोई तरीका नहीं है जिससे आप गारंटी दे सकें कि कंपाइलर entry प्राप्त करने के लिए एक्सेस को सत्यापित कर सकता है, वास्तव में कोड के कुछ हिस्सों का मूल्यांकन किए बिना सीमा में है:

declare const list: T![]

const end = round(max, list.length);

for (let i = 0; i < end; i++) {
  const entry: T![] = list[i];
}

कुछ आसान, स्पष्ट हैं, लेकिन कुछ कठिन हैं।

@impinball दरअसल, आधुनिक एपीआई जैसे map , forEach या for..of ठीक हैं क्योंकि वे उन तत्वों को छोड़ देते हैं जिन्हें कभी प्रारंभ या हटाया नहीं गया था। (उनमें वे तत्व शामिल हैं जिन्हें undefined सेट किया गया है, लेकिन हमारे काल्पनिक शून्य-सुरक्षित टीएस इसे मना करेंगे।)

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

निम्नलिखित उदाहरण पर विचार करें, आपको क्या लगता है कि TS को क्या करना चाहिए?

let array: T![] = [];  // an empty array of non-null, non-undefined T
// blah blah
array[4] = new T();  // Fine for array[4], but it means array[0..3] are undefined, is that OK?
// blah blah
let i = 2;
// Note that we could have an array bounds guard
if (i < array.length) {
  let t = array[i];  // Inferred type would be T!, but this is actually undefined :(
}

Object.defineProperty के साथ भी समस्या है।

let array = new Array(5)
Object.defineProperty(array, "length", 2, {
  get() { return 10 },
})

बुध सितम्बर 9, 2015, पर 17:49 jods [email protected] लिखा है:

@impinball https://github.com/impinball दरअसल, आधुनिक एपीआई जैसे नक्शा,
forEach या for..of ठीक हैं क्योंकि वे उन तत्वों को छोड़ देते हैं जो कभी नहीं थे
प्रारंभ या हटाया गया। (उनमें वे तत्व शामिल हैं जिन्हें सेट किया गया है
अपरिभाषित, लेकिन हमारे काल्पनिक शून्य-सुरक्षित टीएस इसे मना करेंगे।)

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

निम्नलिखित उदाहरण पर विचार करें, आपको क्या लगता है कि TS को क्या करना चाहिए?

चलो सरणी: टी! [] = []; // गैर-शून्य, गैर-अपरिभाषित टी // ब्ला ब्लाह की एक खाली सरणी
सरणी [4] = नया टी (); // सरणी के लिए ठीक है [4], लेकिन इसका मतलब है कि सरणी [0..3] अपरिभाषित हैं, क्या यह ठीक है?// ब्ला ब्लाहलेट i = 2;// ध्यान दें कि हमारे पास एक सरणी सीमा गार्डिफ (i <array. लंबाई) {
चलो टी = सरणी [i]; // अनुमानित प्रकार टी होगा!, लेकिन यह वास्तव में अपरिभाषित है :(
}

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

आपको बस इतना करना है:

1. अशक्त और अपरिभाषित प्रकारों को संदर्भ योग्य बनाएं।
2. शून्य और अपरिभाषित मानों को किसी भी चीज़ को असाइन करने योग्य होने से रोकें।
3. नल और/या अपरिभाषित के साथ एक संघ प्रकार का प्रयोग करें जहां शून्यता हमने निहित की है।

यह वास्तव में एक साहसिक ब्रेकिंग परिवर्तन है और किसी भाषा के लिए अधिक उपयुक्त लगता है
विस्तार।
10 सितंबर 2015 को सुबह 9:13 बजे, "इसिया मीडोज" नोटिफिकेशन @github.com ने लिखा:

Object.defineProperty के साथ भी समस्या है।

let array = new Array(5)
Object.defineProperty(array, "length", 2, {
get() { return 10 },
})

बुध सितम्बर 9, 2015, पर 17:49 jods [email protected] लिखा है:

@impinball https://github.com/impinball दरअसल, आधुनिक API जैसे
नक्शा,
forEach या for..of ठीक हैं क्योंकि वे उन तत्वों को छोड़ देते हैं जो कभी नहीं थे
प्रारंभ या हटाया गया। (उनमें वे तत्व शामिल हैं जिन्हें सेट किया गया है
अपरिभाषित, लेकिन हमारे काल्पनिक शून्य-सुरक्षित टीएस इसे मना करेंगे।)

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

निम्नलिखित उदाहरण पर विचार करें, आपको क्या लगता है कि TS को क्या करना चाहिए?

चलो सरणी: टी! [] = []; // गैर-शून्य, गैर-अपरिभाषित टी की एक खाली सरणी //
ब्ला ब्लाह
सरणी [4] = नया टी (); // सरणी के लिए ठीक है [4], लेकिन इसका मतलब है कि सरणी [0..3] हैं
अपरिभाषित, क्या यह ठीक है?// blah blahlet i = 2;// ध्यान दें कि हमारे पास एक हो सकता है
सरणी सीमा गार्डिफ (i < array.length) {
चलो टी = सरणी [i]; // अनुमानित प्रकार टी होगा!, लेकिन यह वास्तव में है
अपरिभाषित :(
}

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

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

@impinball
मुझे आपके उदाहरण के बारे में ठीक लगता है। इस तरह से defineProperty का उपयोग करना TS सुरक्षा बॉक्स के बाहर और गतिशील JS क्षेत्र में कदम रखना है, क्या आपको नहीं लगता? मुझे नहीं लगता कि मैंने कभी भी सीधे TS कोड में defineProperty को कॉल किया है।

@ अलेक्सी-बायकोव

भाषा विस्तार के लिए अधिक उपयुक्त लगता है।

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

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

इसे "ठीक" करने का एकमात्र तरीका ES6 में है, एक निर्माता के माध्यम से एक प्रॉक्सी लौटा रहा है,
और इसका उदाहरण प्रोटोटाइप और सेल्फ प्रोटोटाइप मूल ऐरे पर सेट है
निर्माता। कुछ इस तरह:

Array = (function (A) {
  "use strict";
  function check(target, prop) {
    const i = +prop;
    if (prop != i) return target[prop];
    if (i >= target.length) {
      throw new ReferenceError();
    }
    return i;
  }

  function Array(...args) {
    return new Proxy(new Array(...args), {
      get(target, prop) {
        return target[check(target, prop)];
      },
      set(target, prop, value) {
        return target[check(target, prop)] = value;
      },
    });
  }

  Array.prototype = A.prototype;
  Array.prototype.constructor = Array
  Object.setPrototypeOf(Array, A);
  return Array;
})(Array);

(नोट: यह परीक्षण नहीं किया गया है, फोन पर टाइप किया गया है...)

गुरु, 10 Sep, 2015, पर 10:09 jods [email protected] लिखा है:

@impinball https://github.com/impinball
मुझे आपके उदाहरण के बारे में ठीक लगता है। इस तरह से डिफाइनप्रॉपर्टी का उपयोग करना है
TS सुरक्षा बॉक्स के बाहर और गतिशील JS क्षेत्र में कदम रखते हुए, ऐसा न करें
आपको लगता है? मुझे नहीं लगता कि मैंने कभी भी टीएस कोड में सीधे डिफाइनप्रॉपर्टी को कॉल किया है।

@ एलेक्सी-बायकोव https://github.com/aleksey-bykov

भाषा विस्तार के लिए अधिक उपयुक्त लगता है।

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

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

@impinball सुनिश्चित नहीं है कि पहली जगह में "ठीक" करने के लिए कुछ है ...
वे जेएस और टीएस के शब्दार्थ हैं उन्हें किसी भी तरह से समायोजित करना चाहिए।

क्या होगा यदि हमारे पास एक स्पैस सरणी बनाम गैर-स्पैस सरणी घोषित करने के लिए बस एक (थोड़ा अलग) मार्क अप है, और गैर-स्पैस को स्वचालित रूप से प्रारंभ करें (शायद प्रोग्रामर प्रारंभिकरण के लिए एक मूल्य या समीकरण प्रदान कर सकते हैं)। इस तरह हम विरल सरणियों को T|undefined टाइप करने के लिए बाध्य कर सकते हैं (जो कि ... और अन्य 'सुरक्षित' संचालन का उपयोग करके टाइप टी में बदल जाएगा) और गैर-स्पैस सरणी के प्रकारों को अकेला छोड़ दें।

//not-sparse
var array = [arrlength] => index*3;
var array = <number[]>[3];
//sparse
var array = [];

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

@ ग्रिफोर्क
मुझे नहीं पता... यह भ्रमित हो जाता है।

इस तरह हम विरल सरणियों को T|undefined टाइप करने के लिए बाध्य कर सकते हैं (जो कि ... और अन्य 'सुरक्षित' संचालन का उपयोग करके टाइप टी में बदल जाएगा)

जेएस में एक विचित्रता के कारण यह उस तरह से काम नहीं करता है। मान लें let arr: (T|undefined)[] ।
तो मैं यह करने के लिए स्वतंत्र हूं: arr[0] = undefined ।
अगर मैं ऐसा करता हूं तो उन "सुरक्षित" कार्यों का उपयोग करके _will_ पहले स्लॉट के लिए undefined लौटाएं। तो arr.forEach(x => ...) आप यह नहीं कह सकते कि x: T । इसे अभी भी x: T|undefined ।

दूसरा उदाहरण प्रत्येक मान को उस प्रकार के लिए कंपाइलर-डिफॉल्ट में प्रारंभ करेगा।

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

TS स्पष्ट रूप से JS में हर चीज से आपकी रक्षा नहीं कर सकता है और ऐसे कई कार्य / निर्माण हैं जिन्हें आप मान्य TS से कॉल कर सकते हैं, जो आपकी वस्तुओं के रनटाइम प्रकार पर गतिशील प्रभाव डालते हैं और स्थिर TS प्रकार के विश्लेषण को तोड़ते हैं।

क्या यह बुरा होगा अगर यह टाइप सिस्टम में एक छेद था? मेरा मतलब है, यह कोड वास्तव में आम नहीं है: let x: number[] = []; x[3] = 0; और यदि आप इस तरह की चीजें करना चाहते हैं तो शायद आपको अपनी सरणी let x: number?[] घोषित करनी चाहिए।

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

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

उन लोगों के लिए जो नहीं जानते कि यह क्यों महत्वपूर्ण है, यही कारण है कि आप
T और T|null बीच अंतर चाहते हैं।

9:11 AM पर, शुक्र सितम्बर 11, 2015 jods [email protected] लिखा है:

@ ग्रिफोर्क https://github.com/Griffork
मुझे नहीं पता... यह भ्रमित हो जाता है।

इस तरह हम विरल सरणियों को टाइप करने के लिए बाध्य कर सकते हैं टी | अपरिभाषित (जो होगा
और अन्य 'सुरक्षित' संचालन के लिए ... का उपयोग करके टी टाइप करने के लिए बदलें)

जेएस में एक विचित्रता के कारण यह उस तरह से काम नहीं करता है। मान लें गिरफ्तार:
(टी | अपरिभाषित) []।
तो मैं करने के लिए स्वतंत्र हूँ: गिरफ्तार [0] = अपरिभाषित।
अगर मैं ऐसा करता हूं तो उन "सुरक्षित" कार्यों का उपयोग करके _will_ वापसी अपरिभाषित
पहले स्लॉट के लिए। तो arr.forEach(x => ...) में आप यह नहीं कह सकते कि x: T.
यह अभी भी एक्स होना चाहिए: टी | अपरिभाषित।

दूसरा उदाहरण प्रत्येक मान को कंपाइलर-डिफॉल्ट में प्रारंभ करेगा
उस प्रकार के लिए।

यह आत्मा में बहुत TS जैसा नहीं है। शायद मैं गलत हूँ लेकिन मुझे ऐसा लगता है
वह TS दर्शन यह है कि JS के शीर्ष पर प्रकार केवल एक अतिरिक्त परत है
और वे codegen को प्रभावित नहीं करते हैं। इसके लिए पूर्ण निहितार्थ हैं
आंशिक प्रकार-शुद्धता जो मुझे काफी पसंद नहीं है।

TS स्पष्ट रूप से JS में हर चीज से आपकी रक्षा नहीं कर सकता है और वहाँ हैं
कई कार्य / संरचनाएं जिन्हें आप वैध टीएस से कॉल कर सकते हैं, जो है
आपकी वस्तुओं के रनटाइम प्रकार पर गतिशील प्रभाव और स्थिर TS
विश्लेषण टाइप करें।

क्या यह बुरा होगा अगर यह टाइप सिस्टम में एक छेद था? मेरा मतलब है, यह कोड
वास्तव में आम नहीं है: चलो x: संख्या [] = []; एक्स [3] = 0; और अगर वह है
आप जिस तरह की चीजें करना चाहते हैं, हो सकता है कि आपको अपनी सरणी घोषित करनी चाहिए
एक्स: संख्या? []।

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

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

@ jods4 "फिक्सिंग" से

@jods मैं जेएस के बारे में शिकायत कर रहा हूं, टीएस नहीं। मैं मानता हूँ कि यह विषय से हटकर है।

गुरु, सितम्बर 10, 2015, 19:19 को ग्रिफोर्क नोटिफिकेशन @github.com ने लिखा:

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

उन लोगों के लिए जो नहीं जानते कि यह क्यों महत्वपूर्ण है, यही कारण है कि आप
T और T|null बीच अंतर चाहते हैं।

9:11 AM पर, शुक्र सितम्बर 11, 2015 jods [email protected] लिखा है:

@ ग्रिफोर्क https://github.com/Griffork
मुझे नहीं पता... यह भ्रमित हो जाता है।

इस तरह हम विरल सरणियों को टाइप करने के लिए बाध्य कर सकते हैं टी | अपरिभाषित (जो होगा
और अन्य 'सुरक्षित' संचालन के लिए ... का उपयोग करके टी टाइप करने के लिए बदलें)

जेएस में एक विचित्रता के कारण यह उस तरह से काम नहीं करता है। मान लें गिरफ्तार:
(टी | अपरिभाषित) []।
तो मैं करने के लिए स्वतंत्र हूँ: गिरफ्तार [0] = अपरिभाषित।
अगर मैं ऐसा करता हूं तो उन "सुरक्षित" कार्यों का उपयोग करके _will_ वापसी अपरिभाषित
पहले स्लॉट के लिए। तो arr.forEach(x => ...) में आप यह नहीं कह सकते कि x: T.
यह अभी भी एक्स होना चाहिए: टी | अपरिभाषित।

दूसरा उदाहरण प्रत्येक मान को कंपाइलर-डिफॉल्ट में प्रारंभ करेगा
उस प्रकार के लिए।

यह आत्मा में बहुत TS जैसा नहीं है। शायद मैं गलत हूँ लेकिन मुझे ऐसा लगता है
टीएस दर्शन यह है कि प्रकार केवल शीर्ष पर एक अतिरिक्त परत हैं
जे एस
और वे codegen को प्रभावित नहीं करते हैं। इसके लिए पूर्ण निहितार्थ हैं
आंशिक प्रकार-शुद्धता जो मुझे काफी पसंद नहीं है।

TS स्पष्ट रूप से JS में हर चीज से आपकी रक्षा नहीं कर सकता है और वहाँ हैं
कई कार्य / संरचनाएं जिन्हें आप वैध टीएस से कॉल कर सकते हैं, जो
पास होना
आपकी वस्तुओं के रनटाइम प्रकार पर गतिशील प्रभाव और स्थिर TS
विश्लेषण टाइप करें।

क्या यह बुरा होगा अगर यह टाइप सिस्टम में एक छेद था? मेरा मतलब है, यह कोड
वास्तव में आम नहीं है: चलो x: संख्या [] = []; एक्स [3] = 0; और अगर वह है
आप जिस तरह की चीजें करना चाहते हैं, शायद आपको अपनी सरणी घोषित करनी चाहिए
होने देना
एक्स: संख्या? []।

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

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

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

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

मुझे पता है कि मिलान सी/सी ++ अपरिभाषित व्यवहार सतह पर बहुत बेवकूफ लगता है, लेकिन मुझे लगता है कि इस मामले में, यह इसके लायक हो सकता है। ऐसा कुछ देखना दुर्लभ है जो वास्तव में सीमा से बाहर पहुंच बनाकर _better_ किया जाता है। इसके लिए मैंने जो 99.99% उपयोग देखे हैं, वे केवल बेहद तीखी कोड गंध हैं, लगभग हमेशा उन लोगों द्वारा किए जाते हैं जिन्हें जावास्क्रिप्ट से लगभग कोई परिचित नहीं है।

(इनमें से अधिकतर लोगों ने, मेरे अनुभव में, कॉफीस्क्रिप्ट के बारे में भी नहीं सुना है, बहुत कम टाइपस्क्रिप्ट। उनमें से कई जेएस के नए संस्करण से भी अनजान हैं जिसे अभी अंतिम रूप दिया गया था और मानकीकृत किया गया था, ईएस2015।)

क्या इसका कोई उभरता हुआ संकल्प है?

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

var o = null;
console.log(o.x);

... विफल होना चाहिए।

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

ऐसा लगता है कि तीन विकल्प हैं जो मानते हैं कि संकलन समय पर सरणियों पर सीमा-जांच लागू नहीं की जाती है:

1. सरणी अनुक्रमण (और अनुक्रमणिका द्वारा किसी भी मनमानी सरणी तत्व पहुंच) को गैर-शून्य प्रकार के सरणी पर भी एक शून्य प्रकार वापस करने के लिए माना जाता है। अनिवार्य रूप से, [] "विधि" में T? का एक प्रकार का हस्ताक्षर है। यदि आप जानते हैं कि आप केवल बाउंड-चेक इंडेक्सिंग कर रहे हैं, तो आप अपने एप्लिकेशन कोड में T? को T! में डाल सकते हैं।
2. ऐरे इंडेक्सिंग सरणी के सामान्य प्रकार पैरामीटर के रूप में बिल्कुल उसी प्रकार (उसी शून्यता के साथ) देता है, और यह माना जाता है कि सभी सरणी एक्सेस एप्लिकेशन द्वारा सीमा-जांच की जाती है। आउट-ऑफ-बाउंड एक्सेस undefined लौटाएगा, और टाइप-चेकर द्वारा पकड़ा नहीं जाएगा।
3. परमाणु विकल्प: सभी सरणियों को अशक्त होने के कारण भाषा में हार्डकोड किया जाता है, और गैर-अशक्त सरणियों का उपयोग करने का प्रयास टाइपचेक विफल हो जाता है।

ये सभी वस्तुओं पर गुणों की अनुक्रमणिका-आधारित पहुंच पर भी लागू होते हैं, उदाहरण के लिए object['property'] जहां object प्रकार का है { [ key: string ]: T! } ।

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

एक दूसरा प्रश्न है कि क्या प्रकार डिफ़ॉल्ट रूप से गैर-शून्य होना चाहिए, या डिफ़ॉल्ट रूप से शून्य होना चाहिए। ऐसा लगता है कि किसी भी मामले में जेनेरिक को संभालने के लिए स्पष्ट रूप से शून्य और स्पष्ट रूप से गैर-शून्य प्रकार के लिए वाक्यविन्यास होना उपयोगी होगा; उदाहरण के लिए एक कंटेनर वर्ग (उदाहरण के लिए एक नक्शा) पर get विधि की कल्पना करें जिसने कुछ मूल्य लिया और संभावित रूप से एक प्रकार लौटाया, _यहां तक ​​​​कि यदि कंटेनर में केवल गैर-शून्य मान शामिल हैं_:

class Container<K,V> {
  get(key: K): V? {
    // fetch from some internal data structure and return the value, if it exists
    // return null otherwise
  }
}

// only non-nullable values allowed in the container
const container = new Container<SomeKeyClass!, SomeValueClass!>();
const val: SomeValueClass!;
// ... later, we attempt to read from the container with a get() call
// even though only non-nullables are allowed in the container, the following should fail:
// get() explicitly returns null when the item can't be found
val = container.get(someKey);

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

class Container<K, V> {
  insert(key: K!, val: V): void {
    // put the val in the data structure
    // the key must not be null here, even if K is elsewhere a nullable type
  }
}

const container = new Container<SomeKeyClass?, SomeValueClass>();
container.insert(null, new SomeValueClass()); // fails

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

उस बिंदु पर जहां दोनों के लिए वाक्यविन्यास है, डिफ़ॉल्ट ऐसा लगता है जैसे यह --noImplicitAny समान एक कंपाइलर ध्वज हो सकता है। व्यक्तिगत रूप से मैं 2.0 रिलीज तक डिफ़ॉल्ट रहने के लिए वोट दूंगा, लेकिन जब तक कोई बचने वाला हैच (कम से कम अस्थायी रूप से) तब तक ठीक लगता है।

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

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

उदाहरण के रूप में एक योग फ़ंक्शन का उपयोग करते हुए, प्रत्येक विकल्प के साथ तुलना यहां दी गई है (आदिम सबसे अधिक समस्याग्रस्त हैं):

// Option 1
function sum(numbers: !number[]) {
  let res = 0
  for (let i = 0; i < numbers.length; i++) {
    res += <!number> numbers[i]
  }
  return res
}

// Option 2
function sum(numbers: !number[]) {
  let res = 0
  for (let i = 0; i < numbers.length; i++) {
    res += numbers[i]
  }
  return res
}

// Option 3
function sum(numbers: number[]) {
  let res = 0
  for (let i = 0; i < numbers.length; i++) {
    res += <!number> numbers[i]
  }
  return res
}

एक अन्य उदाहरण: map फ़ंक्शन।

// Option 1
function map<T>(list: !T[], f: (value: !T, index: !number) => !T): !T[] {
  let res: !T[] = []
  for (let i = 0; i < list.length; i++) {
    res.push(f(<!T> list[i], i));
  }
  return res
}

// Option 2
function map<T>(list: !T[], f: (value: !T, index: !number) => !T): !T[] {
  let res: !T[] = []
  for (let i = 0; i < list.length; i++) {
    res.push(f(list[i], i));
  }
  return res
}

// Option 3
function map<T>(list: T[], f: (value: !T, index: !number) => !T): T[] {
  let res: T[] = []
  for (let i = 0; i < list.length; i++) {
    const entry = list[i]
    if (entry !== undefined) {
      res.push(f(<!T> entry, i));
    }
  }
  return res
}

एक अन्य प्रश्न: इनमें से प्रत्येक में entry का प्रकार क्या है? !string , ?string , या string ?

declare const regularStrings: string[];
declare const nullableStrings: ?string[];
declare const nonnullableStrings: !string[];

for (const entry of regularStrings) { /* ... */  }
for (const entry of nullableStrings) { /* ... */  }
for (const entry of nonnullableStrings) { /* ... */  }

विकल्प तीन एक जुबान-इन-गाल सुझाव था :stuck_out_tongue:

पुन: आपका अंतिम प्रश्न:

declare const regularStrings: string[];
declare const nullableStrings: string?[];
declare const nonNullableStrings: string![]; // fails typecheck in option three

for(const entry of regularStrings) {
  // option 1: entry is of type string?
  // option 2: depends on default nullability
}

for(const entry of nullableStrings) {
  // option 1 and 2: entry is of type string?
}

for(const entry of nonNullableStrings) {
  // option 1: entry is of type string?
  // option 2: entry is of type string!
}

कुछ मामलों में - जहां आप एक गैर-शून्य प्रकार वापस करना चाहते हैं और आप इसे एक सरणी से प्राप्त कर रहे हैं, उदाहरण के लिए - आपको विकल्प के साथ एक अतिरिक्त कास्ट करना होगा, यह मानते हुए कि आपने कहीं और गारंटी दी है कि कोई अपरिभाषित मान नहीं है सरणी में (इस गारंटी की आवश्यकता इस बात की परवाह किए बिना नहीं बदलती है कि कौन सा दृष्टिकोण लिया गया है, केवल as string! टाइप करने की आवश्यकता है)। व्यक्तिगत रूप से मैं अभी भी इसे पसंद करता हूं क्योंकि यह दोनों अधिक स्पष्ट है (आपको यह निर्दिष्ट करना होगा कि आप संभावित रूप से खतरनाक व्यवहार कब ले रहे हैं, इसके विपरीत यह स्पष्ट रूप से हो रहा है) और अधिकांश कंटेनर वर्ग कैसे काम करते हैं इसके अनुरूप: उदाहरण के लिए, मानचित्र का get फ़ंक्शन स्पष्ट रूप से शून्य प्रकार देता है (यदि यह कुंजी के नीचे मौजूद है, या यदि यह नहीं है तो शून्य है), और यदि Map.prototype.get एक शून्य देता है तो object['property'] शायद करना चाहिए वही, क्योंकि वे अशक्तता के बारे में समान गारंटी देते हैं और समान रूप से उपयोग किए जाते हैं। जो अजीब लोगों के रूप में सरणी छोड़ देता है जहां शून्य संदर्भ त्रुटियां वापस रेंग सकती हैं, और जहां प्रकार प्रणाली द्वारा यादृच्छिक पहुंच को गैर-शून्य होने की अनुमति है।

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

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

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

टाइपस्क्रिप्ट को वास्तव में चीजों को मुखर करने के एक तरीके की आवश्यकता होती है, क्योंकि अभिकथन अक्सर होते हैं
अन्य भाषाओं में स्थिर प्रकार की जाँच में सहायता के लिए उपयोग किया जाता है। मैंने में देखा है
V8 कोड आधार एक UNREACHABLE(); मैक्रो है जो अनुमानों को a . होने की अनुमति देता है
थोड़ा और सुरक्षित रूप से, प्रोग्राम को क्रैश करना यदि अपरिवर्तनीय का उल्लंघन किया जाता है। सी++
टाइप जाँच में सहायता के लिए स्थिर अभिकथन के लिए static_assert ।

मंगलवार, 20 अक्टूबर, 2015 को सुबह 4:01 बजे, मैट बेकर नोटिफिकेशन @github.com
लिखा था:

विकल्प तीन एक जुबान-इन-गाल सुझाव था [छवि:
:अटक_बाहर_जीभ:]

पुन: आपका अंतिम प्रश्न:

कॉन्स रेगुलर स्ट्रिंग्स घोषित करें: स्ट्रिंग []; कॉन्स्टेबल अशक्त घोषित करें: स्ट्रिंग? []; कॉन्स्ट नॉन-न्यूलेबल स्ट्रिंग्स घोषित करें: स्ट्रिंग! []; // विकल्प तीन में टाइपचेक विफल रहता है
के लिए (नियमित स्ट्रिंग्स की स्थिरांक प्रविष्टि) {
// विकल्प 1: प्रविष्टि प्रकार स्ट्रिंग की है?
// विकल्प 2: डिफ़ॉल्ट अशक्तता पर निर्भर करता है
}
for(nullableStrings की स्थिरांक प्रविष्टि) {
// विकल्प 1 और 2: प्रविष्टि प्रकार स्ट्रिंग की है?
}
for(nonNullableStrings की स्थिरांक प्रविष्टि) {
// विकल्प 1: प्रविष्टि प्रकार स्ट्रिंग की है?
// विकल्प 2: प्रविष्टि स्ट्रिंग प्रकार की है!
}

कुछ मामलों में - जहां आप एक गैर-शून्य प्रकार वापस करना चाहते हैं और आप हैं
इसे एक सरणी से प्राप्त करना, उदाहरण के लिए - आपको एक अतिरिक्त कास्ट करना होगा
विकल्प के साथ यह मानते हुए कि आपने कहीं और गारंटी दी है कि कोई अपरिभाषित नहीं है
सरणी में मान (इस गारंटी की आवश्यकता नहीं बदली है
कोई फर्क नहीं पड़ता कि कौन सा दृष्टिकोण लिया जाता है, केवल स्ट्रिंग के रूप में टाइप करने की आवश्यकता है!)
व्यक्तिगत रूप से मैं अभी भी इसे पसंद करता हूं क्योंकि यह दोनों अधिक स्पष्ट है (आपको करना होगा
निर्दिष्ट करें कि आप इसके विपरीत संभावित-खतरनाक व्यवहार कब कर रहे हैं
निहित रूप से हो रहा है) और अधिकांश कंटेनर वर्गों के लिए अधिक सुसंगत है
कार्य: उदाहरण के लिए, मानचित्र का प्राप्त फ़ंक्शन स्पष्ट रूप से अशक्त प्रकार देता है
(यदि यह कुंजी के नीचे मौजूद है, या शून्य नहीं है तो यह ऑब्जेक्ट देता है),
और अगर Map.prototype.get एक अशक्त रिटर्न देता है तो object['property']
शायद ऐसा ही करना चाहिए, क्योंकि वे इसी तरह की गारंटी देते हैं
शून्यता और समान रूप से उपयोग किया जाता है। जो विषम के रूप में सरणियों को छोड़ देता है
जहां शून्य संदर्भ त्रुटियां वापस आ सकती हैं, और जहां यादृच्छिक अभिगम है
प्रकार प्रणाली द्वारा गैर-शून्य होने की अनुमति है।

निश्चित रूप से अन्य दृष्टिकोण हैं; उदाहरण के लिए, वर्तमान में प्रवाह उपयोग करता है
विकल्प दो http://flowtype.org/docs/nullable-types.html , और अंतिम I
चेक किए गए साउंडस्क्रिप्ट ने विरल सरणियों को उनकी कल्पना में स्पष्ट रूप से अवैध बना दिया
https://github.com/rwaldron/tc39-notes/blob/master/es6/2015-01/JSExperimentalDirections.pdf
(ठीक है, मजबूत मोड/"सेनस्क्रिप्ट" उन्हें अवैध बनाता है, और साउंडस्क्रिप्ट एक है
नए नियमों का सुपरसेट), जो कुछ हद तक समस्या को दूर करता है
हालांकि उन्हें अभी भी यह पता लगाने की आवश्यकता होगी कि मैन्युअल लंबाई से कैसे निपटें
परिवर्तन और प्रारंभिक आवंटन के साथ।

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

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

इसिया मीडोज

क्या हमें उन्हें non-void प्रकार कहना शुरू कर देना चाहिए? किसी भी मामले में, मुझे लगता है कि non-void को T! या !T साथ स्पष्ट रूप से परिभाषित करना एक गलती है। एक इंसान के रूप में पढ़ना मुश्किल है, और टाइपस्क्रिप्ट कंपाइलर के सभी मामलों से निपटना भी मुश्किल है।

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

``` .ts
// फ़ंक्शन खुशी से संकलित करता है
फ़ंक्शन लेन (x: स्ट्रिंग): संख्या {
वापसी x.लंबाई;
}

लेन ("काम करता है"); // 5
लेन (शून्य); // त्रुटि, शून्य की कोई संपत्ति लंबाई नहीं

``` .ts
function len(x: string): number {
    if (x === null) {
        return -1;
    }
    return x.length;
}

len("works"); // 5
len(null); // null

वास्तव में यहां क्या चल रहा होगा इनपुट डेटा को non-void रूप में मॉडलिंग कर रहा है, लेकिन जब इसे फ़ंक्शन में संभाला जाता है तो void परोक्ष रूप से जोड़ना। इसी तरह, वापसी प्रकार non-void जब तक कि यह स्पष्ट रूप से null या undefined

हम ?T या T? प्रकार भी जोड़ सकते हैं, जो उपयोग से पहले शून्य (और/या अपरिभाषित) जांच को बाध्य करता है। व्यक्तिगत रूप से मुझे T? , लेकिन फ्लो के साथ ?T का उपयोग करने की मिसाल है।

``` .ts
फ़ंक्शन लेन (एक्स:? स्ट्रिंग): संख्या {
वापसी x.लंबाई; // त्रुटि: प्रकार पर कोई लंबाई की संपत्ति नहीं है? स्ट्रिंग, आपको एक प्रकार के गार्ड का उपयोग करना चाहिए
}

One more example -- what about using function results?

``` .js
function len(x: string): number {
    return x.length;
}

function identity(f: string): string {
    return f;
}

function unknown(): string {
    if (Math.random() > 0.5) {
        return null;
    }
    return "maybe";
}

len("works"); // 5
len(null); // error, no property length of null

identity("works"); // "works": string
identity(null); // null: void
unknown(); // ?string

len(identity("works")); // 5
len(identity(null)); // error, no property length of null
len(unknown()); // error: no length property on type ?string, you must use a type guard

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

यहां एकमात्र मुश्किल हिस्सा यह है कि परिभाषा फाइलों के साथ कैसे इंटरफेस किया जाए। मुझे लगता है कि इसे डिफ़ॉल्ट मान कर हल किया जा सकता है कि function(t: T) घोषित करने वाली एक परिभाषा फ़ाइल दूसरे उदाहरण की तरह शून्य/ void जांच करती है। इसका मतलब यह है कि वे फ़ंक्शन संकलक के बिना त्रुटि उत्पन्न किए बिना शून्य मान लेने में सक्षम होंगे।

यह अब दो चीजों की अनुमति देता है:

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

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

उपसर्ग ? प्रकार का उपयोग क्लोजर कंपाइलर एनोटेशन, IIRC में भी किया जाता है।

मंगलवार, 17 नवंबर, 2015, 13:37 को टॉम जैक्स नोटिफिकेशन @github.com ने लिखा:

क्या हमें उन्हें गैर-शून्य प्रकार कहना शुरू कर देना चाहिए? किसी भी मामले में, मुझे लगता है
टी के साथ गैर-शून्य को स्पष्ट रूप से परिभाषित करना! या !T एक गलती है। यह मुश्किल है
एक इंसान के रूप में पढ़ने के लिए, और सभी मामलों से निपटने के लिए भी मुश्किल
टाइपस्क्रिप्ट कंपाइलर।

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

// फ़ंक्शन खुशी से संकलित करता है लेन (x: स्ट्रिंग): संख्या {
वापसी x.लंबाई;
}

लेन ("काम करता है"); // 5
लेन (शून्य); // त्रुटि, शून्य की कोई संपत्ति लंबाई नहीं

फ़ंक्शन लेन (x: स्ट्रिंग): संख्या {
अगर (एक्स === शून्य) {
वापसी -1;
}
वापसी x.लंबाई;
}

लेन ("काम करता है"); // 5
लेन (शून्य); // शून्य

वास्तव में यहाँ क्या चल रहा है इनपुट डेटा को गैर-शून्य के रूप में मॉडलिंग कर रहा है,
लेकिन जब इसे फ़ंक्शन में संभाला जाता है तो शून्य रूप से शून्य जोड़ना। इसी तरह,
वापसी प्रकार गैर-शून्य है जब तक कि यह स्पष्ट रूप से शून्य या वापस नहीं लौटा सकता
अपरिभाषित

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

फ़ंक्शन लेन (एक्स:? स्ट्रिंग): संख्या {
वापसी x.लंबाई; // त्रुटि: प्रकार पर कोई लंबाई की संपत्ति नहीं है? स्ट्रिंग, आपको एक प्रकार के गार्ड का उपयोग करना चाहिए
}

एक और उदाहरण - फ़ंक्शन परिणामों का उपयोग करने के बारे में क्या?

फ़ंक्शन लेन (x: स्ट्रिंग): संख्या {
वापसी x.लंबाई;
}
फ़ंक्शन पहचान (एफ: स्ट्रिंग): स्ट्रिंग {
वापसी च;
}
फ़ंक्शन अज्ञात (): स्ट्रिंग {
अगर (गणित। यादृच्छिक ()> 0.5) {
वापसी शून्य;
}
वापसी "शायद";
}

लेन ("काम करता है"); // 5
लेन (शून्य); // त्रुटि, शून्य की कोई संपत्ति लंबाई नहीं

पहचान ("काम करता है"); // "काम करता है": स्ट्रिंग
पहचान (शून्य); // अमान्य शून्य
अनजान(); // ?डोरी

लेन (पहचान ("काम करता है")); // 5
लेन (पहचान (शून्य)); // त्रुटि, शून्य की कोई संपत्ति लंबाई नहीं
लेन (अज्ञात ()); // त्रुटि: प्रकार पर कोई लंबाई की संपत्ति नहीं है? स्ट्रिंग, आपको एक प्रकार के गार्ड का उपयोग करना चाहिए

हुड के तहत, वास्तव में यहाँ क्या हो रहा है कि टाइपस्क्रिप्ट है
यह देखते हुए कि क्या यह संभालता है या नहीं, यह देखकर कि कोई प्रकार शून्य हो सकता है या नहीं
शून्य, और संभावित रूप से शून्य मान दिया गया है।

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

यह अब दो चीजों की अनुमति देता है:

1. ?T टाइप सिंटैक्स को धीरे-धीरे अपनाना, जिसमें से वैकल्पिक
   पैरामीटर पहले ही बदल दिए जाएंगे।
2. भविष्य में एक संकलक ध्वज --noImplicitVoid, जोड़ा जा सकता है
   जो डिक्लेरेशन फाइलों को संकलित कोड फाइलों के समान मानेगा। इस
   "ब्रेकिंग" होगा, लेकिन अगर सड़क से बहुत नीचे किया जाए, तो अधिकांश
   पुस्तकालय ?T का उपयोग करने के सर्वोत्तम अभ्यास को अपनाएंगे जब प्रकार कर सकते हैं
   शून्य हो और टी जब यह नहीं हो सकता। यह ऑप्ट-इन भी होगा, इसलिए केवल वे
   जो इसका उपयोग करना चुनते हैं वे प्रभावित होंगे।

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

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

अच्छी बात। मौजूदा वैकल्पिक पैरामीटर घोषणाओं के साथ भी बहुत सी समानताएँ हैं:

``` .ts
वैकल्पिक संपत्ति के साथ इंटरफ़ेस {
ओ ?: स्ट्रिंग
}
VoidableProperty के साथ इंटरफ़ेस {
ओ:?स्ट्रिंग
}

वैकल्पिकपरम के साथ फ़ंक्शन (ओ ?: स्ट्रिंग) { }
VoidableParam के साथ फ़ंक्शन (ओ:? स्ट्रिंग) { }
```

दरअसल, वे उपसर्ग का उपयोग करते हैं । वे स्पष्ट अशक्त प्रकारों के लिए ? उपयोग करते हैं और गैर-शून्य प्रकारों के लिए ! करते हैं, जिसमें अशक्त डिफ़ॉल्ट होता है।

शून्य करने योग्य बनाम अशक्त भेद बहुत मायने रखता है। :+1:

मुझे ऐसा लग रहा है कि यह मंडलियों में घूम रहा है।

क्या आप सभी ने ऊपर पढ़ा है कि क्यों एक शून्यकरणीय/गैर-शून्य करने योग्य परिभाषा अंतर्निहित समस्या का समाधान नहीं करने जा रही है?

@ ग्रिफोर्क मैंने हर टिप्पणी पढ़ी है। मैं मानता हूँ कि मैंने जो कहा है वह कुछ हद तक दूसरों की कही गई बातों का पुनर्मूल्यांकन/संयोजन है, लेकिन मुझे लगता है कि यह आगे का सबसे यथार्थवादी मार्ग है। मैं नहीं जानता कि आप अंतर्निहित समस्या के रूप में क्या देखते हैं, लेकिन मेरे लिए अंतर्निहित समस्या यह है कि null और undefined हर प्रकार का हिस्सा हैं, और संकलक वर्तमान में कोशिश करते समय सुरक्षा सुनिश्चित नहीं करता है T प्रकार के तर्क का उपयोग करने के लिए। मेरे उदाहरण के अनुसार:

``` .ts
फ़ंक्शन लेन (x: स्ट्रिंग): संख्या {
वापसी x.लंबाई;
}

लेन ("काम करता है");
// कोई त्रुटि नहीं - 5

लेन (शून्य);
// कंपाइलर इसकी अनुमति देता है, लेकिन यहां कुछ इस तरह से त्रुटि होनी चाहिए
// त्रुटि: शून्य की कोई संपत्ति 'लंबाई' नहीं है

लेन (अपरिभाषित);
// कंपाइलर इसकी अनुमति देता है, लेकिन यहां कुछ इस तरह से त्रुटि होनी चाहिए
// त्रुटि: अपरिभाषित की कोई संपत्ति 'लंबाई' नहीं है
```

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

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

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

भाग एक:

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

भाग दो:

• रुकना। बाद में पार्ट वन की शुरुआत के बाद लाइन नीचे, और टीएस के समुदाय और उपयोगकर्ताओं के पास उन सुविधाओं का उपयोग करने का समय है, मानक T का उपयोग करना होगा जब प्रकार शून्य नहीं है, और ?T जब प्रकार शून्य हो सकता है। इसकी गारंटी नहीं है, लेकिन मुझे लगता है कि यह एक स्पष्ट स्पष्ट सर्वोत्तम अभ्यास होगा।
• एक अलग सुविधा के रूप में, एक कंपाइलर विकल्प जोड़ें --noImplicitVoid जिसके लिए प्रकारों की आवश्यकता होती है ?T यदि वे शून्य हो सकते हैं। यह सिर्फ पहले से मौजूद सर्वोत्तम अभ्यास को लागू करने वाला संकलक है। यदि कोई परिभाषा फ़ाइल है जो सर्वोत्तम अभ्यास का पालन नहीं करती है तो यह गलत होगा, लेकिन इसलिए यह ऑप्ट-इन है।
• यदि आप वास्तव में सख्त होना चाहते हैं, तो ध्वज यह निर्दिष्ट करने वाले तर्कों को स्वीकार कर सकता है कि इसे किन निर्देशिकाओं/फाइलों पर लागू होना चाहिए। तब आप परिवर्तन को केवल अपने कोड पर लागू कर सकते हैं, और node_modules ।

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

@tejacques मैं, एक के लिए, पूरी तरह से इसके साथ हूं।

@tejacques - FWIW, मैं आपके आकलन और प्रस्ताव से पूरी तरह सहमत हूं। आइए आशा करते हैं कि टीएस टीम सहमत हो :)

दरअसल, दो चीजें:

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

मैं --noImplicitVoid को थोड़ा अलग तरीके से भी वाक्यांश दूंगा - मान लें कि यह null और undefined को गैर-शून्य करने योग्य (यानी, डिफ़ॉल्ट) प्रकारों को निर्दिष्ट करने की अनुमति नहीं देता है बजाय "आवश्यक प्रकार होने के लिए" ?T अगर वे शून्य हो सकते हैं"। मुझे पूरा यकीन है कि हमारा मतलब एक ही है, सिर्फ शब्दार्थ; परिभाषा के बजाय उपयोग पर ध्यान केंद्रित करता है, जो, अगर मैं समझता हूं कि टीएस कैसे काम करता है, केवल वही चीजें हैं जो वास्तव में लागू कर सकती हैं।

और अभी कुछ दिमाग में आया है: तब हमारे पास शून्यता के चार स्तर होंगे (यह फ्लो के बारे में भी सच है, जो मुझे लगता है कि इस बातचीत का एक अच्छा सौदा प्रेरित कर रहा है):

interface Foo {
  w: string;
  x?: string;
  y: ?string;
  z?: ?string;
}

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

x वर्तमान सेटिंग्स के तहत पूरी तरह से उदार है। यह एक स्ट्रिंग, अशक्त, अपरिभाषित हो सकता है, और इसे लागू करने वाली वस्तुओं में भी मौजूद होने की आवश्यकता नहीं है। --noImplicitVoid तहत, चीजें थोड़ी अधिक जटिल हो जाती हैं ... आप इसे परिभाषित नहीं कर सकते हैं, लेकिन यदि आप _do_ इसमें कुछ सेट करते हैं, तो क्या यह शून्य नहीं हो सकता है? मुझे लगता है कि फ्लो इसे संभालने का तरीका यह है कि आप x से undefined (गैर-अस्तित्व की नकल) सेट कर सकते हैं, लेकिन null । हालाँकि, टाइपस्क्रिप्ट के लिए यह थोड़ा बहुत विचारणीय हो सकता है।

साथ ही, इसका उपयोग करने से पहले x शून्य-जांच की आवश्यकता के लिए तार्किक अर्थ होगा, लेकिन यह फिर से एक ब्रेकिंग परिवर्तन होगा। क्या यह व्यवहार --noImplicitVoid ध्वज का हिस्सा हो सकता है?

y को किसी भी स्ट्रिंग या शून्य मान पर सेट किया जा सकता है, लेकिन _must_ किसी न किसी रूप में मौजूद होना चाहिए, भले ही शून्य हो। और, ज़ाहिर है, इसे एक्सेस करने के लिए एक शून्य-जांच की आवश्यकता होती है। यह व्यवहार थोड़ा चौंकाने वाला हो सकता है। क्या हमें _not_ को इसे undefined सेट करने जैसा ही मानना ​​चाहिए? यदि हां, तो शून्य जांच की आवश्यकता को छोड़कर, इसे x से अलग क्या बना देगा?

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

x और y बीच कुछ ओवरलैप है, और मुझे संदेह है कि x अंततः समुदाय द्वारा बहिष्कृत हो जाएगा, अधिकतम सुरक्षा के लिए z फॉर्म को प्राथमिकता देते हुए .

@tejacques

कोड उपलब्ध होने पर किसी भी ?T प्रकार के होने की आवश्यकता नहीं है क्योंकि वह विश्लेषण किया जा सकता है (यद्यपि हर मामले में हर समय पूरी तरह से सटीक नहीं)।

यह कथन गलत है। पूर्ण कोड स्रोत उपलब्ध होने पर भी अशक्तता के बहुत सारे पहलुओं का हिसाब नहीं दिया जा सकता है।

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

एक अन्य उदाहरण: यदि मेरे पास एक सरणी list और एक फ़ंक्शन unsafe(x) जिसका स्रोत कोड दिखाता है कि यह null तर्क को स्वीकार नहीं करता है, तो संकलक यह नहीं कह सकता है कि लाइन सुरक्षित है या नहीं: list.filter(unsafe) । और वास्तव में, जब तक आप स्थिर रूप से यह नहीं जान सकते कि list सभी संभावित सामग्री क्या होगी, यह नहीं किया जा सकता है।

अन्य मामले विरासत और बहुत कुछ से जुड़े हैं।

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

मैंने इस चर्चा में कहीं कहा था कि मुझे लगता है कि अशक्तता का अनुमान कई साधारण मामलों में पिछड़ी संगतता को कम करने में मदद कर सकता है। लेकिन यह स्रोत एनोटेशन को पूरी तरह से प्रतिस्थापित नहीं कर सकता है।

@tejacques my bad, मैंने आपकी टिप्पणी को गलत तरीके से पढ़ा (किसी कारण से मेरे दिमाग ने void===null फैसला किया :( मैं सिर्फ जागने को दोष देता हूं)।
हालांकि अतिरिक्त पोस्ट के लिए धन्यवाद, यह आपकी मूल पोस्ट की तुलना में मेरे लिए कहीं अधिक समझ में आया। मुझे वास्तव में वह विचार काफी पसंद है।

मैं आप तीनों को अलग-अलग जवाब देने जा रहा हूं क्योंकि इसे एक पोस्ट पर लिखना एक अपठनीय बूँद है।

@ ग्रिफोर्क कोई समस्या नहीं है। कभी-कभी पाठ के माध्यम से सब कुछ ठीक से व्यक्त करना कठिन होता है और मुझे लगता है कि यह वैसे भी स्पष्ट करने योग्य था।

@dallonf आपका

मुझे लगता है कि x?: T और y: ?T बीच का अंतर टूलटिप्स/फ़ंक्शन उपयोग में होगा, और टाइपिंग और गार्ड में उपयोग किया जाएगा।

वैकल्पिक तर्क के रूप में घोषित करने से टूलटिप्स/फ़ंक्शन उपयोग में परिवर्तन होता है, इसलिए यह स्पष्ट है कि यह वैकल्पिक है:
a?: T को फ़ंक्शन कॉल में तर्क के रूप में पारित करने की आवश्यकता नहीं है, खाली छोड़ा जा सकता है
यदि घोषणा में ?: नहीं है तो इसे फ़ंक्शन कॉल में एक तर्क के रूप में पारित किया जाना चाहिए, और इसे खाली नहीं छोड़ा जा सकता है

w: T एक आवश्यक गैर- void तर्क है ( --noImplicitVoid )
गार्ड की आवश्यकता नहीं है

x?: T एक वैकल्पिक तर्क है, इसलिए प्रकार वास्तव में T | undefined
if (typeof x !== 'undefined') गार्ड की आवश्यकता है।
undefined पर सटीक जाँच के लिए ट्रिपल ग्लिफ़ !== पर ध्यान दें।

y: ?T एक आवश्यक तर्क है, और प्रकार वास्तव में T | void
if (y == null) गार्ड की आवश्यकता है।
डबल ग्लिफ़ == ध्यान दें जो null और undefined यानी void दोनों से मेल खाता है

z?: ?T एक वैकल्पिक तर्क है, और प्रकार वास्तव में T | undefined | void जो T | void
if (z == null) गार्ड की आवश्यकता है।
फिर से डबल ग्लिफ़ == ध्यान दें जो null और undefined यानी void दोनों से मेल खाता है

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

मुझे लगता है कि इन सभी के पास वास्तव में एक जगह है, इसलिए यह जरूरी नहीं कि मौजूदा वैकल्पिक तर्क सिंटैक्स को हटा दे, लेकिन मैं मानता हूं कि z फॉर्म सबसे सुरक्षित है।

संपादित करें: अद्यतन शब्दांकन और कुछ टाइपो को ठीक किया।

@ jods4 मैं आपकी कही हर बात से काफी हद तक सहमत हूं। मैं गैर- void टाइपिंग के महत्व को कम करने की कोशिश नहीं कर रहा हूं। मैं इसे एक बार में एक चरण में धकेलने की कोशिश कर रहा हूं। यदि TS टीम इसे बाद में नहीं कर सकती है, तो कम से कम हम बेहतर स्थिति में हैं, और यदि वे अधिक जाँच और ?T लागू करने के बाद इसे सड़क पर कर सकते हैं तो यह मिशन पूरा हो गया है।

मुझे लगता है कि Arrays के मामले में वास्तव में एक मुश्किल मामला है। आप हमेशा कुछ ऐसा कर सकते हैं:

``` .ts
फ़ंक्शन numToString (x: संख्या) {
वापसी x.toString ();
}
वर अंक: संख्या [] = सरणी (100);
numToString (अंक [0]); // तुमने बहुत बड़ी गलती कर दी है!

You can try to do something specifically for uninitialized arrays, like typing the `Array` function as `Array<?T>` / `?T[]` and upgrading it to `T[]` after a for-loop initializing it, but I agree that you can't catch everything. That said, that's already a problem anyway, and arrays typically don't even send uninitialized values to `map`/`filter`/`forEach`.

Here's an example -- the output is the same on Node/Chrome/IE/FF/Safari.

``` .ts
function timesTwo(x: number) {
    return x * 2;
}
function all(x) {
    return true;
}
var nums: number[] = Array(100);
nums.map(timesTwo);
// [undefined x 100]
nums.filter(all);
// []
nums.forEach(function(x) { console.log(x); })
// No output

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

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

यहाँ एक उदाहरण है। मान लेते हैं कि --noImplicitVoid बंद है

``` .ts
इंटरफ़ेस{
(एक्स: टी): यू;
}

इंटरफ़ेस IHaveName {
नाम: स्ट्रिंग;
}

फंक्शन ट्रांसफॉर्म(एक्स: टी, एफएन: आईट्रांसफॉर्म) {
वापसी एफएन (एक्स);
}

वर नाम = {
नाम: "फू"
};

वर गलतनाम = {
नाम: 1234
};

वर नाम नल = {
नाम: शून्य
};

var someFun = (x: IHaveName) => x.name;
var someFunHandlesVoid = (x: IHaveName) => {
अगर (x != null && x.name != null) {
वापसी x.नाम;
}
वापसी "कोई नाम नहीं";
};

All of the above code compiles just fine -- no issues. Now let's try using it

``` .ts
someFun(named);
// "Foo"
someFun(wrongName);
// error TS2345: Argument of type '{ name: number; }' is not assignable to parameter
// of type 'IHaveName'.
//   Types of property 'name' are incompatible.
//     Type 'number' is not assignable to type 'string'.
someFun(null);
// Not currently an error, but would be something like this:
// error TS#: Argument of type 'null' is not assignale to parameter of type 'IHaveName'.
someFun(namedNull);
// Not currently an error, but would be something like this:
// error TS#: Argument of type '{ name: null; }' is not assignable to parameter of
// type 'IHaveName'.
//   Types of property 'name' are incompatible.
//     Type 'null' is not assignable to type 'string'.

someFunHandlesVoid(named);
// "Foo"
someFunHandlesVoid(wrongName);
// error TS2345: Argument of type '{ name: number; }' is not assignable to parameter
// of type 'IHaveName'.
someFunHandlesVoid(null);
// "No Name"
someFunHandlesVoid(namedNull);
// "No Name"

transform(named, someFun);
// "Foo"
transform(wrongName, someFun);
// error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage.
// Consider specifying the type arguments explicitly.
//   Type argument candidate '{ name: number; }' is not a valid type argument because it
//   is not a supertype of candidate 'IHaveName'.
//     Types of property 'name' are incompatible.
//       Type 'string' is not assignable to type 'number'.
transform(null, someFun);
// Not currently an error, but would be something like this:
// error TS#: The type argument for type parameter 'T' cannot be inferred from the usage.
// Consider specifying the type arguments explicitly.
//   Type argument candidate 'null' is not a valid type argument because it
//   is not a supertype of candidate 'IHaveName'.
transform(namedNull, someFun);
// Not currently an error, but would be something like this:
// error TS#: The type argument for type parameter 'T' cannot be inferred from the usage.
// Consider specifying the type arguments explicitly.
//   Type argument candidate '{ name: null; }' is not a valid type argument because it
//   is not a supertype of candidate 'IHaveName'.
//     Types of property 'name' are incompatible.
//       Type 'string' is not assignable to type 'null'.

transform(named, someFunHandlesVoid);
// "Foo"
transform(wrongName, someFunHandlesVoid);
// error TS2453: The type argument for type parameter 'T' cannot be inferred from the usage.
// Consider specifying the type arguments explicitly.
//   Type argument candidate '{ name: number; }' is not a valid type argument because it
//   is not a supertype of candidate 'IHaveName'.
transform(null, someFunHandlesVoid);
// "No Name"
transform(namedNull, someFunHandlesVoid);
// "No Name"

आप सही हैं कि आप सब कुछ नहीं पकड़ सकते, लेकिन आप बहुत सी चीजें पकड़ सकते हैं।

अंतिम नोट -- --noImplicitVoid चालू होने पर उपरोक्त का व्यवहार क्या होना चाहिए?

अब someFun और someFunHandlesVoid दोनों को एक ही प्रकार से चेक किया जाता है और वही त्रुटि संदेश उत्पन्न करते हैं जो someFun उत्पन्न होते हैं। भले ही someFunHandlesVoid शून्य को संभालता है, इसे null या undefined साथ कॉल करना एक त्रुटि है क्योंकि हस्ताक्षर बताता है कि यह गैर void लेता है। इसे स्वीकार करने के लिए (x: ?IHaveName) : string रूप में टाइप करना होगा null या undefined । अगर हम इसका प्रकार बदलते हैं, तो यह पहले की तरह काम करना जारी रखता है।

यह वह हिस्सा है जो एक ब्रेकिंग बदलाव है, लेकिन इसे ठीक करने के लिए हमें बस इतना करना है कि टाइप सिग्नेचर में एक सिंगल कैरेक्टर ? जोड़ा जाए। हमारे पास एक और झंडा भी हो सकता है --warnImplicitVoid जो चेतावनी के समान काम करता है ताकि हम धीरे-धीरे माइग्रेट कर सकें।

मुझे ऐसा करने के लिए कुल झटका लग रहा है, लेकिन मैं एक और पोस्ट करने जा रहा हूं।

इस समय मुझे नहीं पता कि आगे बढ़ने के लिए क्या करना चाहिए। क्या कोई बेहतर विचार है? क्या हमें:

• यह कैसे व्यवहार करना चाहिए, इस पर चर्चा/विनिर्देश करते रहें?
• इसे तीन नए फीचर प्रस्तावों में बदल दें?
  
  
  
  • उन्नत विश्लेषण
  
  
  • हो सकता है/विकल्प प्रकार ?T
  
  
  • --noImplicitVoid संकलक विकल्प
  
  
• इनपुट के लिए पिंग टाइपस्क्रिप्ट टीम के सदस्य?

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

@tejacques

• आप dallonf के ट्रिपल बराबर उदाहरण में typeof खो रहे हैं।
• ऐसा लगता है कि आप jods4 के उदाहरण में कुछ ? खो रहे हैं।

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

संपादित करें: याद किया गया मार्कडाउन मौजूद है।

इस स्तर पर इस सूत्र पर टिप्पणी करना बहुत ही निरर्थक है। यहां तक ​​​​कि अगर एक प्रस्ताव बनाया जाता है जिसे टाइपस्क्रिप्ट टीम स्वीकार्य मानती है (मैंने इसे अगस्त में ऊपर करने का प्रयास किया था) तो कोई रास्ता नहीं है कि वे इसे शोर के बीच पाएंगे।

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

इसे विभाजित करने के लिए +1, लेकिन अभी के लिए, --noImplicitVoid विकल्प कर सकते हैं
अशक्त प्रकार के लागू होने की प्रतीक्षा करें।

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

बुधवार को, नवंबर 18, 2015, 21:24 टॉम जैक्स नोटिफिकेशन @github.com ने लिखा:

मुझे ऐसा करने के लिए कुल झटका लग रहा है, लेकिन मैं एक और बनाने जा रहा हूं
पद।

इस समय मुझे नहीं पता कि आगे बढ़ने के लिए क्या करना चाहिए। क्या कोई बेहतर विचार है?
क्या हमें:

• यह कैसे व्यवहार करना चाहिए, इस पर चर्चा/विनिर्देश करते रहें?
• इसे तीन नए फीचर प्रस्तावों में बदल दें?
  
  
  
  • उन्नत विश्लेषण
  
  
  • हो सकता है/विकल्प प्रकार? टी
  
  
  • --noImplicitVoid संकलक विकल्प
  
  
• इनपुट के लिए पिंग टाइपस्क्रिप्ट टीम के सदस्य?

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

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

+1 --noImplicitNull विकल्प के लिए (शून्य और शून्य असाइनमेंट को अस्वीकार करें)।

मैंने इस समस्या को एक विशेष प्रकार Op<A> = A | NullType से कम करने का प्रयास किया। ऐसा लगता है कि यह काफी अच्छा काम करता है। यहां देखें।

+1 के लिए _--noImplicitNull_ साथ ही कृपया: +1:

+1 के लिए --noImplicitNull

क्या इसे बंद कर देना चाहिए?

@Gaelan दिए गए #7140 को मर्ज कर दिया गया है, यदि आप --noImplicitNull लिए एक नया, समर्पित मुद्दा दर्ज करना चाहते हैं, जैसा कि यहां कुछ लोगों द्वारा सुझाया गया है, तो अब ऐसा करना शायद सुरक्षित है।

@isiahmeadows शायद इसे खुला छोड़ना बेहतर होगा।

क्या इसे बंद कर देना चाहिए?

हमें लगता है कि https://github.com/Microsoft/TypeScript/issues/2388 इस काम का नाम बदलने वाला हिस्सा है। यही कारण है कि हमने अभी तक इस सुविधा को पूर्ण घोषित नहीं किया है।

यदि आप --noImplicitNull लिए एक नया, समर्पित मुद्दा दर्ज करना चाहते हैं, जैसा कि यहां कुछ लोगों द्वारा सुझाया गया है, तो शायद अब ऐसा करना सुरक्षित है।

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

@mhegazy इस अंक में पहले --noImplicitNull गया था कि सब कुछ स्पष्ट रूप से ?Type या !Type । आईएमएचओ मुझे नहीं लगता कि यह बॉयलरप्लेट के लायक है जब एक और झंडा होता है जो डिफ़ॉल्ट रूप से गैर-शून्य का अनुमान लगाता है कि आईआईआरसी पहले ही लागू हो चुका था जब शून्य प्रकार स्वयं थे।

अब बंद हो रहा है कि #7140 और #8010 दोनों का विलय हो गया है।

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

@massimiliano-mantione, कृपया देखें https://github.com/Microsoft/TypeScript/issues/8405