440

इसके अलावा, क्या एक दूसरे का मतलब है?

type-safety strong-typing static-typing

— JDelage
स्रोत

8

नोट के पास डुप्लिकेट पर stackoverflow.com/questions/2351190/...

— नॉर्मन रैमसे

4

Tcl दृढ़ता से टाइप किया गया है। इसमें केवल स्ट्रिंग है: P

— nawfal

21

@nawfal नाह, यह कड़ाई से टाइप किया गया है;)

— geekonaut

542

एक जोरदार टाइप की गई भाषा और एक स्थिर टाइप भाषा के बीच अंतर क्या है?

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

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

स्थैतिक बनाम गतिशील

स्टैटिकली टाइप के विपरीत "डायनामिकली टाइप्ड" है, जिसका अर्थ है कि

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

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

मजबूत बनाम कमजोर

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

यहाँ वास्तव में क्या हो रहा है?

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

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

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

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

क्या एक दूसरे को प्रभावित करता है?

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

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

किसी भी तरह से, यदि कोई व्यक्ति किसी भाषा को "दृढ़ता से टाइप किया हुआ" कहता है, तो उस व्यक्ति के बारे में एक सांख्यिकीय रूप से टाइप की जाने वाली भाषा के बारे में बात की जा सकती है।

— नॉर्मन रैमसे
स्रोत

3

@ एडडम: अपवित्र होने के लिए पर्याप्त रूप से सही नहीं है :) क्योंकि क्लेटस के जवाब में बहुत सारी गलतफहमियां हैं (हालांकि मैंने उनमें से सबसे खराब संपादन किया है), मुझे एक शब्दांश के शब्दों में सब कुछ वर्तनी के लिए मजबूर महसूस हुआ ...

— नॉर्मन रैमसे

1

वैसे मैंने आपको उतारा :) यहां तक कि "संकलन" शब्द भी स्पष्ट नहीं है जो आज के वीएम गतिशील भाषाएं चला रहा है। तकनीकी रूप से जावा और C # दोनों को दो बार (JIT) संकलित किया गया है और दोनों कुछ प्रकार का विश्लेषण करते हैं। .NET vm में चलने वाली जावास्क्रिप्ट जैसी भाषा VM की वजह से अधिक टाइपफ़स हो सकती है।

— एडम जेंट

2

मैं अब बहुत उलझन में हूँ! ठीक है, अखाड़े के प्रिय महान ग्लैडिएटर्स, क्या मेरे जैसी गरीब आत्मा निम्नलिखित सरल समझ के साथ जा सकती है? 1. स्थिर: मान संकलन समय के दौरान प्रकार के साथ जुड़े होते हैं और समय नहीं चलाते हैं। डायनामिक: मान रनटाइम के दौरान प्रकार से जुड़े होते हैं, इसलिए रनटाइम के दौरान मान का प्रकार बदल सकता है ~ इसलिए टाइपिंग से संबंधित मुद्दों के लिए अधिक प्रवण रनटाइम के दौरान। 3. मजबूत / कमजोर: इसे भूल जाओ! ये तकनीकी शब्द नहीं हैं और सिर्फ नाममात्र हैं। यह इस बात पर निर्भर करता है कि कोई किस संदर्भ में बात कर रहा है। क्या मैं इस सरल समझ के साथ अपने जीवन को आगे बढ़ा सकता हूं? :(

— सौरभ पाटिल

"उस प्रकार के निर्माणकर्ताओं में से किसी एक को कॉल करके बनाए गए गारंटीकृत प्रकार (या वर्ग) का हर मूल्य है?" C में उत्तर नहीं है। क्या कोई एक उदाहरण स्थिति प्रदान कर सकता है जहां यह सी में होता है? मुझे लगता है कि इसमें कॉम्पेक्ट्स को कास्टिंग पॉइंट्स शामिल हैं?

— corazza

मजबूत और कमजोर टंकण: ऐसा कोई वर्गीकरण नहीं।

— राऊल

248

यह अक्सर गलत समझा जाता है तो मैं इसे स्पष्ट कर दूं।

स्टैटिक / डायनामिक टाइपिंग

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

डायनामिक टाइपिंग वह जगह है जहां टाइप वैल्यू के लिए बाध्य है । रन टाइम पर टाइप्स चेक किए जाते हैं।

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

String s = "abcd";

s"हमेशा के लिए" हो जाएगा String। अपने जीवन के दौरान यह अलग-अलग Strings को इंगित कर सकता है (चूंकि sजावा में एक संदर्भ है)। इसका nullमान हो सकता है लेकिन यह कभी भी Integera या a का संदर्भ नहीं देगा List। वह स्टैटिक टाइपिंग है।

PHP में:

$s = "abcd";          // $s is a string
$s = 123;             // $s is now an integer
$s = array(1, 2, 3);  // $s is now an array
$s = new DOMDocument; // $s is an instance of the DOMDocument class

यह डायनामिक टाइपिंग है।

मजबूत / कमजोर टंकण

(अलर्ट संपादित करें!)

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

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

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

इस उत्तर के मूल में निहितार्थ रूपांतरण (जिसे कभी-कभी "निहित पदोन्नति" भी कहा जाता है) के साथ कमजोर टाइपिंग होती है । उदाहरण के लिए, जावा में:

String s = "abc" + 123; // "abc123";

यह कोड निहित प्रचार का एक उदाहरण है: 123 को संक्षेप में एक स्ट्रिंग में परिवर्तित किया जाता है, जिसके साथ समाप्‍त होने से पहले "abc"। यह तर्क दिया जा सकता है कि जावा कंपाइलर उस कोड को फिर से लिखता है:

String s = "abc" + new Integer(123).toString();

एक क्लासिक PHP पर विचार करें "समस्या" से शुरू होता है:

if (strpos('abcdef', 'abc') == false) {
  // not found
}

यहां त्रुटि यह है कि strpos()मैच का इंडेक्स लौटाया जा रहा है, 0. 0 बूलियन में जमा है falseऔर इस तरह हालत वास्तव में सच है। समाधान निहितार्थ से बचने के ===बजाय उपयोग करना है ==।

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

इसकी तुलना रूबी से करें:

val = "abc" + 123

जो एक रनटाइम त्रुटि है क्योंकि रूबी में ऑब्जेक्ट 123 को केवल इसलिए परिवर्तित नहीं किया गया है क्योंकि यह एक +विधि को पारित करने के लिए होता है । रूबी में प्रोग्रामर को रूपांतरण स्पष्ट करना चाहिए:

val = "abc" + 123.to_s

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

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

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

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

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

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

— cletus
स्रोत

कहने के बजाय $ s एक पूर्णांक या स्ट्रिंग है, बेहतर होता यदि आप कहते हैं कि प्रकार "abcd" से जुड़ा हुआ है या 1234 चर $ s के साथ नहीं है।

— श्रीनिवास रेड्डी थिप्पर्थी

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

— JasDev

1

"abc" + 123एक रनटाइम त्रुटि है, माणिक में संकलित त्रुटि नहीं है। यदि यह एक संकलित त्रुटि थी, तो माणिक को वैधानिक रूप से टाइप किया जाएगा।

— sepp2k

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

— एडम जेंट

मेरे ऑपियन में मजबूत बनाम कमजोर टाइपगिन यह है: मजबूत: "सी" + ट्रू = रनटाइम त्रुटि या संकलन समय त्रुटि। कमजोर: "c" + True = "b" या "d" क्योंकि सब कुछ कच्चे बाइट्स के रूप में माना जाता है। मजबूत: सी #, रूबी, सी ++ कमजोर: असेंबली, सी (निहित शून्य बिंदुओं के कारण)

— जोनाथन एलन

17

दोनों दो अलग-अलग धुरी पर डंडे हैं:

जोर से टाइप किया हुआ बनाम कमजोर टाइप का
स्टेटिकली टाइप्ड बनाम डायनामिक टाइप्ड

दृढ़ता से टाइप किया गया साधन, एक स्वचालित रूप से एक प्रकार से दूसरे में परिवर्तित नहीं होगा। कमजोर टाइप विपरीत होता है: पर्ल एक स्ट्रिंग का उपयोग "123"संख्यात्मक संदर्भ में कर सकता है, इसे स्वचालित रूप से इंट में परिवर्तित करके 123। अजगर जैसी जोरदार टाइप की गई भाषा ऐसा नहीं करेगी।

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

— डैरन थॉमस
स्रोत

6

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

— जोनाथन एलन

1

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

— एडम जेंट

1

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

— MaRoBet

13

जोर से टाइप करने का मतलब है कि प्रकारों के बीच रूपांतरण के बीच प्रतिबंध हैं। स्टैटिकली टाइप का मतलब है कि टाइप डायनेमिक नहीं हैं - आप एक बार बनने के बाद वेरिएबल के टाइप को बदल नहीं सकते।

— स्वेतलोज़र एंजेलोव
स्रोत

इसे प्रदर्शित करने के लिए: दृढ़ता से टाइप की गई भाषा में, आप "5" == 5 की तुलना नहीं कर सकते हैं और इसे सच कर सकते हैं: स्ट्रिंग्स पूर्णांक नहीं हैं। यदि मेरी स्मृति कार्य करती है, तो अधिकांश आधुनिक स्क्रिप्टिंग भाषाएँ दृढ़ता से गतिशील रूप से टाइप की जाती हैं। Tcl / Tk, हालांकि कमजोर रूप से टाइप किया गया है - सब कुछ एक स्ट्रिंग के रूप में माना जा सकता है।

— छोटे बॉबी टेबल्स

बॉबी, एक कमजोर टाइप की गई भाषा में "5" == 5 को 0x35 == 0x05 के रूप में पढ़ा जाता है। या दूसरे शब्दों में, सब कुछ कच्चे बाइट्स के रूप में माना जाता है।

— जोनाथन एलन

मुझे तुम दोनों से असहमत होना है। लूआ ले लो; आप "5" == 5 की तुलना कर सकते हैं और यह गलत हो जाएगा, हालांकि "5" + 0.

— RCIX

12

जरूरी नहीं कि डेटा सिन्कोरियन का अर्थ कमजोर टाइप किया गया हो क्योंकि कभी-कभी इसका सिंटेशिकल शुगर:

जावा के ऊपर का उदाहरण कमजोर होने के कारण टाइप किया गया है

String s = "abc" + 123;

कमजोर टाइप का उदाहरण नहीं है क्योंकि वास्तव में ऐसा कर रहा है:

String s = "abc" + new Integer(123).toString()

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

यह सी। सी के विपरीत है जो कमजोर टाइप के सबसे अच्छे उदाहरणों में से एक है। रनटाइम का कोई पता नहीं है अगर 4 बाइट एक पूर्णांक, एक संरचना, एक सूचक या 4 वर्ण है।

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

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

— एडम जेंट
स्रोत

बी शायद एक बेहतर है, अगर थोड़ा कम जाना जाता है, उदाहरण।

— टॉम हैटिन

जावास्क्रिप्ट भी कमजोर प्रकार का है, लेकिन क्योंकि वहाँ कुछ प्रकार हैं और क्योंकि आप वास्तव में नए प्रकार का निर्माण नहीं कर सकते हैं।

— एडम गेंट

10

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

जोरदार टाइप किया हुआ वी.एस. कमजोर टाइप क्या है?

दृढ़ता से टाइप किया हुआ: स्वचालित रूप से एक प्रकार से दूसरे में परिवर्तित नहीं होगा

गो या पाइथन की तरह दृढ़ता से टाइप की जाने वाली भाषाएं "2" + 8 एक प्रकार की त्रुटि उठाएगी, क्योंकि वे "टाइप कॉर्सेर" की अनुमति नहीं देते हैं।

कमजोर (शिथिल) टाइप: स्वचालित रूप से एक प्रकार से दूसरे में परिवर्तित हो जाएगा: जावास्क्रिप्ट या पर्ल जैसी कमजोर टाइप की गई भाषाएं कोई त्रुटि नहीं फेंकेंगी और इस स्थिति में जावास्क्रिप्ट '28' का परिणाम देगा और पर्ल का परिणाम 10 होगा।

पर्ल उदाहरण:

my $a = "2" + 8;
print $a,"\n";

इसे main.pl में सहेजें और चलाएं perl main.pl और आपको आउटपुट 10 मिलेगा।

Static VS डायनामिक टाइप क्या है?

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

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

इसका क्या मतलब है?

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

package main

import "fmt"

func foo(a int) {
    if (a > 0) {
        fmt.Println("I am feeling lucky (maybe).")
    } else {
        fmt.Println("2" + 8)
    }
}

func main() {
    foo(2)
}

इस फाइल को main.go में सेव करें और इसे रन करें, आपको इसके लिए संकलन विफल संदेश मिल जाएगा।

go run main.go
# command-line-arguments
./main.go:9:25: cannot convert "2" (type untyped string) to type int
./main.go:9:25: invalid operation: "2" + 8 (mismatched types string and int)

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

def foo(a):
    if a > 0:
        print 'I am feeling lucky.'
    else:
        print "2" + 8
foo(2)
foo(0)

आपको निम्न आउटपुट दिखाई देगा

python main.py
I am feeling lucky.
Traceback (most recent call last):
  File "pyth.py", line 7, in <module>
    foo(0)
  File "pyth.py", line 5, in foo
    print "2" + 8
TypeError: cannot concatenate 'str' and 'int' objects

— बालकृष्ण
स्रोत

8

एक दूसरे को इम्प्रेस नहीं करता। किसी भाषा के लिए सांख्यिकीय रूप से टाइप करने के लिए इसका मतलब है कि सभी चर के प्रकार ज्ञात हैं या संकलन समय पर अनुमान किए जाते हैं।

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

— जो कनपट्टी
स्रोत

7

मजबूत टाइपिंग का शायद यह मतलब है कि चर एक अच्छी तरह से परिभाषित प्रकार हैं और अभिव्यक्ति के विभिन्न प्रकारों के संयोजन के बारे में सख्त नियम हैं। उदाहरण के लिए, यदि A पूर्णांक है और B एक फ्लोट है, तो A + B के बारे में सख्त नियम यह हो सकता है कि A को एक फ्लोट पर रखा गया हो और परिणाम फ्लोट के रूप में लौटा हो। यदि A पूर्णांक है और B एक स्ट्रिंग है, तो सख्त नियम यह हो सकता है कि A + B मान्य नहीं है।

स्टेटिक टाइपिंग का अर्थ शायद यह है कि प्रकारों को संकलित समय (या इसके गैर-संकलित भाषाओं के बराबर) में असाइन किया गया है और प्रोग्राम निष्पादन के दौरान बदल नहीं सकता है।

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

और ध्यान दें कि जब मैं 'शायद' शब्द का उपयोग करता हूं तो यह है क्योंकि इन शब्दों की कोई सार्वभौमिक रूप से स्वीकृत परिभाषा नहीं है। जैसा कि आप अब तक के जवाबों से देख चुके हैं।

— उच्च प्रदर्शन मार्क
स्रोत