429

ऑनलाइन सॉफ्टवेयर पर यादृच्छिक विषयों को पढ़ते हुए मुझे बतख टाइपिंग का ज्ञान हुआ और यह पूरी तरह से समझ में नहीं आया।

"डक टाइपिंग" क्या है?

programming-languages duck-typing

1

@ मिच मैंने कोशिश की और विरासत के कुछ रूप के रूप में कुछ मिला। लेकिन ज्यादा फॉलो नहीं कर सके। क्षमा करें यदि मैंने गलत प्रश्न पूछा है।

— सुशील भवानी

3

@ सुशील भवानी: नहीं, गुस्सा नहीं। लेकिन लोगों को उम्मीद है कि कॉल के पहले पोर्ट के रूप में (यानी पहली चीज जो आप करते हैं) यहां पोस्ट करने से पहले खोज करने की कोशिश करना है।

— मिच गेहूं

104

ऊपर दिए गए तर्कों को देखते हुए ऐसा नहीं लगता है कि स्टैकओवरफ़्लो वास्तव में आवश्यक है क्योंकि मुझे यकीन है कि लगभग हर प्रश्न जो संभवतः सोच सकता है, उसका उत्तर कहीं न कहीं इंटरनेट पर दिया गया है, और यदि नहीं तो उत्तर को ईमेल द्वारा संभवत: अधिक आसानी से और बिना आलोचना के प्राप्त किया जा सकता है। ज्ञानवान मित्र। मुझे लगता है कि आप में से कई स्टैकओवरफ्लो के बिंदु से चूक गए हैं।

— कविता

41

मुझे यकीन है कि मैंने कहीं पढ़ा है कि SO को "विहित प्रश्नों का भंडार" बनाने का इरादा था, और मुझे पूरा यकीन है कि आप इस से अधिक विहित नहीं कर सकते।

— हेलटनबीकर

7

यदि यह एक बतख की तरह दिखता है, एक बतख की तरह तैरता है, और एक बतख की तरह चुटकी लेता है, तो संभवतः यह एक बतख है।

— हबीब परवाद

302

यह एक ऐसी भाषा है जिसका उपयोग गतिशील भाषाओं में किया जाता है, जिसमें मजबूत टाइपिंग नहीं होती है ।

विचार यह है कि किसी वस्तु पर किसी मौजूदा विधि को लागू करने के लिए आपको एक प्रकार की आवश्यकता नहीं है - यदि कोई विधि उस पर परिभाषित है, तो आप इसे लागू कर सकते हैं।

नाम वाक्यांश से आता है "यदि यह बतख की तरह दिखता है और बतख की तरह होता है, तो यह बतख है"।

विकिपीडिया में बहुत अधिक जानकारी है।

— Oded
स्रोत

25

स्ट्रोंग टाइपिंग के उपयोग से सावधान रहें। यह अच्छी तरह से परिभाषित नहीं है। न ही डक टाइपिंग है। Google Go या Ocaml एक संरचनात्मक उप-निर्माण-निर्माण के साथ सांख्यिकीय रूप से टाइप की गई भाषाएं हैं। क्या ये बतख टाइप की हुई भाषाएं हैं?

— मैं

7

बत्तख टाइपिंग के लिए एक बेहतर वाक्यांश है: "अगर कहे कि यह एक बत्तख है .. तो यह मेरे लिए काफी अच्छा है।" देख pyvideo.org/video/1669/keynote-3 28:30 या youtube.com/watch?v=NfngrdLv9ZQ#t=1716

— tovmeod

7

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

— पलक

12

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

— alanjds

8

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

— ई-सतीस

209

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

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

उदाहरण कार्य: किसी विधि को कॉल करेंQuack पर को ।

बत्तख-टाइपिंग का उपयोग किए बिना , fइस कार्य को करने वाले फ़ंक्शन को पहले से निर्दिष्ट करना होगा कि उसके तर्क को कुछ विधि का समर्थन करना है Quack। एक आम तरीका इंटरफेस का उपयोग है

interface IQuack { 
    void Quack();
}

void f(IQuack x) { 
    x.Quack(); 
}

कॉल करना f(42)विफल रहता है, लेकिन f(donald)जब तक donaldयह एक उदाहरण है, तब तक काम करता हैIQuack -subtype ।

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

def f(x : { def Quack() : Unit }) = x.Quack()

हम लिख भी सकते थे

f :: Quackable a => a -> IO ()
f = quack

हास्केल में, जहां Quackable टाइपकास्ट हमारी पद्धति के अस्तित्व को सुनिश्चित करता है।

तो डक टाइपिंग कैसे होती है इसे बदलती है?

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

इस प्रकार, पायथन के हमेशा गतिशील टाइप के रूप में एक डायनामिक टाइप सिस्टम:

def f(x):
    x.Quack()

यदि fएक xसहायक हो जाता Quack()है, तो सब कुछ ठीक है, यदि नहीं, तो यह रनटाइम पर दुर्घटनाग्रस्त हो जाएगा।

लेकिन बत्तख टाइपिंग डायनेमिक टाइपिंग को बिल्कुल भी प्रभावित नहीं करती है - वास्तव में, एक बहुत ही लोकप्रिय लेकिन पूरी तरह से स्टैटिक डक टाइपिंग दृष्टिकोण है जो आपकी आवश्यकताओं को भी पूरा नहीं करता है:

template <typename T>
void f(T x) { x.Quack(); }

समारोह किसी भी तरह से है कि यह कुछ चाहता है में नहीं बताता है xकि कर सकते हैं Quack, तो बजाय यह सिर्फ कोशिश करता है संकलन समय पर और अगर सब कुछ काम करता है, यह ठीक।

— दारियो
स्रोत

5

आपका मतलब यह नहीं था: शून्य f (IQuak x) {x.Quak (); } (K.Quack के बजाय) क्योंकि फ़ंक्शन f का पैरामीटर IQuack x है Iquack k नहीं, बहुत छोटी गलती है, लेकिन मुझे लगा कि इसे सही करने की आवश्यकता है :)

— dominicbri7

विकिपीडिया के अनुसार, आपका अंतिम उदाहरण "संरचनात्मक टाइपिंग" है, न कि "डक टाइपिंग"।

— ब्रिलियनड

खैर, ऐसा लगता है कि उस चर्चा के लिए एक अलग सवाल है: stackoverflow.com/questions/1948069/…

— ब्रिलियनड

1

इसलिए यदि मैं समझता हूं कि आपने क्या कहा है, तो एक भाषा के बीच का अंतर जो बतख टाइपिंग का समर्थन करता है और एक ऐसा नहीं है जो सिर्फ बतख टाइपिंग के साथ है, आपको उन प्रकारों को निर्दिष्ट करने की आवश्यकता नहीं है जो एक फ़ंक्शन स्वीकार करता है? def f(x)के बजाय def f(IQuack x)।

— पीपीट्रोटस

124

सरल स्पष्टीकरण (कोड के बिना)

प्रश्न के शब्दार्थ की चर्चा काफी बारीक है (और बहुत अकादमिक), लेकिन यहाँ सामान्य विचार है:

बत्तख टाइपिंग

("अगर यह एक बतख की तरह चलता है और एक बतख की तरह चलता है तो यह एक बतख है।") - हाँ! लेकिन इसका क्या मतलब है??! यह सबसे अच्छा उदाहरण द्वारा चित्रित किया गया है:

बतख टंकण कार्यक्षमता के उदाहरण:

कल्पना कीजिए कि मेरे पास एक जादू की छड़ी है। इसकी विशेष शक्तियाँ हैं। अगर मैं छड़ी को लहराता हूं और कहता हूं "ड्राइव!" एक कार के लिए, अच्छी तरह से, तो यह ड्राइव!

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

लेकिन क्या यह काम करेगा, एक चायवाला? त्रुटि: KAAAA-BOOOOOOM! इतना अच्छा काम नहीं किया। ====> Teacups ड्राइव नहीं कर सकते हैं !! ओह !?

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

दूसरे शब्दों में, हम रुचि रखते हैं कि वस्तु क्या कर सकती है , बजाय इसके कि वस्तु क्या है ।

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

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

दूसरे शब्दों में, इस परिदृश्य में, जादू की छड़ी बहुत बारीकी से दिखती है कि वस्तु क्या है (यह एक कार है?) बजाय इसके कि वस्तु क्या कर सकती है? (जैसे कि कार, ट्रक आदि ड्राइव कर सकते हैं)।

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

सारांश: कुंजी ले-आउट

बतख टाइपिंग में जो महत्वपूर्ण है वह वही है जो वस्तु वास्तव में कर सकती है, बजाय इसके कि वस्तु क्या है ।

— BKSpurgeon
स्रोत

मुझे लगता है कि आप व्यवहार के बारे में अधिक परवाह करते हैं, यही इसकी परिभाषा है। कोई शक नहीं कि रूडी जैसी भाषाओं में BDD इतनी सफल है।

— पाब्लो ओल्मोस डी एगुइलेरा सी।

27

विचार करें कि आप एक साधारण फ़ंक्शन डिज़ाइन कर रहे हैं, जो किसी प्रकार की वस्तु प्राप्त करता है Birdऔर इसकी walk()विधि कहता है । दो दृष्टिकोण हैं, जो आप सोच सकते हैं:

यह मेरा कार्य है और मुझे यह सुनिश्चित करना चाहिए कि यह केवल स्वीकार करता है Bird, या उनका कोड संकलित नहीं करेगा। यदि कोई भी मेरे कार्य का उपयोग करना चाहता है, तो उसे इस बात की जानकारी होनी चाहिए कि मैं केवल Birdएस स्वीकार कर रहा हूं
मेरे फ़ंक्शन को कोई भी मिलता है objectsऔर मैं सिर्फ ऑब्जेक्ट की walk()विधि कहता हूं । तो, अगर objectकर सकते हैं walk()कि यह सही है, अगर यह मेरे कार्य करेंगे विफल रहता है नहीं कर सकते। इसलिए यहां यह महत्वपूर्ण नहीं है कि वस्तु एक Birdया कुछ और है, यह महत्वपूर्ण है कि यह walk() (यह टंकण टाइप कर सकता है )

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

उपयोगी पढ़ने

Https://en.wikipedia.org/wiki/Duck_typing पर Java, Python, JavaScript आदि के लिए duck टाइपिंग के अच्छे उदाहरण हैं।
यहां एक अच्छा उत्तर भी है जो डायनामिक टाइपिंग के फायदों का वर्णन करता है और इसके नुकसान भी हैं: डायनामिक टाइपिंग का अनुमानित उत्पादकता लाभ क्या है?

— अलीरज़ा फ़ताही
स्रोत

1

अच्छी व्याख्या, क्या फायदे हैं?

— सुशील भरवानी

2

यह उत्तर सरल, स्पष्ट और शुरुआती लोगों के लिए सबसे अच्छा है। इस उत्तर को ऊपर दिए गए उत्तर के साथ पढ़ें (या यदि यह चलता है, तो वह उत्तर जो कारों और

— चाय की थैलियों के

18

विकिपीडिया में एक विस्तृत विवरण दिया गया है:

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

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

महत्वपूर्ण नोट की संभावना है कि बतख टाइपिंग के साथ एक डेवलपर वस्तु के उन हिस्सों के साथ अधिक संबंध रखता है जो वास्तविक वास्तविक प्रवाह के बजाय उपभोग किए गए हैं।

— क्रिस बैक्सटर
स्रोत

13

मुझे पुराने मुहावरों को दोहराने वाले बहुत से उत्तर दिखाई देते हैं:

यदि यह एक बतख की तरह दिखता है और बतख की तरह होता है, तो यह एक बतख है

और फिर डक टाइपिंग के साथ आप क्या कर सकते हैं, इसका एक उदाहरण दें, या एक उदाहरण जो अवधारणा को आगे बढ़ाने में बाधा डालता है।

मुझे उतना मदद नहीं मिला।

बतख टाइपिंग के बारे में एक सादे अंग्रेजी उत्तर में यह सबसे अच्छा प्रयास है जो मुझे मिला है:

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

इसका मतलब यह है कि हम किसी वस्तु के वर्ग / प्रकार से कम चिंतित हैं और इस बारे में अधिक चिंतित हैं कि इस पर कौन से तरीके कहे जा सकते हैं और कौन से ऑपरेशन किए जा सकते हैं। हम इसके प्रकार के बारे में परवाह नहीं करते हैं, हम इसकी परवाह करते हैं कि यह क्या कर सकता है ।

— जेरार्ड सिम्पसन
स्रोत

3

बतख टाइपिंग:

अगर यह बात करता है और एक बतख की तरह चलता है, तो यह एक बतख है

इसे आमतौर पर कहा जाता है अपहरण ( abductive तर्क या भी कहा जाता है retroduction , एक स्पष्ट परिभाषा मुझे लगता है कि):

से सी (निष्कर्ष, हम देखते हैं ) और आर (नियम, जो हम जानते ), हम स्वीकार करते हैं / तय / मान पी (परिसर, संपत्ति दूसरे शब्दों में) किसी दिए गए तथ्य

... चिकित्सा निदान का बहुत आधार

बतख के साथ: C = चलता है, बातचीत करता है , R = एक बतख की तरह , P = यह एक बतख है

प्रोग्रामिंग पर वापस:

ऑब्जेक्ट ओ में विधि / संपत्ति mp1 और इंटरफ़ेस / प्रकार है T के लिए mp1 को परिभाषित / परिभाषित करता है
ऑब्जेक्ट ओ में विधि / संपत्ति mp2 और इंटरफ़ेस / प्रकार है T के लिए mp2 को परिभाषित / परिभाषित करता है
...

तो, केवल mp1 को स्वीकार करने से ज्यादा ... किसी भी वस्तु पर जब तक यह mp1 की कुछ परिभाषा को पूरा करता है ..., संकलक ओ के साथ संकलक / रनटाइम भी ठीक होना चाहिए प्रकार का है टी

और ठीक है, क्या यह ऊपर के उदाहरण के साथ मामला है? क्या डक टाइपिंग अनिवार्य रूप से कोई टाइपिंग नहीं है? या हम इसे अंतर्निहित टाइपिंग कहेंगे?

— Djee
स्रोत

3

भाषा को देखने से ही मदद मिल सकती है; यह अक्सर मेरी मदद करता है (मैं एक देशी अंग्रेजी वक्ता नहीं हूं)।

में duck typing :

1) शब्द का typingमतलब कीबोर्ड पर टाइप करना नहीं है (जैसा कि मेरे दिमाग में लगातार छवि थी), इसका अर्थ है "यह किस प्रकार की चीज है? "

2) यह शब्द duckव्यक्त करता है कि यह कैसे निर्धारित किया जाता है; यह एक 'ढीले' निर्धारण की तरह है, जैसे: " अगर यह एक बतख की तरह चलता है ... तो यह एक बतख है "। यह 'ढीला' है क्योंकि बात बतख की हो सकती है या नहीं, लेकिन क्या यह वास्तव में एक बतख है कोई फर्क नहीं पड़ता; जो मायने रखता है वह यह है कि मैं इसके साथ कर सकता हूं कि मैं बतख के साथ क्या कर सकता हूं और बतख द्वारा प्रदर्शित व्यवहारों की अपेक्षा कर सकता हूं। मैं इसे ब्रेड क्रुम्ब्स खिला सकता हूं और बात मेरी ओर जा सकती है या मुझ पर आरोप लगा सकती है या वापस ले जा सकती है ... लेकिन यह मुझे ऐसे नहीं खाएगा जैसे कि घड़ियाल।

— Arta
स्रोत

2

मुझे पता है कि मैं सामान्यीकृत उत्तर नहीं दे रहा हूं। रूबी में, हम चर या विधियों के प्रकार की घोषणा नहीं करते हैं - सब कुछ बस किसी प्रकार की वस्तु है। इसलिए नियम है "वर्ग प्रकार नहीं हैं"

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

उदाहरण के लिए, आप स्ट्रिंग में गीत की जानकारी जोड़ने के लिए एक रूटीन लिख रहे होंगे। यदि आप C # या जावा बैकग्राउंड से आते हैं, तो आपको यह लिखने के लिए लुभाया जा सकता है:

def append_song(result, song)
    # test we're given the right parameters 
    unless result.kind_of?(String)
        fail TypeError.new("String expected") end
    unless song.kind_of?(Song)
        fail TypeError.new("Song expected")
end

result << song.title << " (" << song.artist << ")" end
result = ""

append_song(result, song) # => "I Got Rhythm (Gene Kelly)"

रूबी के बत्तख टाइपिंग को गले लगाओ, और आप कुछ सरल लिखेंगे:

def append_song(result, song)
    result << song.title << " (" << song.artist << ")"
end

result = ""
append_song(result, song) # => "I Got Rhythm (Gene Kelly)"

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

— बचाव
स्रोत

2

डक टाइपिंग नहीं है टाइपिंग!

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

आप एक ऐसी प्रणाली की कल्पना कर सकते हैं जो जानकारी संग्रहीत करती है। सूचना लिखने / पढ़ने के लिए आपको किसी प्रकार के भंडारण और सूचना की आवश्यकता होती है।

भंडारण के प्रकार हो सकते हैं: फ़ाइल, डेटाबेस, सत्र आदि।

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

हर स्टोरेज सिस्टम को इंटरफ़ेस के अस्तित्व को जानना होगा और इसे उसी तरीके से लागू करना होगा।

interface StorageInterface
{
   public function write(string $key, array $value): bool;
   public function read(string $key): array;
}


class File implements StorageInterface
{
    public function read(string $key): array {
        //reading from a file
    }

    public function write(string $key, array $value): bool {
         //writing in a file implementation
    }
}


class Session implements StorageInterface
{
    public function read(string $key): array {
        //reading from a session
    }

    public function write(string $key, array $value): bool {
         //writing in a session implementation
    }
}


class Storage implements StorageInterface
{
    private $_storage = null;

    function __construct(StorageInterface $storage) {
        $this->_storage = $storage;
    }

    public function read(string $key): array {
        return $this->_storage->read($key);
    }

    public function write(string $key, array $value): bool {
        return ($this->_storage->write($key, $value)) ? true : false;
    }
}

इसलिए अब, हर बार आपको जानकारी लिखने / पढ़ने की आवश्यकता है:

$file = new Storage(new File());
$file->write('filename', ['information'] );
echo $file->read('filename');

$session = new Storage(new Session());
$session->write('filename', ['information'] );
echo $session->read('filename');

इस उदाहरण में आप स्टोरेज कंस्ट्रक्टर में डक टाइपिंग का उपयोग करते हैं:

function __construct(StorageInterface $storage) ...

आशा है कि यह मदद की;)

— obinoob
स्रोत

2

बतख टाइपिंग तकनीक के साथ ट्री ट्रैवर्सल

def traverse(t):
    try:
        t.label()
    except AttributeError:
        print(t, end=" ")
    else:
        # Now we know that t.node is defined
        print('(', t.label(), end=" ")
        for child in t:
            traverse(child)
        print(')', end=" ")

— रजत
स्रोत

0

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

— Icee
स्रोत

-1

मैं अपने तरीके से प्रसिद्ध वाक्य को समझने की कोशिश करता हूं: "पायथन की खुराक किसी वस्तु की परवाह नहीं करना एक वास्तविक बतख है या नहीं। यह सभी परवाह है कि क्या वस्तु, पहली 'क्वैक', दूसरी 'एक बतख की तरह'।"

एक अच्छी वेबसाइट है। http://www.voidspace.org.uk/python/articles/duck_typing.shtml#id14

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

— रोबिन
स्रोत

बत्तख टाइपिंग क्या है?

सरल स्पष्टीकरण (कोड के बिना)

उपयोगी पढ़ने