आधुनिक प्रोग्रामिंग भाषाओं में चर नाम के बाद प्रकार क्यों जाता है?

Question

ऐसा क्यों है कि लगभग सभी आधुनिक प्रोग्रामिंग भाषाओं में (गो, रस्ट, कोटलिन, स्विफ्ट, स्काला, निम, यहां तक ​​कि पायथन अंतिम संस्करण) प्रकार हमेशा चर घोषणा में चर नाम के बाद आते हैं, और इससे पहले नहीं?

क्यों x: int = 42और क्या नहीं int x = 42?
क्या उत्तरार्द्ध पूर्व की तुलना में अधिक पठनीय नहीं है?
क्या यह सिर्फ एक प्रवृत्ति है या इस समाधान के पीछे कोई सचमुच सार्थक कारण हैं?

Comments

कोटलिन के

— 8bittree

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

— रॉबर्ट हार्वे

यह भी देखें: एक प्रकार की पहचानकर्ता को शामिल करते समय स्केल के मूल्य / परिवर्तनशील घोषणा के आदेश के पीछे तर्क क्या है?

— gnat

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

— आंद्रे पॉलीकिनन

Hihi, इसलिए डेल्फी, जो कि (ऑब्जेक्ट) पास्कल है, और इसकी स्थापना के बाद से चर नामों के बाद टाइप किया गया है, पिछली शताब्दी के अंधेरे युगों में जिस तरह से वापस आ गया है, फिर से आधुनिक है;) Btw, पठनीयता आपके द्वारा बहुत प्रभावित होती है। अभ्यस्त। डेल्फी से आ रहा है, सी # नाम के पहले प्रकार के साथ, मुझे काफी समय से अपना सिर पीट रहा था।

— मार्जन वेनमा

Answer 1

जिन भाषाओं का आपने समर्थन प्रकार का उल्लेख किया है , उनमें से सभी का अर्थ है कि प्रकार उन भाषाओं में घोषणा का एक वैकल्पिक हिस्सा है क्योंकि वे काफी स्मार्ट होते हैं जब आप इसे आसानी से भर सकते हैं जब आप एक आरंभिक अभिव्यक्ति प्रदान करते हैं जिसमें आसानी से निर्धारित प्रकार होता है।

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

यह तर्क विशेष रूप से मजबूत हो जाता है जब आप सभी वैकल्पिक प्रकार के संशोधक पर विचार करते हैं जो कि "गैर-आधुनिक" भाषा है जैसे सी ++, जैसे कि *संकेत के लिए, &संदर्भ के लिए const, volatileऔर इसी तरह। एक बार जब आप कई घोषणाओं के लिए अल्पविराम में फेंक देते हैं, तो आपको कुछ वास्तव में अजीब अस्पष्टताएं मिलनी शुरू हो जाती हैं जैसे int* a, b;कि bपॉइंटर बनाना नहीं ।

यहां तक ​​कि C ++ अब के रूप में "सही पर प्रकार" घोषणाओं का समर्थन करता है auto x = int{ 4 };, और इसके कुछ फायदे हैं ।

Comments

+1 अनिवार्य कीवर्ड के अस्तित्व को स्वीकार करने के लिए varजो पार्सिंग सरलीकरण के बहुमत प्रदान करते हैं।

— 8bittree

क्या varनाम-प्रथम संकेतन के उद्देश्य से खोजशब्द का अस्तित्व पराजित नहीं होता है? मैं लिख का लाभ नहीं दिख रहा है var userInput: String = getUserInput()खत्म हो गया String userInput = getUserInput()। यह लाभ केवल तभी प्रासंगिक होगा जब userInput = getUserInput()अनुमति दी गई हो, लेकिन यह एक स्कोप किए गए वैरिएबल की अनुमानित घोषणा होगी, जो मुझे बहुत घृणित लगती है।

— kdb

सी # और सी ++ जैसी भाषाओं में @kdb यह होगा var userInput = getUserInput()या auto userInput = getUserInput(), संकलक getUserInput()रिटर्न जानता है, Stringइसलिए आपको इसे प्रकार कटौती कीवर्ड के साथ निर्दिष्ट करने की आवश्यकता नहीं है। userInput = getUserInput()घोषणा से पहले पाठ्यक्रम का उपयोग है।

— वेस टोलमैन

Answer 2

लगभग सभी आधुनिक प्रोग्रामिंग भाषाओं में (गो, रस्ट, कोटलिन, स्विफ्ट, स्काला, निम, यहां तक ​​कि पायथन अंतिम संस्करण) प्रकार हमेशा चर घोषणा के बाद आते हैं, और इससे पहले नहीं?

आपका आधार दो मोर्चों पर त्रुटिपूर्ण है:

• नई-ईश प्रोग्रामिंग भाषाएं हैं जो पहचानकर्ता से पहले का प्रकार हैं । उदाहरण के लिए C, D या सीलोन।
• पहचानकर्ता के बाद के प्रकार का होना कोई नई घटना नहीं है, यह कम से कम पास्कल (1968-1969 डिज़ाइन किया गया, 1970 में जारी) पर वापस चला जाता है, लेकिन वास्तव में गणितीय प्रकार के सिद्धांत में उपयोग किया गया था, जो ~ 1902 से शुरू होता है। इसका उपयोग ML (1973), CLU (1974), होप (1970), मोडुला -2 (1977-1985), Ada (1980), Miranda (1985), Caml (1985), Eiffel (1985), Oberon में भी किया गया था। (1986), मोडुला -3 (1986-1988), और हास्केल (1989)।

पास्कल, एमएल, सीएलयू, मोडुला -2 और मिरांडा सभी बहुत प्रभावशाली भाषाएं थीं, इसलिए यह आश्चर्य की बात नहीं है कि इस प्रकार की घोषणाएं लोकप्रिय रहीं।

क्यों x: int = 42और क्या नहीं int x = 42? क्या उत्तरार्द्ध पूर्व की तुलना में अधिक पठनीय नहीं है?

पठनीयता परिचित का विषय है। निजी तौर पर, मैं चीनी को अपठनीय मानता हूं, लेकिन जाहिर है, चीनी लोग नहीं करते। स्कूल में पास्कल सीखने के बाद, एफिल, Fask, हास्केल, और स्काला के साथ डबल्ड किया गया और टाइपस्क्रिप्ट, फोर्ट, गो, रस्ट, कोटलिन, इदरिस, फ्रीज, एजडा, एमएल, ओक्लेमल,… को देखा, यह मुझे पूरी तरह से स्वाभाविक लगता है ।

क्या यह सिर्फ एक प्रवृत्ति है या इस तरह के समाधान के पीछे कोई सार्थक कारण हैं?

यदि यह एक प्रवृत्ति है, तो यह बहुत ही स्थायी है: जैसा कि मैंने उल्लेख किया है, यह गणित में सौ साल पीछे चला जाता है।

पहचानकर्ता के बाद टाइप करने के मुख्य लाभों में से एक यह है कि यदि आप चाहते हैं कि यह पता लगाया जाए तो टाइप को छोड़ना आसान है। यदि आपकी घोषणाएं इस तरह दिखती हैं:

val i: Int = 10

फिर इस प्रकार को छोड़ना तुच्छ है और क्या यह इस प्रकार है:

val i = 10

जबकि यदि पहचानकर्ता इस तरह से पहले आता है:

Int i = 10

फिर पार्सर के लिए एक अभिव्यक्ति को एक घोषणा से अलग करना मुश्किल होने लगता है:

i = 10

भाषा डिजाइनर जो समाधान आमतौर पर साथ आते हैं, वह है "मैं एक प्रकार लिखना नहीं चाहता हूं" कीवर्ड को टाइप के बजाय लिखा जाना चाहिए:

var  i = 10; // C♯
auto i = 10; // C++

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

(और चलो सी में फ़ंक्शन पॉइंटर प्रकारों के बारे में भी बात नहीं करते हैं )

उपर्युक्त कई भाषाओं के डिजाइनरों ने इस विषय पर तौला है:

• जाओ अकसर किये गए सवाल (यह भी देखें: गो घोषणा सिंटेक्स ):

  घोषणाएँ पीछे की ओर क्यों हैं?

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

  int* a, b;
  

  aएक सूचक होने की घोषणा करता है लेकिन नहीं b; में जाओ

  var a, b *int
  

  दोनों को संकेत देता है। यह स्पष्ट और अधिक नियमित है। इसके अलावा, :=कम घोषणा प्रपत्र का तर्क है कि एक पूर्ण चर घोषणा के रूप में एक ही क्रम पेश करना चाहिए :=ताकि

  var a uint64 = 1
  

  के रूप में एक ही प्रभाव है

  a := uint64(1)
  

  पार्सिंग को सरल व्याकरण के प्रकारों के लिए एक अलग व्याकरण होने से भी सरल किया जाता है; जैसे कीवर्ड funcऔर chanचीजें स्पष्ट रखें।

• Kotlin पूछे जाने वाले प्रश्न :

  दाईं ओर टाइप घोषणाएं क्यों हैं?

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

• स्काला में प्रोग्रामिंग :

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

नोट: सीलोन के डिजाइनरों ने यह भी प्रलेखित किया कि वे उपसर्ग प्रकार के सिंटैक्स का उपयोग क्यों करते हैं :

उपसर्ग प्रकार के एनोटेशन के बजाय उपसर्ग

घोषणा के नाम के बाद उन्हें लगाने में पास्कल और एमएल के बजाय, आप पहले प्रकार के एनोटेशन डालने में सी और जावा का पालन क्यों करते हैं?

क्योंकि हम यह सोचते हैं:

shared Float e = ....
shared Float log(Float b, Float x) { ... }

क्या यह पढ़ने में बहुत आसान है:

shared value e: Float = .... 
shared function log(b: Float, x: Float): Float { ... }

और हम बस यह नहीं समझते हैं कि कोई और कैसे अन्यथा सोच सकता है!

व्यक्तिगत रूप से, मैं उनके "तर्क" को दूसरों की तुलना में बहुत कम आश्वस्त पाता हूं।

Comments

प्रकार बाहर छोड़ करने की क्षमता लगता है और अभी भी सरल पार्स के अलावा द्वारा दी जाती है है var, auto, let,, या की तरह चर प्रकार घोषणा पर है के पक्ष है जिसके द्वारा नहीं। var Int x = 5या यहां तक Int var x = 5कि दोनों को छोटा किया जा सकता है var x = 5।

— 8bittree

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

— पियरे हेनरी

"Your premise is flawed on two fronts" वे सभी C # या D. से नए हैं

— Det

"लेकिन यह वास्तव में बहुत मायने नहीं रखता है: आपको मूल रूप से एक प्रकार लिखना होगा जो कहता है कि आप एक प्रकार नहीं लिखते हैं।" ठीक है, टाइप-ऑन-द-राइट संस्करण आपके उदाहरण में बिल्कुल समान है ... इसके अलावा, मैं असहमत हूं कि इसका कोई मतलब नहीं है। यह funcगो के रूप में बिल्कुल समझ में आता है ।

— सोपेल

Answer 3

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

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

C से C # और java स्टेम ताकि उन्हें "पूर्व कला" का सम्मान करना पड़े, इसलिए अनुभवी प्रोग्रामर को भ्रमित न करें।

Comments

Ada भी इसे इस तरह से करता है, लेकिन Ada निश्चित रूप से एक "शैक्षणिक भाषा" नहीं है।

— जॉन आर। स्ट्रॉहम

Ada ने ऐसा इसलिए किया क्योंकि यह पास्कल और मोडुला 2 से भारी रूप से घिर गया था

— गॉर्ट द रोबोट

@StevenBurnap, एक त्वरित खोज से पता चलता है कि मॉडुला -2 पर Wirth की पहली पुस्तक 1982 के मध्य में सामने आई थी। Ada कई वर्षों से पहले से चल रहा था (DoD1 1977 में था या इसलिए, जैसा कि मुझे याद है), और मानकीकृत, ANSI मानक और MIL-STD, दोनों के रूप में 1983 में। सभी चार टीमें जिन्होंने Ada PASCAL के लिए उम्मीदवार प्रस्तुत किए। उनके शुरुआती बिंदुओं के रूप में। (बेल लैब्स को DoD द्वारा सी। पर आधारित एक उम्मीदवार की भाषा प्रस्तुत करने के लिए आमंत्रित किया गया था, उन्होंने कहा कि C तब नहीं था और DoD मिशन-क्रिटिकल सॉफ़्टवेयर के लिए पर्याप्त रूप से मजबूत नहीं होगा।)

— जॉन आर। स्ट्रॉहम

मुझे गलत समझना चाहिए। मुझे लगा कि Wirth को Ada में शामिल किया गया था।

— रोबोट

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

— Shayne

Answer 4

क्यों x: int = 42और क्या नहीं int x = 42? क्या उत्तरार्द्ध पूर्व की तुलना में अधिक पठनीय नहीं है?

इस तरह के एक सरल उदाहरण में, बहुत अंतर नहीं है, लेकिन चलो इसे थोड़ा और जटिल बनाते हैं: int* a, b;

यह C में एक वास्तविक, वैध घोषणा है, लेकिन यह वह नहीं करता है जो यह सहज रूप से दिखता है जैसे इसे करना चाहिए। ऐसा लगता है कि हम दो प्रकार के प्रकार int*घोषित कर रहे हैं, लेकिन वास्तव में हम एक int*और एक की घोषणा कर रहे हैं int।

यदि आपकी भाषा अपनी घोषणाओं में चर नाम (ओं) के बाद टाइप करती है , तो उस समस्या को चलाना असंभव है।

Comments

मुझे यकीन नहीं है कि इस प्रकार की घोषणा को आगे बढ़ाने के बाद यह क्यों प्रभावित होगा। है x, y *int;दो *intया एक *intऔर एक int? दो के बजाय एक टोकन बनाना int*या *intइसे हल करना, या जैसे एक अतिरिक्त सिंटैक्टिक तत्व का उपयोग करना :, जो दोनों दिशा में काम कर सकता है।

— 8bittree

@ 8bittree हर भाषा मुझे लगता है कि से परिचित हूँ नाम-पहले घोषणाओं की तरह एक अतिरिक्त टोकन का उपयोग, का उपयोग करता है :या as, नाम और प्रकार के बीच।

— मेसन व्हीलर

गो x, y intविभाजक के बिना है।

— जॉर्ग डब्ल्यू मित्तग

और गो में, का x, y *intअर्थ है "दो प्रकारों की घोषणा करें, x और y, सूचक-टू-इंट के साथ"।

— वेटिन

C # उपसर्ग सिंटैक्स का उपयोग करता है, फिर भी यह int[] x, yदो सरणियों के रूप में व्यवहार करता है । यह सिर्फ मूर्खतापूर्ण सी वाक्यविन्यास है जो उन संशोधक को चर पर एकरी संचालकों के रूप में मानता है (और उपसर्ग और उपसर्ग का मिश्रण, कोई कम नहीं) जो समस्याओं का कारण बनता है।

— कोडइन्चोस