स्थिर / गतिशील बनाम मजबूत / कमजोर

Question

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

Comments

डुप्‍ली: इस प्रकार है-मेरी-समझ-की-प्रकार-प्रणालियाँ-सही

— नवफ़ल

के संभावित डुप्लिकेट क्या स्थिर टाइप किया और गतिशील रूप से टाइप किया भाषाओं के बीच अंतर है?

— कोरे तुगे

Answer 1

• स्टैटिक / डायनामिक टाइपिंग तब होती है जब टाइप जानकारी हासिल की जाती है (या तो संकलन समय पर या रनटाइम पर)

• मजबूत / कमजोर टाइपिंग इस बारे में है कि कड़ाई से प्रकार कैसे प्रतिष्ठित किए जाते हैं (जैसे कि भाषा स्ट्रिंग से संख्याओं तक एक अंतर्निहित रूपांतरण करने की कोशिश करती है)।

देखें विकि-पेज में अधिक विस्तृत जानकारी के लिए।

Comments

विकिपीडिया के पास सभी उत्तर हैं। मुझे यह पता नहीं है कि मैं पहले से ही क्यों नहीं लड़ रहा हूँ।

— Dan Revell

यह बहुत शर्म की बात है कि बहुत से लोग इस बात से अवगत नहीं हैं कि स्थैतिक / गतिशील मजबूत / कमजोर की तुलना में कुछ और है ... यह वास्तव में कुछ पूर्वाग्रह और चर्चा को बचाएगा।

— दक्ख्म

"प्रकार की कमजोरी" के विभिन्न डिग्री हैं। एक जोरदार टाइप की गई भाषा स्ट्रिंग्स से लेकर नंबरों तक रूपांतरण का प्रयास कर सकती है। दूसरी ओर, हाइपरटेक (एक ऐसी भाषा जो मैंने दशकों पहले इस्तेमाल की थी) इतनी कमजोर टाइप की थी कि "12" + "34"बराबर होगी "46", लेकिन "12" + "34Q"बराबर "1234Q"[सौभाग्य से, "12" & "34"अगर कोई चाहता था कि एक लिख सकता है ]। उत्सुकता से, चर रखने वाली संख्याओं ने उन्हें डबल-सटीक फ़्लोट के रूप में संग्रहीत किया, और ऐसे चर पर गणित ने स्ट्रिंग मुंगिंग के बिना फ़्लोटिंग-पॉइंट मानों का उपयोग किया, लेकिन यह पूछने का कोई तरीका नहीं था कि क्या एक चर स्ट्रिंग या संख्या थी।

— सुपरकैट

@kittylyst मैं यह नहीं देख सकता कि यह उत्तर बताता है कि मजबूत स्थैतिक का पर्याय है

— पीट

++ के लिए (लगभग) एकल लाइन परिभाषाएँ।

— जेम्सफैक्स

Answer 2

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

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

दृढ़ता से टाइप की गई भाषाओं के कार्यान्वयन अक्सर समय के साथ कमियां प्राप्त करते हैं, आमतौर पर रन-टाइम सिस्टम के हिस्से को उच्च-स्तरीय भाषा में लागू किया जा सकता है। उदाहरण के लिए, ऑब्जेक्टिव कैमल में एक फ़ंक्शन Obj.magicहोता है, जिसका रन-टाइम प्रभाव बस अपने तर्क को लौटाने के लिए होता है, लेकिन संकलन के समय यह किसी भी प्रकार के मूल्य को किसी अन्य प्रकार में परिवर्तित करता है। मेरा पसंदीदा उदाहरण मोडुला -3 है, जिसके डिजाइनरों ने अपने टाइप-कास्टिंग निर्माण को बुलाया LOOPHOLE।

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

Comments

(+1) आपके सुझाव के लिए "मजबूत" और "कमजोर" शब्दों से बचने के लिए।

— निको

सहमत, जॉन स्कीट की किताब के माध्यम से पढ़ रहा था, और यह वही प्रतिक्रिया है जो वहां नोट की गई है।

— बेनेट येटेस

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

— डबल ऑर्ट

Answer 3

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

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

String str = "Hello";  //statically typed as string
str = 5;               //would throw an error since java is statically typed

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

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

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

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

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

str = 5 + "hello" 
# would throw an error since it does not want to cast one type to the other implicitly. 

जबकि PHP में:

$str = 5 + "hello"; // equals 5 because "hello" is implicitly casted to 0 
// PHP is weakly typed, thus is a very forgiving language.

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

Comments

महान उदाहरण, और ठोस उदाहरणों का उपयोग करने के लिए यश।

— जूलियन ए।

यही कारण है कि PHP को बहुत सावधानी से उपयोग करने की आवश्यकता है।

— अली गजनी

भाषा के उदाहरण वास्तव में सहायक हैं। बहुत सराहना की।

— जे मुलेन

इस अर्थ में जावा कभी इतना कमजोर टाइप किया जाएगा क्योंकि आप गैर-तार को तार से जोड़ सकते हैं, और ऑटो-अनबॉक्सिंग / बॉक्सिंग के कारण?

— स्टीफन पॉल

@StephenPaul आप सही हैं मेरे उत्तर को इस तरह समझा जा सकता है, और यह मामला नहीं है। मैंने सादगी के लिए समागम का उपयोग किया, लेकिन वास्तव में, मजबूत-नेस / कमजोरी चर के निहित प्रकार रूपांतरण के बारे में है।

— mehmet

Answer 4

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

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

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

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

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

इसी तरह सबसे दृढ़ता से टाइप की जाने वाली भाषाएँ अभी भी पूर्णांकों और फ़्लोट्स (और कुछ भाषाओं में सटीक रूप से सटीक BigInts) के बीच परिवर्तित हो जाएंगी।

Comments

मैं इस वाक्य से सहमत नहीं हो सकता -। "एक वैधानिक रूप से टाइप की गई भाषा में प्रत्येक चर और पैरामीटर के प्रकार को स्रोत में घोषित किया जाना चाहिए" - SML में चर के प्रकारों को घोषित नहीं किया जाना चाहिए (कभी भी उनकी जाँच कैसे की जाती है)। मान लें कि फ़ंक्शन fतर्क लेता है x( fun f(x)) [** तो कोई प्रकार घोषित नहीं किया जाता है **] और फ़ंक्शन का शरीर है x+1। किसी प्रकार के घोषित संकलक से यह पता नहीं चल xसकेगा कि एक इंट होना है। - fun f x = x + 1; val f = fn : int -> int

— फिलिप बार्टुज़ि

C के बारे में, कास्टिंग मजबूत टाइपिंग के खिलाफ नहीं है, लेकिन C बिना कास्टिंग के भी विभिन्न प्रकारों को जोड़ने की अनुमति देता है, जैसे:5 + 'c' // OK

— mehmet

@mehmet: C में, वर्ण मान पूर्णांक डोमेन में हैं, इसलिए यह विशेष उदाहरण प्रकार की सुरक्षा का उल्लंघन नहीं करता है। 'c' 99 के लिए सिंटैक्टिक शुगर है। C में एक समर्पित चरित्र प्रकार नहीं है।

— पीटर ल्यूरिन

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

— mehmet

C एक कमजोर टाइप की भाषा नहीं है । यह सिर्फ इतना है कि सी। की तुलना में जावा, सी # आदि अधिक दृढ़ता से टाइप की जाने वाली भाषाएं हैं। यहाँ पढ़ें और अधिक पढ़ें - en.wikipedia.org/wiki/Strong_and_weak_typing यदि आप "कमजोर" टाइप की गई भाषा की परिभाषा "कमजोर" टाइप की हुई भाषाओं की जाँच करते हैं। क्या वे हैं जिनमें आप किसी भी प्रकार का रूपांतरण कर सकते हैं, उदाहरण के लिए एक int एक स्ट्रिंग में "निहित" रूपांतरित या डाला जा सकता है , अब आप खुद सोचें कि क्या यह C में संभव है या नहीं?

— हग्रावाल

Answer 5

आज इस विषय के बारे में शोध करने पर मुझे यह बेहतरीन लेख http://blogs.perl.org/users/ovid/2010/08/what-to-know-before-debating-type-systems.html यह बहुत साफ हो गया मेरे लिए चीजें और मैंने सोचा कि यह ऊपर दिए गए कुछ शानदार उत्तरों को जोड़ सकता है।

मजबूत और कमजोर टंकण:

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

स्थैतिक और गतिशील प्रकार

यह बहुत ही सामान्य प्रकार का एकमात्र वर्गीकरण है जिसका वास्तविक अर्थ है। तथ्य की बात के रूप में, इसका महत्व अक्सर कम-अनुमानित है [...] गतिशील और स्थिर प्रकार की प्रणालियां दो पूरी तरह से अलग चीजें हैं, जिनके लक्ष्य आंशिक रूप से ओवरलैप होते हैं।

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

स्पष्ट / निहित प्रकार:

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

Answer 6

स्कॉट के प्रोग्रामिंग लैंग्वेज प्रैग्मेटिक्स से , तीसरा संस्करण पेज 291, हमारे पास है

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

कुछ उदाहरण: एडा दृढ़ता से टाइप किया गया है, और अधिकांश भाग के लिए सांख्यिकीय रूप से टाइप किया गया है (कुछ प्रकार की बाधाओं को चलाने के दौरान जांचना आवश्यक है)। एक पास्कल कार्यान्वयन अपने अधिकांश प्रकार की जाँच संकलन समय पर भी कर सकता है, हालाँकि यह भाषा बहुत दृढ़ता से टाइप नहीं की गई है: असंगत संस्करण रिकॉर्ड (खंड ).३.४ में चर्चा की जाने वाली) इसकी एकमात्र खामियां हैं। C89 अपने पूर्ववर्ती बोलियों की तुलना में बहुत अधिक दृढ़ता से टाइप किया गया है, लेकिन अभी भी पास्कल की तुलना में काफी कम टाइप किया गया है। इसकी खामियों में यूनियनों, पैरामीटर्स की सबरूटिनविथ चर संख्या, और पॉइंटर्स और सरणियों की इंटरऑपरेबिलिटी (धारा 7.7.1 में चर्चा की जानी है) शामिल हैं। C का कार्यान्वयन शायद ही कभी रन समय पर कुछ भी जांचता है।

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

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

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

Answer 7

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

यहाँ दो उदाहरण हैं:

• कुछ का कहना है कि हास्केल दृढ़ता से टाइप किया गया है, क्योंकि आपको किसी भी प्रकार के रूपांतरण करने की अनुमति नहीं है ।

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

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

Answer 8

वैधानिक रूप से v / s गतिशील रूप से टाइप की गई भाषाएँ

• वैधानिक रूप से टाइप की गई भाषा वे हैं जिनमें संकलन समय पर जाँच की जाती है, इसलिए इसका अर्थ यह भी है कि सांख्यिकीय रूप से टाइप की गई भाषाओं में प्रत्येक चर का प्रकार होता है और यह पाठ्यक्रम में परिवर्तित नहीं होता है। अब, इसके विपरीत, गतिशील रूप से टाइप की जाने वाली भाषाएं हैं, जिनमें रनटाइम पर टाइपिंग की जाँच की जाती है, और संकलन समय पर किसी भी प्रकार की जाँच नहीं होती है, इसलिए इसका अर्थ यह भी है कि डायनामिक रूप से टाइप की गई भाषाएँ एक प्रकार से भिन्न हो सकती हैं या नहीं भी हो सकती हैं। , और यदि कोई प्रकार जुड़ा हुआ है, तो यह जेएस में "var" जैसा एक सामान्य प्रकार हो सकता है जो स्ट्रिंग और संख्या दोनों के लिए अच्छा है।
  • "गतिशील रूप से टाइप की गई भाषाओं के कार्यान्वयन आमतौर पर प्रत्येक रनटाइम ऑब्जेक्ट को एक प्रकार के टैग (यानी, एक प्रकार का संदर्भ) के साथ जोड़ते हैं जिसमें इसकी प्रकार की जानकारी होती है। इस रनटाइम प्रकार की जानकारी (RTTI) का उपयोग डायनेमिक डिस्पैच, लेट बाइंडिंग, डाउन कास्टिंग, रिफ्लेक्शन और इसी तरह की अन्य विशेषताओं को लागू करने के लिए किया जा सकता है। ”
• भले ही भाषा वैधानिक रूप से टाइप की गई हो, फिर भी इसमें कुछ गतिशील रूप से टाइप की गई सुविधा हो सकती है, जिसका मूल अर्थ है कि रनटाइम के दौरान कुछ प्रकार की जाँच। यह प्रकारों की ढलाई में उपयोगी है।
  • “कई उपयोगी और आम प्रोग्रामिंग भाषा सुविधाओं को स्टेटिक रूप से जाँच नहीं किया जा सकता है, जैसे कि डाउन कास्टिंग। इस प्रकार, कई भाषाओं में स्थिर और गतिशील दोनों प्रकार की जाँच होगी; स्टैटिक टाइप चेकर सत्यापित करता है कि यह क्या कर सकता है, और डायनेमिक चेक बाकी को सत्यापित करता है। "
• “कुछ भाषाएं लिखने का कोड देती हैं जो टाइप-सुरक्षित नहीं है। उदाहरण के लिए, सी में, प्रोग्रामर स्वतंत्र रूप से किसी भी दो प्रकारों के बीच एक मान डाल सकते हैं जिनका आकार समान है। "
• "स्टैटिकली" टाइप की गई भाषाओं का लाभ यह है कि:
  • चूंकि अधिकांश प्रकार की जाँच संकलन समय पर की जाती है, इसलिए दुभाषिया या रनटाइम पूर्ण गति से चल सकता है, प्रकारों की चिंता किए बिना।
  • यह रनटाइम अपवाद या प्रकार से संबंधित त्रुटियों की कम संख्या की ओर जाता है, क्योंकि अधिकांश प्रकार की जाँच संकलन समय पर की जाती है।
• "गतिशील" टाइप की गई भाषाओं का लाभ यह है कि:
  • वे बहुत तेज़ प्रोटोटाइप में मदद कर सकते हैं, क्योंकि डेवलपर को टाइप सिस्टम को समझने की ज़रूरत नहीं है इसलिए देव शिथिल रूप से चर बना सकते हैं और इसे चला सकते हैं, और यह बहुत तेज़ प्रोटोटाइप की ओर जाता है।
• सांख्यिकीय और गतिशील रूप से टाइप की गई भाषाओं की सूची :
  • स्थिर:
    • जावा
    • सी (सी एक सांख्यिकीय रूप से टाइप की गई भाषा है लेकिन जावा की तुलना में "दृढ़ता से" टाइप की जाती है क्योंकि यह अधिक अंतर्निहित रूपांतरणों की अनुमति देती है)
    • सी ++
    • सी#
  • गतिशील रूप से:
    • PERL
    • पीएचपी
    • अजगर
    • जावास्क्रिप्ट
    • माणिक
• टाइप चेकिंग एक महत्वपूर्ण सुरक्षा विशेषता है। मान लीजिए, कोई प्रकार की जाँच नहीं है, और एक विधि "BankAccount" प्रकार की एक वस्तु को स्वीकार करती है, जिसका एक तरीका है, जिसे "creditAccount (BankAccountDetails)" कहा जाता है, अब यदि कोई प्रकार की जाँच नहीं होती है, तो मैं अपनी खुद की एक वस्तु पास कर सकता हूँ वर्ग जिसकी एक ही विधि है "क्रेडिटअकाउंट (BankAccountDetails)" और यह निष्पादित हो जाएगा, यह देखते हुए कि हम ऑब्जेक्ट ओरिएंटेड भाषा के बारे में बात कर रहे हैं क्योंकि OOP "बहुरूपता" का समर्थन करता है और यहाँ हम जिस पर चर्चा कर रहे हैं वह "बहुरूपता" के अलावा और कुछ नहीं है। तो, मूल रूप से एक वस्तु उन्मुख भाषा (जिसका मूल अर्थ है कि यह "बहुरूपता" का समर्थन करता है) जिसमें मजबूत प्रकार की जांच नहीं होती है, सुरक्षा मुद्दों को जन्म दे सकती है।

जोरदार v / s कमजोर टाइप की हुई भाषाएं

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

---

आगे की पढाई अच्छी है

• Type_system
• Strong_and_weak_typing
• श्रेणी: Statically_typed_programming_languages
• श्रेणी: Dynamically_typed_programming_languages

Comments

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

— असीम यादव

@AseemYadav "* का क्या मतलब है यदि आप पहले से ही उस तंत्र से आगे निकल चुके हैं जो आपको एक वस्तु * पास करने से रोक सकता है?"

— हगरावल

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

— असेम यादव

इसका कोई प्रदर्शन पहलू नहीं है, आपको इसे बहुरूपता के संदर्भ से देखना होगा तब आप इसके सुरक्षा पहलू को समझ पाएंगे, मैंने इसी पैराग्राफ में इसका उल्लेख किया है।

— हगरावल

Answer 9

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

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

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

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

char *a = "123";
int b = (int)a;

बराबर जावा कोड एक संकलित त्रुटि उत्पन्न करेगा, जो आम तौर पर बेहतर है:

String a = "123"
int b = (int)a;