मजबूत <=> कमजोर टाइपिंग केवल इस बारे में नहीं है कि भाषा के एक-दूसरे के लिए एक डेटाटाइप से कितने या कितने मानों को स्वचालित रूप से ज़ब्त किया जाता है, लेकिन वास्तविक मूल्यों को कितनी दृढ़ता से या कमजोर रूप से को टाइप किया जाता है। पायथन और जावा में, और ज्यादातर C # में, मानों को पत्थर में सेट किया गया है। पर्ल में, इतना नहीं - एक चर में स्टोर करने के लिए वास्तव में केवल कुछ ही अलग-अलग वैल्यूसेटेप हैं।
एक-एक करके मामले खुलते हैं।
अजगर
पायथन उदाहरण में 1 + "1", +ऑपरेटर इसे एक तर्क के रूप में स्ट्रिंग देने वाले __add__प्रकार के लिए कहता है - हालांकि, यह NotImplemented में परिणाम देता है:int"1"
>>> (1).__add__('1')
NotImplemented
इसके बाद, दुभाषिया __radd__str की कोशिश करता है :
>>> '1'.__radd__(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'str' object has no attribute '__radd__'
जैसे ही यह विफल होता है, +ऑपरेटर परिणाम के साथ विफल हो जाता है TypeError: unsupported operand type(s) for +: 'int' and 'str'। जैसे, अपवाद मजबूत टाइपिंग के बारे में बहुत कुछ नहीं कहता है, लेकिन तथ्य यह है कि ऑपरेटर + को मजबूर नहीं करता है अपने तर्क को एक ही प्रकार से स्वचालित रूप से , इस तथ्य के लिए एक संकेतक है कि पायथन निरंतरता में सबसे कमजोर टाइप की भाषा नहीं है।
दूसरी ओर, पायथन 'a' * 5 में लागू किया गया है:
>>> 'a' * 5
'aaaaa'
अर्थात्,
>>> 'a'.__mul__(5)
'aaaaa'
यह तथ्य कि ऑपरेशन अलग है, इसके लिए कुछ मजबूत टाइपिंग की आवश्यकता होती है - हालाँकि, *संख्याओं को गुणा करने से पहले मानों को जोड़ने के विपरीत अभी भी जरूरी नहीं है कि मान कमजोर रूप से टाइप किए गए हों।
जावा
जावा उदाहरण, String result = "1" + 1;केवल इसलिए काम करता है क्योंकि सुविधा के तथ्य के रूप में, ऑपरेटर +को तार के लिए अतिभारित किया जाता है। जावा +ऑपरेटर एक बनाने के साथ अनुक्रम को बदल देता है StringBuilder(देखें इस ):
String result = a + b;
// becomes something like
String result = new StringBuilder().append(a).append(b).toString()
यह बहुत स्थिर टाइपिंग का एक उदाहरण है, बिना किसी वास्तविक जबरदस्ती के - StringBuilderएक ऐसा तरीका append(Object)है जो विशेष रूप से यहां उपयोग किया जाता है। प्रलेखन निम्नलिखित कहता है:
Objectतर्क के कड़े प्रतिनिधित्व को लागू करता है।
समग्र प्रभाव वैसा ही है जैसे कि विधि द्वारा तर्क को एक स्ट्रिंग में बदल दिया गया था String.valueOf(Object), और फिर उस स्ट्रिंग के वर्णों को इस वर्ण अनुक्रम में जोड़ा गया था।
String.valueOfतब कहां
ऑब्जेक्ट तर्क का स्ट्रिंग प्रतिनिधित्व लौटाता है। [लौटता है] यदि तर्क है null, तो एक स्ट्रिंग के बराबर "null"; अन्यथा, का मान obj.toString()लौटाया जाता है।
इस प्रकार यह भाषा द्वारा बिल्कुल कोई जोर-जबरदस्ती का मामला नहीं है - वस्तुओं को हर चिंता का प्रतिनिधित्व करना।
सी#
जॉन स्कीट के जवाब के अनुसार , ऑपरेटर को जावा के +लिए भी अतिभारित नहीं किया गया है string- जावा के समान, यह केवल संकलक द्वारा उत्पन्न सुविधा है, जो स्थैतिक और मजबूत टाइपिंग दोनों के लिए धन्यवाद है।
पर्ल
जैसा कि प्रतिमा बताते हैं,
पर्ल में तीन अंतर्निहित डेटा प्रकार होते हैं: स्केलर, स्केलर्स की सरणियाँ, और स्केलर्स के साहचर्य सरणियों, जिन्हें "हैश" के रूप में जाना जाता है। एक स्केलर एक एकल स्ट्रिंग है (किसी भी आकार का, केवल उपलब्ध मेमोरी द्वारा सीमित), संख्या, या किसी चीज़ का संदर्भ (जिसकी चर्चा पर्ल में की जाएगी)। सामान्य सरणियों को संख्या द्वारा अनुक्रमित स्केलर की सूची का आदेश दिया जाता है, 0. के साथ शुरू होता है Hashes उनके संबंधित स्ट्रिंग कुंजी द्वारा अनुक्रमित स्केलर मानों के अनियोजित संग्रह हैं।
पर्ल के पास संख्या, बूलियन, स्ट्रिंग्स, नल, undefinedएस, अन्य वस्तुओं के संदर्भ आदि के लिए एक अलग डेटा प्रकार नहीं है - यह इन सभी के लिए एक प्रकार है, स्केलर प्रकार; 0 एक अदिश मान है जितना "0" है। एक स्केलर वैरिएबल जो एक स्ट्रिंग के रूप में सेट किया गया था, वास्तव में एक संख्या में बदल सकता है, और वहां से "बस एक स्ट्रिंग" से अलग व्यवहार करता है करता है अगर यह संख्यात्मक संदर्भ में एक्सेस किया जाता है।,। स्केलर पर्ल में कुछ भी पकड़ सकता है, यह उतना ही ऑब्जेक्ट है जितना कि सिस्टम में मौजूद है। जबकि पायथन में नाम सिर्फ वस्तुओं को संदर्भित करते हैं, पर्ल में नाम में स्केलर मान अस्थिर वस्तु हैं। इसके अलावा, ऑब्जेक्ट ओरिएंटेड टाइप सिस्टम इस के शीर्ष पर सरेस से जोड़ा हुआ है: पर्ल में केवल 3 डेटाटिप्स हैं - स्केलर, सूचियां और हैश।bless एक पैकेज में एड - आप इस तरह का कोई भी मूल्य ले सकते हैं और इसे किसी भी वर्ग को किसी भी पल में आशीर्वाद दे सकते हैं।
पर्ल आपको मूल्यों के वर्गों को पूरी तरह से बदलने की अनुमति देता है - यह पायथन में संभव नहीं है जहां कुछ वर्ग के मूल्य बनाने के लिए आपको उस वर्ग से संबंधित मूल्य को स्पष्ट रूप से object.__new__या समान बनाने की आवश्यकता होती है। पायथन में आप वास्तव में निर्माण के बाद वस्तु का सार नहीं बदल सकते हैं, पर्ल में आप बहुत कुछ कर सकते हैं:
package Foo;
package Bar;
my $val = 42;
# $val is now a scalar value set from double
bless \$val, Foo;
# all references to $val now belong to class Foo
my $obj = \$val;
# now $obj refers to the SV stored in $val
# thus this prints: Foo=SCALAR(0x1c7d8c8)
print \$val, "\n";
# all references to $val now belong to class Bar
bless \$val, Bar;
# thus this prints Bar=SCALAR(0x1c7d8c8)
print \$val, "\n";
# we change the value stored in $val from number to a string
$val = 'abc';
# yet still the SV is blessed: Bar=SCALAR(0x1c7d8c8)
print \$val, "\n";
# and on the course, the $obj now refers to a "Bar" even though
# at the time of copying it did refer to a "Foo".
print $obj, "\n";
इस प्रकार प्रकार की पहचान कमजोर रूप से चर के लिए बाध्य है, और इसे मक्खी पर किसी भी संदर्भ के माध्यम से बदला जा सकता है। वास्तव में, यदि आप करते हैं
my $another = $val;
\$anotherवर्ग पहचान नहीं है, भले ही \$valअभी भी धन्य संदर्भ देगा।
टी एल; डॉ
Perl के कमजोर टाइपिंग के बारे में बहुत कुछ हैं जो सिर्फ स्वचालित ज़ब्ती की तुलना में अधिक हैं, और यह इस बारे में अधिक है कि पायथन के विपरीत मानों के प्रकार स्वयं पत्थर में सेट नहीं होते हैं, जो गतिशील रूप से अभी तक बहुत दृढ़ता से टाइप की गई भाषा है। अजगर जो देता TypeErrorहै 1 + "1"वह एक संकेत है कि भाषा दृढ़ता से टाइप की जाती है, भले ही कुछ उपयोगी करने के विपरीत हो, जैसा कि जावा या सी # में उन्हें दृढ़ता से टाइप की जाने वाली भाषाएं शामिल नहीं करती हैं।
