सांख्यिकीय रूप से टाइप की गई और गतिशील रूप से टाइप की गई भाषाओं में क्या अंतर है?

Question

मैंने बहुत सुना है कि नई प्रोग्रामिंग भाषाएं गतिशील रूप से टाइप की जाती हैं लेकिन जब हम कहते हैं कि वास्तव में गतिशील रूप से टाइप की गई बनाम स्टेटिक टाइप की गई भाषा का क्या अर्थ है?

Comments

अच्छा प्रश्न है लेकिन आपका स्वीकृत उत्तर सही उत्तर नहीं है।

— जॉन हैरोप

क्या आप pls कुछ का उल्लेख कर सकते हैं जो सही है?

— सगीरुद्दीन मोंडल

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

— पिक्सेल 67

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

— एरिक लेसचिंस्की

मुझे पता है कि यह सवाल 10 साल पुराना है, लेकिन मैंने टिप्पणियों में जो पढ़ा है, उससे आपको संभवतः "क्रिस्टोफर टोकेन" से जवाब स्वीकार करने के लिए स्विच करना चाहिए।

— Rev1.0

Answer 1

वैधानिक रूप से टाइप की गई भाषाएँ

यदि संकलित समय पर चर के प्रकार को जाना जाता है, तो एक भाषा वैधानिक रूप से टाइप की जाती है। कुछ भाषाओं के लिए इसका मतलब है कि आपको प्रोग्रामर को यह निर्दिष्ट करना होगा कि प्रत्येक चर किस प्रकार का है (जैसे: जावा, सी, सी ++); अन्य भाषाएं कुछ प्रकार के प्रकार की पेशकश करती हैं , प्रकार के सिस्टम की क्षमता एक चर के प्रकार को कम करने के लिए (जैसे: OCaml, Haskell, Scala, Kotlin)

यहां मुख्य लाभ यह है कि संकलक द्वारा सभी प्रकार की जाँच की जा सकती है, और इसलिए बहुत से तुच्छ बग बहुत प्रारंभिक अवस्था में पकड़े जाते हैं।

उदाहरण: C, C ++, Java, Rust, Go, Scala

डायनामिक रूप से टाइप की गई भाषाएं

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

उदाहरण: पर्ल, रूबी, पायथन, पीएचपी, जावास्क्रिप्ट

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

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

Comments

@NomeN क्या आप किसी भी डायनामिक टाइप की गई भाषा का नाम बता सकते हैं, जो एचएम प्रकार के इंफेक्शन को लागू करती है?

— पीट किर्कम

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

— पॉल बिगगर

गलत, स्थैतिक टाइपिंग का अर्थ है "कि एक संदर्भ मान प्रकट होता है (जो संकलन के समय के समान नहीं होता है) यह मान के प्रकार के संबंध में विवश होता है जो इसे निरूपित कर सकता है, और यह कि भाषा कार्यान्वयन, चाहे वह संकलक हो या दुभाषिया हो , दोनों इन बाधाओं को यथासंभव लागू करते हैं और उनका उपयोग करते हैं। " से उद्धृत: c2.com/cgi/wiki?StaticTyping , जो मैं इसे कैसे समझता हूं, सही है।

— मथायस वुल्फ

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

— विप्रेश

पहले क़ानूनी रूप से टाइप की गई भाषाएँ स्पष्टता से टाइप की जाती थीं। हालांकि, टाइप इंफ़ॉर्मेशन एल्गोरिदम - बिना किसी प्रकार की घोषणा के स्रोत कोड को देखने की तकनीक और यह तय करना कि इसके चर के प्रकार अब कई वर्षों से मौजूद हैं। एमएल भाषा, जो इसका उपयोग करता है। हास्केल, जो इस पर सुधार करता है, अब लगभग 15 साल का है। यहां तक ​​कि C # भी अब इस विचार को अपना रहा है, जो काफी भौंहें उठाएगा और निस्संदेह इसके "कमजोर टाइप" होने के दावों को जन्म देगा। जारी ...

— विप्रेश १६'१४ को

Answer 2

स्टैटिक-टाइप की गई प्रोग्रामिंग लैंग्वेज रन-टाइम के विपरीत कंपाइल-टाइम पर टाइप चेकिंग (यानी वेरिफिकेशन की प्रक्रिया और प्रकार की बाधाओं को लागू करने) करती हैं ।

संकलित समय के विपरीत डायनामिक रूप से टाइप की गई प्रोग्रामिंग भाषा रन-टाइम पर चेकिंग करती हैं ।

सांख्यिकीय रूप से टाइप की जाने वाली भाषाओं के उदाहरण हैं: - जावा, सी, सी ++

गतिशील रूप से टाइप की जाने वाली भाषाओं के उदाहरण हैं: - पर्ल, रूबी, पायथन, पीएचपी, जावास्क्रिप्ट

Comments

मुझे लगता है कि यह सबसे अच्छा जवाब है। विशेष रूप से, स्वीकृत उत्तर मोटे तौर पर तथ्यात्मक रूप से गलत है।

— जॉन हैरोप

@JonHarrop किन तरीकों से विशेष रूप से?

— १२५२ .४।

@thomas: "इसका मतलब है कि आप एक प्रोग्रामर के रूप में थोड़ा तेज लिख सकते हैं क्योंकि आपको हर प्रकार को निर्दिष्ट करने की आवश्यकता नहीं है"। यदि आपके पास टाइपिंग है तो आपको हर बार स्टेटिक टाइपिंग के साथ टाइप करने की आवश्यकता नहीं है। SML, OCaml, F #, हास्केल देखें ...

— जॉन हैरोप

सांख्यिकीय रूप से टाइप की गई भाषाओं में टाइपिंग की जाँच रनटाइम से पहले की जाती है, लेकिन संकलन के समय बिल्कुल नहीं।

— लुइज़ फेलिप

Answer 3

यहां एक उदाहरण दिया गया है कि पायथन (गतिशील रूप से टाइप किया गया) और गो (स्टेटिक रूप से टाइप किया गया) एक प्रकार की त्रुटि को हैंडल करते हैं:

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

पायथन रन टाइम पर चेकिंग टाइप करता है, और इसलिए:

silly(2)

पूरी तरह से ठीक चलता है, और अपेक्षित उत्पादन करता है Hi। यदि समस्यात्मक रेखा हिट है तो त्रुटि केवल तभी उठाई जाती है:

silly(-1)

का उत्पादन

TypeError: unsupported operand type(s) for +: 'int' and 'str'

क्योंकि संबंधित लाइन वास्तव में निष्पादित की गई थी।

दूसरी ओर जाना संकलन समय पर टाइप-जाँच करता है:

package main

import ("fmt"
)

func silly(a int) {
    if (a > 0) {
        fmt.Println("Hi")
    } else {
        fmt.Println("3" + 5)
    }
}

func main() {
    silly(2)
}

उपरोक्त त्रुटि के साथ संकलित नहीं होगा:

invalid operation: "3" + 5 (mismatched types string and int)

Comments

साफ उदाहरण के लिए धन्यवाद। इसलिए मुझे पता है कि सभी स्क्रिप्टिंग भाषाओं को डायनामिक रूप से टाइप किया गया है, क्योंकि वे संकलित नहीं हैं?

— C --Z

हाँ। सभी स्क्रिप्टिंग भाषाएं गतिशील रूप से टाइप की जाती हैं, क्योंकि उनका स्थैतिक प्रकार की जाँच करने के लिए कोई संकलक नहीं है। इस बिंदु का चित्रण इस साइट sitepoint.com/typing-versus-dynamic-typing में किया गया है ।

— शशि

स्कैला का उपयोग स्क्रिप्टिंग भाषा के रूप में किया जा सकता है और यह सांख्यिकीय रूप से टाइप किया जाता है! # विवाह @ शशी

— सगीरुद्दीन मंडल

@ शशि संकलन का अर्थ सांख्यिकीय रूप से टाइप नहीं है। runhaskellउदाहरण के लिए हास्केल के साथ व्याख्या की जा सकती है ।

— BalinKingOfMoria

साथ ही स्क्रिप्टिंग भाषा का अर्थ भाषा की व्याख्या नहीं है। टाइपस्क्रिप्ट सांख्यिकीय रूप से टाइप, संकलित / ट्रांसपेल्ड है, लेकिन स्क्रिप्टिंग भाषा है।

— मेटेलिम

Answer 4

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

जावा में उदाहरण के लिए:

String str = "Hello";  //variable str statically typed as string
str = 5;               //would throw an error since str is supposed to be a string only

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

उदाहरण के लिए पायथन:

str = "Hello" # variable str is linked to a string value
str = 5       # now it is linked to an integer value; perfectly OK

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

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

आमतौर पर टाइप की जाने वाली भाषाएं आमतौर पर संकलित भाषाएं होती हैं, इस प्रकार, कंपाइलर प्रकारों की जांच करते हैं (सही अर्थों को सही बनाते हैं; क्योंकि प्रकारों को बाद के समय में बदलने की अनुमति नहीं है)।

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

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

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

Comments

इसके बहुत सारे अर्थ निकलते हैं। मुझे लगता है कि यह कम से कम नामों के पीछे के तर्क को यहां अन्य उत्तरों की तुलना में बेहतर बताता है।

— JamEngulfer

इस संदर्भ के अनुसार, पायथन दोनों एक सांख्यिकीय रूप से टाइप और गतिशील रूप से टाइप की गई भाषा है: wiki.python.org/moin/… क्या कोई जानता है कि क्यों?

— modulitos

लुकास, इसके विपरीत दस्तावेज़ यह ध्यान रखता है कि पायथन दृढ़ता से और गतिशील रूप से टाइप किया गया है। आपने उसे कहां देखा? क्या आप बोली?

— मेहमेट

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

— होवीके

अधिकांश अन्य उत्तरों ने मेरे दिमाग में और अधिक सवाल पैदा किए। इस एक ने सब साफ कर दिया। यह उत्तर वास्तव में शीर्ष IMHO

— Hami Torun

Answer 5

http://en.wikipedia.org/wiki/Type_system

स्थैतिक टाइपिंग

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

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

if <complex test> then 42 else <type error>

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

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

गतिशील टाइपिंग

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

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

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

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

संदर्भ

1. पियर्स, बेंजामिन (2002)। प्रकार और प्रोग्रामिंग भाषाएँ। एमआईटी प्रेस। आईएसबीएन 0-262-16209-1।

Comments

एसओ का मुख्य विचार ज्ञान के एक निकाय का निर्माण करना है, न कि अन्य स्थानों के लिंक प्रदान करना। आपको कम से कम उस विकी के अंश का प्रयास करना चाहिए जो प्रश्न का उत्तर देता है।

— नोमन

यह सिर्फ बेमानी लग रहा था क्योंकि यह विकिपीडिया और कुछ क्षणिक वेबसाइट का लिंक नहीं है, लेकिन मैं अगली बार इसे याद रखूंगा।

— याकूब

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

— नॉवेलिज़ेटर

@Novellizator पुरानी टिप्पणी लेकिन एक परिदृश्य की कल्पना करें जहां कुछ डेटा को दूरस्थ सर्वर से उठाया जाता है, फिर उस डेटा का उपयोग किसी वस्तु को हटाने के लिए किया जाता है। उदाहरण के लिए: myObject[remoteDataName]। फिर यह जानने का कोई तरीका नहीं है कि यह कौन सी संपत्ति होगी या भले ही यह एक वैध संपत्ति हो।

— माइक क्लार्क

Answer 6

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

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

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

एक uni-typed भाषा जो ऐसा करती है उसे गतिशील रूप से टाइप किया जाता है।

जावास्क्रिप्ट, पायथन, और रूबी जैसी भाषाएं सभी uni-typed हैं। फिर से, typeofजावास्क्रिप्ट में ऑपरेटर और typeपायथन में फ़ंक्शन के नाम भ्रामक हैं; वे ऑपरेंड से जुड़े टैग लौटाते हैं, उनके प्रकार नहीं। इसी तरह, dynamic_castC ++ और instanceofJava में टाइप चेक ना करें।

Answer 7

संकलित बनाम संकलित

"जब स्रोत कोड का अनुवाद किया जाता है"

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

---

टाइपिंग

"जब प्रकार की जाँच की जाती है"

5 + '3'दृढ़ता से टाइप की गई भाषाओं जैसे कि गो और पायथन में एक प्रकार की त्रुटि का एक उदाहरण है , क्योंकि वे "प्रकार की ज़बरदस्ती" के लिए अनुमति नहीं देते हैं -> कुछ संदर्भों में टाइप बदलने के लिए एक मान के लिए क्षमता जैसे कि दो प्रकार के विलय। कमजोर टाइप की गई भाषाएं, जैसे कि जावास्क्रिप्ट, एक प्रकार की त्रुटि (परिणाम '53') नहीं फेंकेंगी ।

• स्टेटिक : रन-टाइम से पहले टाइप किए गए प्रकार
• डायनामिक : निष्पादन के दौरान मक्खी पर टाइप किए गए प्रकार

---

"Static & Compiled" और "Dynamic & Interpreted" की परिभाषाएँ काफी समान हैं ... लेकिन याद रखें कि जब स्रोत कोड का अनुवाद किया जाता है तो यह "जब प्रकारों की जाँच की जाती है" "।

आप एक ही प्रकार की त्रुटियां प्राप्त करेंगे चाहे वह भाषा संकलित हो या व्याख्या की गई हो ! आपको इन शर्तों को वैचारिक रूप से अलग करने की आवश्यकता है।

---

पायथन उदाहरण

गतिशील, व्याख्या की गई

def silly(a):
    if a > 0:
        print 'Hi'
    else:
        print 5 + '3'

silly(2)

क्योंकि पायथन दोनों की व्याख्या और गतिशील रूप से टाइप की गई है, यह केवल अनुवाद करता है और टाइप-चेक कोड है जिस पर यह निष्पादित हो रहा है। elseब्लॉक कभी नहीं निष्पादित करता है, तो 5 + '3'भी देखा कभी नहीं रही है!

यदि यह सांख्यिकीय रूप से टाइप किया गया था तो क्या होगा?

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

यदि इसे संकलित किया गया तो क्या होगा?

elseब्लॉक अनुवाद किया जाएगा / चलाने के समय से पहले को देखा, लेकिन क्योंकि यह गतिशील रूप से टाइप किया है यह एक त्रुटि फेंक नहीं होता! डायनामिक रूप से टाइप की गई भाषाएँ निष्पादन तक प्रकारों की जाँच नहीं करती हैं, और यह लाइन कभी निष्पादित नहीं होती है।

---

उदाहरण के लिए जाओ

स्टेटिक, संकलित

package main

import ("fmt"
)

func silly(a int) {
  if (a > 0) {
      fmt.Println("Hi")
  } else {
      fmt.Println("3" + 5)
  }
}

func main() {
  silly(2)
}

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

---

प्रदर्शन

संकलित भाषा का रन-टाइम में बेहतर प्रदर्शन होगा यदि इसे स्टेटिकली टाइप किया गया है (बनाम डायनामिक); मशीन कोड ऑप्टिमाइज़ेशन के प्रकारों का ज्ञान अनुमति देता है।

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

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

ध्यान दें कि संकलित और सांख्यिकीय दोनों प्रकार की भाषाओं में क्रमशः अनुवाद और टाइप-चेकिंग के लिए चलने से पहले एक देरी होगी।

---

अधिक अंतर

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

num = 2
num = '3' // ERROR

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

Comments

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

— एली कोरविगो

Answer 8

सांख्यिकीय रूप से टाइप की गई भाषाएं : प्रत्येक चर और अभिव्यक्ति पहले से ही संकलन समय पर जानी जाती हैं।

( int a;एक रनटाइम में केवल पूर्णांक प्रकार मान ले सकते हैं)

उदाहरण: C, C ++, Java

डायनामिक रूप से टाइप की गई भाषाएं : चर रनटाइम पर विभिन्न मान प्राप्त कर सकते हैं और उनके प्रकार को रन टाइम पर परिभाषित किया जाता है।

( var a;ए रनटाइम पर किसी भी प्रकार के मान ले सकता है)

उदाहरण: रूबी, पायथन।

Answer 9

संकलित भाषाएं संकलित संकलन समय पर टाइप-चेक करती हैं और प्रकार बदल नहीं सकता है। (टाइप-कास्टिंग टिप्पणियों के साथ प्यारा मत बनो, एक नया चर / संदर्भ बनाया गया है)।

डायनामिक टाइप की गई भाषाएं रन-टाइम पर टाइप-चेक करती हैं और रन-टाइम पर एक वेरिएबल के प्रकार को बदला जा सकता है।

Answer 10

मीठी और सरल परिभाषाएँ, लेकिन ज़रूरत को पूरा करना: सांख्यिकीय रूप से टाइप की जाने वाली भाषाएँ अपने पूरे दायरे (Seg: SCALA) के लिए एक चर के प्रकार को बांधती हैं। डायनामिक रूप से टाइप की गई भाषाएँ एक चर द्वारा संदर्भित वास्तविक मान के प्रकार को बांधती हैं।

Answer 11

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

Answer 12

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

इसके अलावा उनके पास एक बहुत छोटा अंतर है और जोरदार टाइप और कमजोर टाइप की भाषाओं से संबंधित हो सकता है । एक जोरदार टाइप की गई भाषा आपको एक प्रकार का दूसरे के रूप में उपयोग करने की अनुमति नहीं देती है। C और C ++ ... जबकि कमजोर टाइप की गई भाषाएँ eg.python को अनुमति देती हैं

Answer 13

स्टेटिकली टाइप्ड

रन-टाइम से पहले प्रकारों की जाँच की जाती है ताकि गलतियों को पहले पकड़ा जा सके।

उदाहरण = c ++

डायनामिक रूप से टाइप किया हुआ

निष्पादन के दौरान प्रकारों की जाँच की जाती है।

उदाहरण = पायथन

Comments

यह वास्तव में ऐसा कुछ भी नहीं जोड़ता है जो अभी तक अन्य उत्तरों से ढंका नहीं है, क्या यह करता है?

— रॉबर्ट

हां, लेकिन अधिकांश उत्तर बहुत स्पष्ट नहीं थे इसलिए मुझे ऐसा उत्तर चाहिए था जिसे समझना आसान था।

— अटिकस डेनेमोंट

Answer 14

स्टेटिक टाइप की गई भाषाएं (कंपाइलर मेथड कॉल और कंपाइल रेफरेंस को हल करता है):

• आमतौर पर बेहतर प्रदर्शन
• तेजी से संकलन त्रुटि प्रतिक्रिया
• बेहतर IDE समर्थन
• अपरिभाषित डेटा प्रारूपों के साथ काम करने के लिए उपयुक्त नहीं है
• एक विकास शुरू करने के लिए कठिन है जब मॉडल को परिभाषित नहीं किया जाता है
• अब संकलन समय
• कई मामलों में अधिक कोड लिखने की आवश्यकता होती है

गतिशील टाइप की गई भाषाएं (प्रोग्राम चलाने में लिए गए निर्णय):

• कम प्रदर्शन
• तेजी से विकास
• कुछ कीड़े केवल रन-टाइम में ही पता लग सकते हैं
• अपरिभाषित डेटा स्वरूपों के लिए अच्छा (मेटा प्रोग्रामिंग)

Answer 15

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

Answer 16

स्टैटिक टाइपिंग: जावा और स्काला जैसी भाषाएँ स्टैटिक टाइप की जाती हैं।

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

पूर्व के लिए। इंट x; x = 10;

Println (x);

डायनेमिक टाइपिंग: पर्ल एक डायनेमिक टाइप की गई भाषा है।

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

y = 10; कोड के बाद के भाग में इस चर का उपयोग करें

Comments

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

— दर्शन

ऐसा लगता है कि आप शब्द "चर" का दुरुपयोग कर रहे हैं, आपको इसके बजाय "प्रकार" कहना चाहिए था।

— अमीर

मेरा तर्क है कि पर्ल वैधानिक रूप से टाइप किया गया है: इसमें 3 प्रकार, स्केलर ( $), सरणी ( @) और हैश ( %) हैं। पर्ल में एक चर का प्रकार संकलन समय पर जाना जाता है और शेष चर जीवनकाल के लिए समान रहता है।

— कॉफीटेबल एस्प्रेसो