🐼 🐉 🙉 क्लोजर और जावास्क्रिप्ट ऑब्जेक्ट। दुभाषिया को फिर से लगाना 🧝🏽 📕 🥪

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

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

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

प्रथम श्रेणी की विशेषताएं

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

निम्नलिखित कोड पर विचार करें:

//  1 var x = 10; var foo = function() { var y = 20; var bar = function() { var z = 30; return x+y+z; } return bar; } var baz = foo(); console.log(baz()); // 60

चर x , foo और baz वैश्विक हैं, और इसलिए स्टैक गहराई की परवाह किए बिना, हर जगह उपलब्ध हैं। foo को कॉल करने के क्षण में, स्टैक के शीर्ष पर स्थानीय चर y और bar साथ एक फ्रेम होता है, फिर, जब foo बाहर निकलते हैं, तो यह फ्रेम खो जाता है, और baz को कॉल करते समय - केवल z सक्रियण फ्रेम में होता है। दुभाषिया कहां मिलता है? सी भाषा में (और उसके सभी वंशज) इस समस्या को बहुत गंभीरता से हल किया जाता है - नेस्टेड कार्यों की घोषणा निषिद्ध है। पास्कल में, इसके विपरीत, नेस्टेड फ़ंक्शन हैं, लेकिन आउटपुट पर एक फ़ंक्शन वापस करने की कोई संभावना नहीं है। जब वे कहते हैं कि अनिवार्य भाषाओं में कार्य प्रथम श्रेणी की वस्तु नहीं हैं, तो उनका अर्थ ठीक यही स्थिति है । फ़ंक्शनल भाषाएँ आपको फ़ंक्शंस के साथ कुछ भी करने की अनुमति देती हैं (वास्तविक जावास्क्रिप्ट में ऊपर का उदाहरण पूरी तरह कार्यात्मक है)। वे इसे कैसे करते हैं?

बाहरी फ़ंक्शन foo से नेस्टेड फंक्शन bar को वापस करते समय, foo को कॉल करके बनाया गया स्टैक फ्रेम bar फ़ंक्शन के निष्पादन संदर्भ के भाग के रूप में baz वेरिएबल में संग्रहित होता है। इस प्रकार, दृश्यता क्षेत्रों की एक श्रृंखला बनती है जो कॉल स्टैक से पूरी तरह से स्वतंत्र है। इस श्रृंखला के गठन तंत्र का विशिष्ट कार्यान्वयन, निश्चित रूप से, इस सरलीकृत विवरण से बहुत भिन्न हो सकता है, लेकिन मुख्य बात यह है कि चर y मौजूद है जबकि baz मौजूद है, इस तथ्य के बावजूद कि जब foo बाहर निकलते हैं foo लिंक स्टैक से गायब हो जाता है।

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

 //  2 var x = 'I am global!'; var foo = function (y) { var z = 'unchanged'; var getXYZ = function () { return 'x: '+x+' y: '+y+' z: '+z; } var setZ = function(newZ) { z = newZ; } return [getXYZ, setZ]; //   ,      , ? } var a = foo('Alice'); // *1* var b = foo('Bob'); // *2* console.log(a[0]()); // x: I am global! y: Alice z: unchanged a[1]('changed'); // *3* console.log(a[0]()); // x: I am global! y: Alice z: changed *4* console.log(b[0]()); // x: I am global! y: Bob z: unchanged x = 'Everybody can see me!'; // *5* console.log(a[0]()); // x: Everybody can see me! y: Alice z: changed console.log(b[0]()); // x: Everybody can see me! y: Bob z: unchanged

बिंदु * 1 * पर, "दृश्यता पेड़" foo नोड में बाहर शाखाएं, क्योंकि हम दो नेस्टेड फ़ंक्शन लौटाते हैं। वे चर y और z माध्यम से एक दूसरे के साथ संवाद कर सकते हैं, जिसे बिंदु * 3 * पर देखा जा सकता है। बिंदु * 2 * पर, हम दूसरी बार फ़ंक्शन foo प्रवेश करते हैं, और पेड़ बढ़ता है - सभी स्थानीय चर foo की प्रतियां foo । ग्रे getXYZ और setZ को भी y और z माध्यम से ग्रे foo नोड के भाग के रूप में सूचित किया जाता है, लेकिन वे काले foo नोड से y और z बारे में कुछ भी नहीं जानते हैं, जो स्पष्ट रूप से * 4 * पर दिखाई देता है। इसी समय, दृश्यमान पेड़ की सभी पत्तियों (* 5 *) के ऊपर चर x दिखाई दे रहा है।

इस प्रकार, कार्यक्रम लिखने के समय, हम भविष्य के दृश्य पेड़ों की संरचना का निर्धारण करते हैं, पेड़ की शाखाओं के वास्तविक निर्माण के समय, हम इसके अंदर कुछ चरों को प्रभावित कर सकते हैं और उन्हें तय करने के बाद छोड़ सकते हैं ( foo('Alice') या foo('Bob') बुलाने के बाद कोई रास्ता नहीं है। चर y के मूल्य को बाहर बदलें) और, जबकि पेड़ की शाखाएं मौजूद हैं, हम केवल इसकी स्थिति को नियंत्रित कर सकते हैं क्योंकि पत्तियां इसे अनुमति देती हैं।

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

इनकैप्सुलेशन और इनहेरिटेंस

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

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

 //  3 var obj = { x: 10, y: 20, foo: function () {return x + y;} }; console.log(obj['foo']()); // !

वास्तव में, सब कुछ थोड़ा और अधिक जटिल है। यह उदाहरण निष्क्रिय है, क्योंकि सक्रियण ऑब्जेक्ट (स्टैक फ्रेम को जावास्क्रिप्ट में कहा जाता है) में हमारे फ़ंक्शन foo() में कोई x और y । उनमें से कोई भी श्रृंखला नहीं है, केवल चर obj । उन तक पहुंचने के लिए, हमें उन्हें obj['x'] और obj['y'] रूप में बदलना होगा:

 //  4 var obj = { x: 10, y: 20, foo: function () {return obj['x'] + obj['y'];} } console.log(obj['foo']()); // 30

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

 //  5 function createObj(x, y) { var obj = {}; obj['x'] = x, obj['y'] = y, obj['foo'] = function () {return obj['x'] + obj['y'];} return obj; } var obj1 = createObj(1, 2); var obj2 = createObj(3, 4); console.log(obj1['foo']()); // 3 console.log(obj2['foo']()); // 7

चूंकि createObj() फ़ंक्शन नेस्टेड ऑब्जेक्ट को obj ऑब्जेक्ट के हिस्से के रूप में लौटाता है, प्रत्येक बार इसे कहा जाता है, एक क्लोजर x , y और foo की प्रतियों से बना होता है जो एक दूसरे से स्वतंत्र होते हैं (स्कोप ट्री ऊपर की ओर बढ़ता है)। हमारे पास बहुत समान है। एक पूर्ण वस्तु के लिए। इस मामले को इंगित करने के लिए, निम्नलिखित सूचियों में, हम अधिक संक्षिप्त बिंदु अंकन पर आगे बढ़ेंगे। लेकिन OOP विरासत के बिना OOP नहीं है। इसे कैसे व्यवस्थित करें? हम एक ऐसा कार्य लिख सकते हैं जो माता-पिता के सभी गुणों को वंशज को कॉपी करेगा। इस तरह की विरासत को कैस्केडिंग कहा जाता है, लेकिन, सख्ती से बोलना, यह विरासत के बजाय क्लोनिंग है। माता-पिता के कार्यान्वयन में परिवर्तन किसी भी तरह से बच्चे को प्रभावित नहीं करेगा, इसके अलावा, यदि प्रत्येक बच्चे में माता-पिता के तरीकों की प्रतियां शामिल हैं, तो यह अत्यधिक मेमोरी खपत का कारण होगा। शायद बच्चे के गुणों में से किसी एक में माता-पिता के लिए लिंक रखना बेहतर होगा। हमें विरासत श्रृंखला के गुणों की खोज करने के लिए एक फ़ंक्शन की आवश्यकता है:

 //  6 function createObj(x, y) { var obj = {}; obj.x = x, obj.y = y, obj.foo = function () {return obj.x + obj.y;} return obj; } function createChild (parent) { var child = {}; child.__parent__ = parent; return child; } function lookupProperty (obj, prop) { if (prop in obj) return obj[prop]; else if (obj.__parent__) return lookupProperty (obj.__parent__, prop); } var a = createObj(1, 2); var b = createChild (a); console.log(lookupProperty(b, 'y')); // 2 console.log(lookupProperty(b, 'foo')()); // 3

यह एक आदेश प्रतीत होता है, लेकिन यदि हम वस्तु b बदलते हैं, उदाहरण के लिए जैसे: bx = 10 , तो हम देखेंगे कि यह वास्तव में काम करता है। foo() विधि अभी भी अपनी वस्तु के गुणों तक पहुंचती है, न कि उसके वंश की वस्तु। यदि हम विरासत में तरीकों का पुन: उपयोग करना चाहते हैं, तो हमें उन्हें यह सिखाने की आवश्यकता है कि अन्य लोगों की वस्तुओं के गुणों के साथ कैसे काम किया जाए। आप एक तर्क को उस विधि से पारित कर सकते हैं जो वर्तमान ऑब्जेक्ट को इंगित करता है। विधि के अंदर lookupProperty() फ़ंक्शन का उपयोग करना भी आवश्यक है, क्योंकि हम पहले से नहीं जानते हैं कि क्या x और y गुण वर्तमान ऑब्जेक्ट में परिभाषित किए गए हैं, या क्या उन्हें इनहेरिटेंस चेन को खोजना होगा या नहीं। createChild() और lookupProperty() फ़ंक्शन स्वयं अपरिवर्तित रहते हैं:

 //  7 function createObj(x, y) { var obj = {}; obj.x = x, obj.y = y, obj.foo = function (currentObj) { return lookupProperty(currentObj, 'x') + lookupProperty(currentObj, 'y'); } return obj; } function createChild (parent) { var child = {}; child.__parent__ = parent; return child; } function lookupProperty (obj, prop) { if (prop in obj) return obj[prop]; else if (obj.__parent__) return lookupProperty (obj.__parent__, prop); } var a = createObj(1, 2); var b = createChild (a); bx = 10; console.log(lookupProperty(b, 'y')); // 2 console.log(lookupProperty(b, 'foo')(b)); // 12

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

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

फिर, createObj() और createChild() फ़ंक्शन को createChild() - वे बहुत समान हैं। दोनों प्रवेश पर एक अस्थायी वस्तु बनाते हैं और इसे बाहर निकलने पर वापस करते हैं। हम संयुक्त फ़ंक्शन को रूट ऑब्जेक्ट Object । यह दो तर्क लेगा - मूल वस्तु और वह वस्तु जो माता-पिता से वंश के अंतर का वर्णन करती है (इस दृष्टिकोण को अंतर या अंतर विरासत भी कहा जाता है)।

अंत में, प्रत्येक विधि कॉल के साथ तर्कों के माध्यम से वर्तमान वस्तु को पारित नहीं करने के लिए, हम स्वचालित रूप से उस वस्तु का संदर्भ प्रदान करेंगे, जिसके लिए विधि संबंधित है। इसे OOP परंपरा के अनुसार कहते हैं:

 //  8 var a = Object.create(null, { x: {value: 1}, y: {value: 2}, foo: {value: function() { return this.x + this.y; } } }); var b = Object.create(a, {x: {value: 10}}); console.log(b.x+', '+b.y+', '+b.foo()); // 10, 2, 12

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

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

सूची में लौटना 7. वंशानुक्रम योजना में कंस्ट्रक्टर्स में प्रवेश करने के लिए, याद रखें कि जावास्क्रिप्ट में, फंक्शन्स सहित सब कुछ एक वस्तु है। अर्थात्, हम साधारण वस्तुओं की तरह कार्यों में भी गुण जोड़ सकते हैं। एक prototype गुण जोड़ें जो फ़ंक्शन को एक निर्माता के रूप में कॉल करने के मामले में बनाई गई ऑब्जेक्ट के प्रोटोटाइप को इंगित करेगा। फिर, जैसा कि सूची 8 में है, हम अस्थायी चर का नाम बदल देते हैं, child और currentObj लिए this , उनकी घोषणा को छिपाने और दुभाषिया के अंदर लौटने के लिए, और lookupProperty() हटा दें। चूंकि प्रत्येक निर्माता एक विशिष्ट प्रकार की वस्तु बनाता है, एक सार्वभौमिक विधि का उपयोग करता है जैसे Object.create() अर्थहीन है, इसलिए हम डिजाइनरों को उनके द्वारा बनाई गई वस्तुओं के प्रकार के अनुसार कहेंगे, लेकिन एक बड़े अक्षर के साथ, ताकि साधारण कार्यों के साथ भ्रमित न हों। दुभाषिया को यह बताने के लिए कि हम फ़ंक्शन को एक निर्माता के रूप में कॉल करना चाहते हैं, उसके नाम के सामने new कीवर्ड जोड़ें। यहाँ हमें क्या मिलता है:

 //  9 function A(x, y) { this.x = x, this.y = y, this.foo = function () { return this.x + this.y; } }; function B () {}; B.prototype = new A(1, 2); var b = new B(); console.log(b.x+', '+b.y+', '+b.foo()); // 1, 2, 3

कंस्ट्रक्टर + प्रोटोटाइप जोड़ी (इस उदाहरण में: B()+B.prototype ) क्लासिक B()+B.prototype में वर्ग के समान भूमिका निभाता है। ध्यान दें कि लिस्टिंग 8 में, वस्तु पूरी तरह से b से विरासत में मिलती है, और 9 की सूची में, हमें पूरी तरह से एक चर से छुटकारा मिल गया, जिसका अर्थ है कि हमें A() निर्माणकर्ता की आवश्यकता नहीं है। गुण x और y , जो प्रत्येक ऑब्जेक्ट के लिए अलग-अलग होते हैं, उन्हें कंस्ट्रक्टर B में सेट किया जा सकता है, और प्रोटोटाइप में सभी के लिए सामान्य विधि foo() :

 //  10 function B (x, y) { this.x = x, this.y = y }; B.prototype.foo = function () { return this.x + this.y; } var b = new B(1, 2); console.log(b.x+', '+b.y+', '+b.foo()); // 1, 2, 3

Object.create() लिए एक ही बात Object.create() :

 //  11 var B = { foo: function() { return this.x + this.y; } }; var b = Object.create(B, {x: {value: 10}, y: {value: 20}}); console.log(b.x+', '+b.y+', '+b.foo()); // 10, 20, 30

निष्कर्ष

1. जावास्क्रिप्ट प्रोग्राम को इंटरप्रेटर की तीन मुख्य डेटा संरचनाओं द्वारा निष्पादित किया जाता है - कॉल स्टैक, स्कोप चेन और इनहेरिटेंस चेन। ढेर सबसे पुराना और सबसे आदिम संरचना है। यह सख्ती से रैखिक है ( हालांकि विकल्प संभव हैं ... ), लेकिन यह त्वरित और सरल है। अंतिम दो संरचनाएं जंजीरों की तुलना में पेड़ों से मिलती जुलती हैं, लेकिन चूंकि प्रत्येक कार्य केवल एक ही समय में किया जाता है, और यह केवल इन पेड़ों के माध्यम से ऊपर की ओर बढ़ सकता है, इसके दृष्टिकोण से, ये श्रृंखलाएं हैं।

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

3. वंशानुक्रम ट्री ऑब्जेक्ट ऑब्जेक्ट (यूपीडी: से बढ़ता है: वास्तव में, यह शून्य से बढ़ता है। चूंकि यह ऑब्जेक्ट, इसे हल्के ढंग से डालने के लिए, बहुत जानकारीपूर्ण नहीं है, आमतौर पर इसे ध्यान में नहीं रखा जाता है। सुधार के लिए धन्यवाद azproduction )। वंशानुक्रम वृक्ष का मुख्य उद्देश्य प्रोटोटाइप श्रृंखला के गुणों की खोज करना है, यदि संपत्ति स्वयं वस्तु में नहीं है, तो हमारे उदाहरण में लुकप्रोपर्टी () ने क्या किया। EcmaScript मानक में, यह [[प्राप्त करें]] विधि है । कई कार्यान्वयन में मूल ऑब्जेक्ट (__parent__ को 6 और 7 में) का संदर्भ __proto__ कहा जाता है और प्रोग्रामर के लिए उपलब्ध है। लेकिन इसका उपयोग बुरा रूप माना जाता है। भाषा मानक माता-पिता को बदलने की क्षमता के लिए प्रदान नहीं करता है, जैसा कि हमारे घर में विरासत में लागू किया गया है। Object.prototyp और Object .__ proto__ पूरी तरह से अलग चीजें हैं। Object.prototype का उपयोग केवल एक फ़ंक्शन को कंस्ट्रक्टर के रूप में कॉल करने पर किया जाता है और लौटे ऑब्जेक्ट के प्रोटोटाइप को सेट करता है।

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

5. यह कीवर्ड वर्तमान ऑब्जेक्ट को इंगित करता है, जो ऑब्जेक्ट कंस्ट्रक्टर और विधियों के मामले में बहुत स्पष्ट है। फ़ंक्शन कॉल के मामले में ऑब्जेक्ट विधि के रूप में नहीं, यह वैश्विक ऑब्जेक्ट के लिए डिफ़ॉल्ट है। हालाँकि इसके द्वारा बताई गई वस्तुओं का निर्माण, संचरण और वापसी इंटरप्रेटर के अंदर छिपी हुई है, लिस्ट 7 से करंटऑबज वैरिएबल के कान कॉल () और लागू () विधियों में बने रहते हैं: इन विधियों का पहला तर्क फ़ंक्शन के अंदर दिखाई देगा, जिसे इस तरह बुलाया जा रहा है।

अतिरिक्त साहित्य की सूची

जावास्क्रिप्ट बंद
जावास्क्रिप्ट। कोर
ECMA-262-3 की सूक्ष्मता। शॉर्ट सर्किट।
इसका उपयोग करने की सूक्ष्मता
ECMA-262-5 विस्तार से। लेक्सिकल वातावरण: सामान्य सिद्धांत
ऑब्जेक्ट ग्राफ़ के साथ जावास्क्रिप्ट सीखना: भाग 1 , भाग 2 , भाग 3
ऑब्जेक्ट ओरिएंटेड सी (पीडीएफ)
जावास्क्रिप्ट मूल बातें और गलत धारणाएँ

क्लोजर और जावास्क्रिप्ट ऑब्जेक्ट। दुभाषिया को फिर से लगाना

प्रथम श्रेणी की विशेषताएं

इनकैप्सुलेशन और इनहेरिटेंस

निष्कर्ष

अतिरिक्त साहित्य की सूची

More articles: