🙏🏼 🍀 🧒 जावास्क्रिप्ट (ES5) में ओओपी को समझना, भाग 2 🧖 👜 🍭

अनुवाद के नोट्स

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

पूर्णता और एक समान शैली के लिए, अनुवाद विरासत के सवालों के साथ शुरू होता है, इस तथ्य के बावजूद कि वे पहले भाग के अंत में पहले ही उल्लेख किए गए थे। इसके अलावा, विभिन्न विरासत समस्याओं को माना जाता है जैसा कि वे लेखक द्वारा माना जाता था। मुझे कहना होगा कि लेखक नए ES5 निर्माणों (इसका अंत में समझाते हुए) का व्यापक उपयोग करता है, जो सभी ब्राउज़रों में काम नहीं करते हैं और जिस भाषा में वे मूल रूप से उपयोग किए गए थे, उसकी निम्न स्तर की उनकी समझ को अस्पष्ट करते हैं। विरासत की वास्तविक समझ के लिए, आपको ES5 से ऑब्जेक्ट्स के आवरण या कार्यान्वयन के गहन विश्लेषण को देखना चाहिए: Object.create, Object.defineProperty, Function.bind, प्राप्त करें और सेट करें शाब्दिक, Object.getOwnPropertyNames, Object.defineProperty, Object.getOwnProperdDD। .getPrototypeOf। उनमें से कुछ को लेख में रखा गया है (Object.create, get and set, Object.defineProperty, bind), लेकिन हमेशा उपस्थिति के क्रम में नहीं। इस प्रकार, लेख सामान्य रूप से वंशानुक्रम के कार्यान्वयन को प्रस्तुत नहीं करना चाहता है, लेकिन कार्यान्वयन जिसे हमने एक्मास्क्रिप्ट 5 मानक के कामकाजी मसौदे में औपचारिक रूप से प्रबंधित किया है। यह कुछ भी नहीं से बेहतर है, लेकिन विरासत के प्रावधानों की पूरी समझ से कुछ कम है।

लेकिन लेख का यह हिस्सा, कई (4) बड़े कोड उदाहरणों में, शुद्ध प्रोटोटाइप विरासत को प्रदर्शित करता है, जिसे एक निर्माता की अवधारणा को शामिल करने की आवश्यकता नहीं है (हालांकि यह वहाँ है, .create (), अदृश्य रूप से मौजूद है), जिसके बारे में व्यापक रूप से बात की जाती है और जो अपने शुद्ध रूप में अत्यंत दुर्लभ है। होता है।

पहले भाग का सारांश

1. वस्तु
1.1 वस्तुएं क्या हैं? (संपत्तियों की सूची)
1.2 गुण बनाना (Object.defineProperty)
1.3 संपत्ति विवरणक (Object.defineProperty)
१.४ सिंटेक्स पार्सिंग (ब्रैकेट अंकन: वस्तु [] संपत्ति ’])
1.5 संपत्तियों तक पहुँच (कोष्ठक संकेतन के माध्यम से)
1.6 संपत्तियों को हटाना (ऑपरेटर हटाएं)
1.7 गेट्स एंड सेटर्स (एक्सेस और राइटिंग मेथड्स)
1.8 संपत्ति सूची (getOwnPropertyNames, चाबियाँ)
1.9 किसी वस्तु का साहित्य (मूल संचालक)
2. तरीके
२.१ इस गतिशील
२.२ यह कैसे लागू किया जाता है
२.२.१ यदि एक वस्तु विधि कहा जाता है
2.2.2 एक सामान्य फ़ंक्शन कॉल में (यह === वैश्विक)
२.२.३ जब संदर्भ को स्पष्ट रूप से निर्दिष्ट किया गया (.apply, .call)
2.3 संदर्भ के लिए बाध्यकारी तरीके (.bind)

भाग 2 की सामग्री

3. प्रोटोटाइप विरासत
3.1 प्रोटोटाइप
3.2 यह कैसे काम करता है [[प्रोटोटाइप]]
3.3 संपत्ति ओवरराइड
3.4 मिश्रण (अशुद्धियाँ)
3.5 परिरक्षित ('अधिलेखित') गुणों तक पहुँच

भाग 3 की रूपरेखा

4. कंस्ट्रक्टर
4.1 नए ऑपरेटर का जादू
४.२ निर्माणकर्ताओं के साथ विरासत
5. समझौतों और अनुकूलता
5.1 वस्तुओं का निर्माण
5.2 संपत्ति परिभाषा
5.3 संपत्ति की सूची
5.4 बांधने के तरीके
5.5 [[प्रोटोटाइप]] प्राप्त करना
5.6 पिछड़ी संगतता पुस्तकालय
6. सिंटेक्स रैपर
7. आगे क्या पढ़ना है
8. आभार
नोट

3. प्रोटोटाइप विरासत

अब तक, हमने जांच की है कि कैसे वस्तुओं में तरीकों को परिभाषित किया जाता है और संदर्भ के स्पष्ट रूप से निर्दिष्ट होने पर अन्य वस्तुओं में उनका पुन: उपयोग कैसे किया जाता है, लेकिन यह अभी भी वस्तुओं के उपयोग और विस्तार का सबसे अच्छा तरीका नहीं है।

अगला, वंशानुक्रम खेल में आता है। यह उन वस्तुओं को बेहतर ढंग से अलग करता है जब अन्य वस्तुओं के तरीकों के आधार पर वस्तुओं को उनके तरीकों से संपन्न किया जाता है।

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

3.1। प्रोटोटाइप

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

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

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

हमारा उदाहरण अब तक इस मॉडल में अच्छी तरह से फिट बैठता है। उदाहरण के लिए, नाम और ग्रीटिंग विधियों को एक अलग ऑब्जेक्ट में वर्णित किया जा सकता है और जहां आवश्यक हो, दिखाया जा सकता है। जो हमें निम्नलिखित मॉडल पर लाता है:

इसे इस कोड के साथ जेएस में वर्णित किया गया है: (ES5 के लिए एक कट्टर नया वाक्यविन्यास। यह याद रखें कि डिफाइनरप्रॉपर्टी में तर्क एक वस्तु है, उसका नाम और एक निर्दिष्ट विशेष ऑब्जेक्ट - लगभग।

लेख के 1 भाग के उदाहरण से स्क्रिप्ट की निरंतरता

// () → String function get_full_name(){ //    return this.first_name + ' ' + this.last_name; } // (new_name:String) → undefined function set_full_name(new_name){ //     var names = new_name.trim().split(/\s+/); this.first_name = names['0'] ||''; this.last_name = names['1'] ||''; } //=============================================== var person = Object.create(null); //     //,   {} --.. Object.defineProperty(person, 'name' ,{get: get_full_name //   / ,set: set_full_name ,configurable: true ,enumerable: true}); person.greet = function(person){ return this.name + ':  ,  ' + person + '.'; }; //      mikhail,  person  [[Prototype]] var mikhail = Object.create(person); mikhail.first_name = ''; mikhail.last_name = ''; mikhail.age = 19; mikhail.gender = 'Male'; //=== ===: console.log(mikhail.name); // => ' ' - .name     person mikhail.name = 'Michael White'; //   name    // first_name  last_name    console.log(mikhail.first_name); // => 'Michael' -  console.log(mikhail.last_name); // => 'White' // .greet    person. console.log(mikhail.greet('') ); // => 'Michael White:  ,  .' // ,      mikhail console.log(Object.keys(mikhail) ); // => [ 'first_name', 'last_name', 'age', 'gender' ]

अविश्वासियों के लिए jsfiddle (1) (IE9 +)

3.2। [[प्रोटोटाइप]] कैसे काम करता है?

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

मूल श्रृंखला को प्रत्येक माता-पिता की छिपी हुई वस्तुओं में परिभाषित किया जाता है, जिसे [[प्रोटोटाइप]] कहा जाता है। उन्हें सीधे नहीं बदला जा सकता (कार्यान्वयनों को छोड़कर जहां .__ proto__ समर्थित है), इसलिए बनाया जाने पर एकमात्र (निर्दिष्ट) तरीका निर्धारित होता है।

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

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

 // (person:String) → String person.greet = function(person){ //   return this.name + ':  ' + person + '.' }; mikhail.greet(''); // => 'Michael White:  .'

3.3। संपत्ति ओवरराइड

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

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

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

ध्यान दें कि मिखाइल और क्रिस्टिन को अभिवादन विधि के संस्करणों द्वारा व्यक्त की गई व्यक्तिगत शुभकामनाएं हैं।

... कोड में उदाहरण

(हम आगे कोड उदाहरणों में उपयोग किए गए चर की परिभाषाओं का पूरी तरह से वर्णन नहीं करेंगे - वे डुप्लिकेट उदाहरण में हैं jsfiddle.net ("=====" से विभाजन रेखा के ऊपर) या आसानी से लेख से पिछले उदाहरणों के आधार पर जोड़े जाते हैं - नोट। )

 // (person:String) → String person.greet = function(person){ //     return this.name + ': ' + (person ?', '+ person :'') +'!'; }; var mikhail = Object.create(person); mikhail.first_name = ''; mikhail.last_name = ''; mikhail.age = 19; mikhail.gender = 'Male'; // greet --    : //(person:String) → String mikhail.greet = function(person){ //   return this.name + ': '+ (person ?', '+ person :', ') +'!'; }; var kristin = Object.create(person); //  kristin.first_name = ''; kristin.last_name = ''; kristin.age = 19; kristin.gender = 'Female'; //(    ) // (person:String) → String kristin.greet = function(person){ //   return this.name + ': , ' + (person ||''); }; //===,    === console.log(mikhail.greet(kristin.first_name) ); //=> ' : , !' console.log(mikhail.greet() ); //=> ' : , !' console.log(kristin.greet(mikhail.first_name) ); //=> ' : , ' //  kristin,    : console.log(' : ', delete kristin.greet); //=> true console.log(kristin.greet(mikhail.first_name) ); //=> ' : , '

jsfiddle (2)

3.4 मिश्रण (अशुद्धियाँ)

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

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

उदाहरण के लिए, एकाधिक वंशानुक्रम वस्तुओं के उपयोग की अनुमति देगा - डेटा स्रोत जो डिफ़ॉल्ट रूप से विधियों या गुणों की सेटिंग देते हैं।

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

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

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

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

 var descriptor = Object.getOwnPropertyDescriptor // ,properties = Object.getOwnPropertyNames ,define_prop = Object.defineProperty; // (target:Object, source:Object) → Object function extend(target, source){ //  source  target properties(source).forEach(function(key){ define_prop(target, key, descriptor(source, key)) }); return target; }

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

अब हम अपनी वस्तुओं में "क्षमता" जोड़ सकते हैं।

कोड के लिए क्षमताओं का एक मिश्रण जोड़ें

 var pianist = Object.create(null); //pianist - ,   .play()   pianist.play = function(){ return this.name + '    .'; }; var singer = Object.create(null); //singer - ,   .sing() singer.sing = function(){ return this.name + '  .'; }; extend(mikhail, pianist); //    -   console.log(mikhail.play() ); // => '     .' //  ,    mikhail console.log(Object.keys(mikhail) ); //=> ['first_name', 'last_name', 'age', 'gender', 'play'] extend(kristin, singer); // kristin   () console.log(kristin.sing() ); //=> '   .' // mikhail    : try{ mikhail.sing(); //=> TypeError: Object #<Object> has no method 'sing' }catch(er){console.error(' : ', er)} //  mikhail  .sing,     - person: extend(person, singer); console.log(mikhail.sing() ); //=> '   .'

आसान नियंत्रण के लिए jsfiddle (3) (IE9 +)

3.5। परिरक्षित गुणों तक पहुँच

हमने गुणों को विरासत में देना और मिक्सिंस के साथ उनका विस्तार करना सीखा। अब एक छोटी सी समस्या है: क्या होगा यदि हम मूल वस्तु की पुनर्निर्मित (परिरक्षित) संपत्ति का उपयोग करना चाहते हैं?

JS एक Object.getPrototypOf फ़ंक्शन प्रदान करता है जो कि [[प्रोटोटाइप]] लौटाता है। इसलिए, प्रोटोटाइप के गुणों तक पहुंच काफी सरल है:

 Object.getPrototypeOf(mikhail).name; //  ,    person.name // => 'undefined undefined' person.first_name = 'Random'; //...     .first_name  .last_name person.last_name = 'Person'; //... ,      Object.getPrototypeOf(mikhail).name; //=> 'Random Person'

यह स्पष्ट होगा कि प्रोटोटाइप का संदर्भ (यह) पर्याप्त है:

 var proto = Object.getPrototypeOf; // (name:String) → String mikhail.greet = function(name){ //      return name == ' '? this.name +': , ' : /*   */ proto(this).greet.call(this, name); }; console.log(mikhail.greet(kristin.name) ); //=> ' : , ' console.log(mikhail.greet('') ); //=> ' : , '

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

एक सरल उपाय यह है कि अभिभावक से प्रोटोटाइप लिया जाए, न कि वर्तमान से। अंतिम उदाहरण इस तरह का हो जाता है

 var proto = Object.getPrototypeOf; //(name:String) → String //    mikhail -     this   mikhail.greet = function(name){ //  return name ==' ' ? this.name + ': , ' : proto(mikhail).greet.call(this, name); //   }; mikhail.greet(kristin.name); //=> ' : , ' mikhail.greet(''); //=> ' : , !'

विधि कमियां के बिना नहीं है: फ़ंक्शन में ऑब्जेक्ट को सख्ती से परिभाषित किया गया है, और हम इसे केवल ले नहीं सकते हैं और फ़ंक्शन को किसी भी ऑब्जेक्ट पर लागू कर सकते हैं, जैसा कि पहले था। फ़ंक्शन ऑब्जेक्ट के पूर्वज पर निर्भर करेगा, न कि स्वयं पर।

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

जेएस के नए संस्करण में प्रस्तावित दृष्टिकोण समस्या का केवल पहला हिस्सा हल करता है, जो सबसे सरल है। यहां हम ऐसा ही करेंगे, लेकिन तरीकों को परिभाषित करने का एक अलग तरीका पेश करके। हाँ, विधियाँ, सामान्य कार्य नहीं।

[For [प्रोटोटाइप] ions में संपत्तियों तक पहुंचने के लिए कार्यों के लिए अतिरिक्त जानकारी की आवश्यकता होती है: वह वस्तु जहां वे लिखे जाते हैं। इसके लिए एक खोज एल्गोरिथ्म की आवश्यकता होती है जो स्थैतिक डेटा के साथ काम करता है, लेकिन हमारी पुनरावर्ती समस्याओं को हल करता है।

हम Make_method फ़ंक्शन का परिचय देते हैं, जो एक फ़ंक्शन देता है जो इस जानकारी को लक्ष्य फ़ंक्शन में भेजता है। (यही है, आपको उस प्रोटोटाइप के लिए एक लिंक प्राप्त करना होगा जिसमें हमारी परिरक्षित पद्धति घोषित की गई है, और यह विरासत के प्रत्येक चरण में विधि को संशोधित करके प्राप्त किया गया है - लगभग। स्थानांतरण।)

परिरक्षित गुणों तक पहुँच प्रदर्शित करने के लिए तीन-चरण की विरासत

 //(object:Object, fun:Function) → Function function make_method(object, fun){ //       return function(){ var args; args = [].slice.call(arguments); args.unshift(object); // 'object'   fun.apply(this, args); }; } //        // ()   (,   //      -   ) function message(self, message){ var proto; proto = Object.getPrototypeOf(self); if(proto && proto.log) proto.log.call(this, message); console.log('--   : ' + self.name +';  name: '+ this.name + ';  : '+ message); } var A = Object.create(null); //   C -> B -> A A.name = 'A'; A.log = make_method(A, message); var B = Object.create(A); B.name = 'B'; B.log = make_method(B, message); var C = Object.create(B); C.name = 'C'; C.log = make_method(C, message); //===  === A.log('~A~'); //=>--   : A;  name: A;  : ~A~ B.log('~B~'); //=>--   : A;  name: B;  : ~B~ //=>--   : B;  name: B;  : ~B~ C.log('~C~'); //=>--   : A;  name: C;  : ~C~ //=>--   : B;  name: C;  : ~C~ //=>--   : C;  name: C;  : ~C~

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

jsfiddle (4), खुदाई के प्रेमियों के लिए

जारी रखा जाए।