"यह सरल के बारे में कठिन है।" निर्माता वस्तुओं के रूप में कार्य करता है, (प्रोटोटाइप)। ऑब्जेक्ट्स, (__ proto__)। कंस्ट्रक्टर, {{}, एक कंस्ट्रक्टर फंक्शन न्यू ऑब्जेक्ट () के रूप में

पिछली बार हमने निम्नलिखित चीजों का पता लगाने की कोशिश की थी:

• 1. पारंपरिक ज्ञान के बावजूद "जेएस में सब कुछ एक वस्तु है" - ऐसा नहीं है, हमने पाया कि एक प्रोग्रामर के पास उपलब्ध 6 डेटा प्रकारों में से 5 प्राइमेटिव हैं और केवल एक ऑब्जेक्ट प्रकार का प्रतिनिधित्व करता है।
• 2. हमने वस्तुओं के बारे में सीखा कि यह एक ऐसी डेटा संरचना है जिसमें कुंजी-मूल्य जोड़े हैं। मान डेटा प्रकारों में से कोई भी हो सकता है (और यह ऑब्जेक्ट की संपत्ति होगी) या एक फ़ंक्शन (और यह ऑब्जेक्ट की विधि होगी)।
• 3. लेकिन आदिम वस्तुएं नहीं हैं। यद्यपि आप उनके साथ एक वस्तु के रूप में काम कर सकते हैं (और यह भ्रामक है कि आदिम एक वस्तु है), लेकिन ...
• 4. चर को सरल (शाब्दिक रूप से) (var a = 'str') और कंस्ट्रक्टर फ़ंक्शन (आवरण) (var a = new String ('str')) के माध्यम से घोषित किया जा सकता है। दूसरे मामले में, हमें अब एक आदिम नहीं मिलेगा, लेकिन स्ट्रिंग () निर्माता द्वारा बनाई गई एक वस्तु। (किस तरह का मैजिक ऑपरेटर नया है और एक कंस्ट्रक्टर फंक्शन क्या है यह हम बाद में पता लगाएंगे)।
• 5. हमने सीखा कि यह आदिम (नई स्ट्रिंग ('स्ट्र')) पर एक आवरण बनाकर है जिसे आप एक वस्तु की तरह काम कर सकते हैं। यह आवरण है कि दुभाषिया आदिम के चारों ओर बनाता है जब हम एक वस्तु के रूप में इसके साथ काम करने की कोशिश करते हैं, लेकिन ऑपरेशन पूरा होने के बाद, यह नष्ट हो जाता है (इसलिए, आदिम कभी भी उस संपत्ति को याद नहीं कर पाएगा जिसे हम इसे a.test = 'test' पर असाइन करेंगे - परीक्षण संपत्ति आवरण के साथ गायब हो जाएगी )।
• 6. हमने पाया है कि वस्तुओं में एक toString () विधि होती है जो ऑब्जेक्ट के एक स्ट्रिंग प्रतिनिधित्व (प्रकार संख्या valueOf के लिए) लौटाती है (यह एक संख्यात्मक मान लौटाएगा)।
• 7. हमने महसूस किया कि जब संक्रिया संचालन या गणितीय संक्रियाएं करते हैं, तो आदिम अपने प्रकार को वांछित प्रकार में पुनर्परिभाषित कर सकते हैं। ऐसा करने के लिए, वे अपने प्रकार के आवरण कार्यों का उपयोग करते हैं, लेकिन नए ऑपरेटर (str = String (str)) के बिना (क्या अंतर है और यह कैसे काम करता है, हम और अधिक बात करेंगे)
• 8. और अंत में, हमने सीखा कि टाइपोफ एक कठिन-निश्चित तालिका से मान लेता है (यह वह जगह है जहां टाइपो नल के आधार पर एक और गलतफहमी // वस्तु से आती है)।

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

उदाहरण 1:

function A() {} A.prototype.x = 10; a = new A(); console.log(ax); //10 console.log(ay); //undefined A.prototype.y = 20; console.log(ay); //20 /*     A.prototype.<>           */ 2: function B() {} B.prototype.x = 10; b = new B(); console.log(bx); //10 console.log(by); //undefined B.prototype = {constructor:B, x:10, y:20}; console.log(bx); //10 console.log(by); //undefined /*    B.prototype = {constructor:B, x:10, y:20};         */ b1 = new B(); console.log(b1.x); //10 console.log(b1.y); //20 /*       */ b instanceof B; //false b1 instanceof B //true /*          */ 

कंस्ट्रक्टर फ़ंक्शंस, ऑब्जेक्ट्स, प्रोटोटाइप के रूप में।

चलिए शुरू करते हैं। कोड की एक सरल रेखा पर विचार करें।

 function A() {} 

बहुत ही पहली बात जो आप कह सकते हैं: "हमने ए नाम के एक फ़ंक्शन की घोषणा की है"। यह सही है। लेकिन बारीकियां हैं।
1. जेएस में यह मत भूलो - लगभग सब कुछ एक वस्तु है। एक फ़ंक्शन, जैसा कि यह निकला, कोई अपवाद नहीं है (ये एक लिंक द्वारा जुड़ी दो वस्तुएं भी हैं)।
2. इसका इस्तेमाल कंस्ट्रक्टर फंक्शन के रूप में किया जा सकता है।
जावास्क्रिप्ट में वह नहीं है जिसे आमतौर पर कक्षाएं कहा जाता है। जावास्क्रिप्ट में कक्षाएं निर्माण कार्यों द्वारा की जाती हैं जो कुछ निर्दिष्ट गुणों के साथ वस्तुओं का निर्माण करती हैं।
सामान्य तौर पर, JS में कोई भी फंक्शन ऑब्जेक्ट कंस्ट्रक्टर हो सकता है (मैं उपयोगकर्ता-परिभाषित कार्यों के बारे में बात कर रहा हूं)। उन्हें सशर्त रूप से तीन (DF (फंक्शन डिक्लेरेशन), FE (फंक्शन एक्सप्रेशन), फ़ंक्शन (फंक्शन) द्वारा बनाए गए फंक्शन) में विभाजित किया जा सकता है। इन सभी कार्यों की अपनी ख़ासियतें हैं (इसलिए उन्हें अलग-अलग समूहों में विभाजित किया गया है), लेकिन मैं उनके बारे में यहां बात नहीं करता, अगर किसी को दिलचस्पी है तो मैं व्यक्तिगत रूप से जवाब दूंगा या उनके बारे में अलग से लिखूंगा। हालांकि, उनके पास एक चीज सामान्य है जो उन्हें निर्माणकर्ता बनने की अनुमति देती है - आंतरिक [[निर्माण]] और [[कॉल]] गुणों की उपस्थिति, साथ ही साथ स्पष्ट प्रोटोटाइप संपत्ति (इसके बारे में नीचे)।
यह आंतरिक विधि [[निर्माण]] है जो एक नई वस्तु के लिए स्मृति आवंटित करने और इसके प्रारंभ के लिए जिम्मेदार है। हालांकि, इसका मतलब यह नहीं है कि एक फ़ंक्शन कॉल ऑब्जेक्ट के निर्माण की ओर ले जाएगा, निश्चित रूप से नहीं। ऐसा करने के लिए, फ़ंक्शन को कॉल करने से पहले नए ऑपरेटर को कॉल करें। यह नया है जो [[निर्माण]] विधि और संबंधित प्रक्रियाओं को लॉन्च करता है।

 function A(){} A(); //   var a = new A(); // -.  (a)  - (A) 

3. आप यह भी कह सकते हैं कि यह एक फ़ंक्शन घोषणा (DF) और इसी तरह है, लेकिन बाकी अभी तक महत्वपूर्ण नहीं है।

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



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

 function A(){} var a = new A(); 

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

ऑब्जेक्ट्स (__ proto__)।

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



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

समेकित करने के लिए, आइए एक उदाहरण पर विचार करने का प्रयास करें:

 function A() {} //  - (  «» prototype) A.prototype.x = 10;//    prototype(    )  (x)  10 a = new A(); //     __proto__     prototype  (x==10) console.log(ax); // (x)       (a),     __proto__      prototype. console.log(ay); //   (y)     . A.prototype.y = 20; //   (y)  prototype(     ) console.log(ay); //20 //        __proto__  

निर्माता।

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



सब कुछ जो ग्रे में चित्रित किया गया है, हमें अभी इसकी आवश्यकता नहीं है - यह अधिक संपूर्ण चित्र के लिए है। आइए कंस्ट्रक्टर संपत्ति पर ध्यान दें। जैसा कि आप आंकड़ा से देख सकते हैं, कंस्ट्रक्टर खुद ही निर्माता फ़ंक्शन को इंगित करता है जिसके लिए यह "रिपॉजिटरी", यह ऑब्जेक्ट, मूल रूप से बनाया गया था। यही है, कंस्ट्रक्टर फ़ंक्शन की प्रोटोटाइप संपत्ति और प्रोटोटाइप ऑब्जेक्ट की कंस्ट्रक्टर संपत्ति के बीच, चक्रीयता दिखाई देती है - वे एक-दूसरे की वस्तुओं की ओर इशारा करते हैं।
कंस्ट्रक्टर संपत्ति का उपयोग करना (यदि यह अभी भी निर्माता को इंगित करता है, और कंस्ट्रक्टर की प्रोटोटाइप संपत्ति, बदले में, अभी भी मूल प्रोटोटाइप को इंगित करता है), तो आप अप्रत्यक्ष रूप से ऑब्जेक्ट प्रोटोटाइप का संदर्भ प्राप्त कर सकते हैं: a.constructor .prototyp.x। और आप कंस्ट्रक्टर फ़ंक्शन के लिए एक लिंक प्राप्त कर सकते हैं और इसके गुण जो प्रोटोटाइप ऑब्जेक्ट को नहीं, बल्कि विशेष रूप से इसे सौंपे गए थे। उदाहरण के लिए:

 function A(){} A.own = 'I am A!'; //     —        a = new A(); a.own //undefined a.constructor.own // 'I am A!'; 

= {} - एक रचनाकार फ़ंक्शन (नई वस्तु ()) के रूप में।

महान, ऐसा लगता है कि सब कुछ जगह में गिर गया। एक "सामान्य संग्रहण" है, माता-पिता और बच्चे के पास इस भंडारण के लिंक हैं, यदि संपत्ति उदाहरण में ही नहीं है, तो दुभाषिया "आम भंडारण" में देखने के लिए लिंक पर क्लिक करेगा। पकड़ क्या है ?? आइए देखें उदाहरण 2:

 function B() {} B.prototype.x = 10; b = new B(); console.log(bx); //10 console.log(by); //undefined B.prototype = {constructor:B, x:10, y:20}; console.log(bx); //10 console.log(by); //undefined 

ऐसा लगता है जैसे सब कुछ काम करना चाहिए। हमने एक कंस्ट्रक्टर फ़ंक्शन बनाया, "कॉमन स्टोरेज" (प्रोटोटाइप (लिंक के माध्यम से)) प्रॉपर्टी (x) सेट किया, एक उदाहरण बनाया, इसमें प्रॉपर्टी (x) है - सब कुछ ठीक है। फिर हमने आम तौर पर प्रोटोटाइप मूल संपत्ति को फिर से परिभाषित किया, गुण (x) और (y) को जोड़कर सही निर्माता का संकेत दिया। सब कुछ इन दोनों गुणों के "साझा भंडार" में काम करना चाहिए, लेकिन नहीं, (y) दुभाषिया इसे नहीं ढूंढता है। WTF?!?

यहां किस तरह का जादू चल रहा है? हम इन परिवर्तनों को इस निर्माता के वंशज से क्यों नहीं देखते हैं? वंशज क्यों नहीं देखता y? खैर, सबसे पहले, हम कंस्ट्रक्टर फ़ंक्शन (बी) की प्रोटोटाइप संपत्ति को ओवरराइड करते हैं और यह नई ऑब्जेक्ट (मूल प्रोटोटाइप ऑब्जेक्ट के साथ कनेक्शन टूट गया है) को संदर्भित करना शुरू कर देता है। दूसरे, वस्तु चर के सामान्य असाइनमेंट, जैसे: दुभाषिया द्वारा var = a {{}, वास्तव में var a = new Object () के रूप में किया जाता है। और इसका मतलब यह है कि कंस्ट्रक्टर फ़ंक्शन की प्रोटोटाइप संपत्ति में अब एक पूरी तरह से नई वस्तु शामिल है, जिसके लिए कंस्ट्रक्टर लिंक गायब है और इसलिए माता-पिता को नहीं खोना है, हम स्वतंत्र रूप से निर्माणकर्ता संपत्ति को वहां जोड़ते हैं और माता-पिता को असाइन करते हैं।
और पहले किए गए उदाहरण में पुराने प्रोटोटाइप ऑब्जेक्ट के लिए एक लिंक __proto__ शामिल है जहां कोई संपत्ति (y) नहीं है। अर्थात्, उदाहरण 1 के विपरीत, यहां हमने "संपत्ति को भंडार में नहीं जोड़ा" और "पुन: भंडार को फिर से लिखना" भी नहीं किया, हमने बस एक नया बनाया, पुराने से संबंध तोड़ दिया, और उदाहरण इसके बारे में कुछ भी नहीं जानता है, यह अभी भी अपने पुराने में पुराने का उपयोग करता है लिंक __proto__। यह इस तरह दिखता है:



काले रंग में - यह कुछ ऐसा है जो B.prototyp = {constructor: B, x: 10, y: 20} के बाद नहीं बदला है;
लाल - क्या गया
हरा - क्या जोड़ा गया है

तुम भी Instof के बारे में थोड़ा जोड़ सकते हैं। विचित्र रूप से पर्याप्त है, इस उदाहरण में, बी 1 निर्माण फ़ंक्शन बी से संबंधित होगा, और बी नहीं होगा। सब कुछ बहुत सरल है। तथ्य यह है कि उदाहरण के लिए निम्न स्थिति की तलाश है - कि लिंक __proto __ द्वारा निर्दिष्ट वस्तु (श्रृंखला के किसी भी स्तर पर) (संख्या 1 के साथ सर्कल) वांछित माता-पिता की प्रोटोटाइप संपत्ति द्वारा संदर्भित वस्तु के बराबर है (संख्या 2 के साथ सर्कल) (आंकड़े में काले की तुलना करें) रंग और हरा)। काले रंग में यह स्थिति पूरी नहीं होती है, और हरे रंग में यह संतुष्ट है।
हमारे मामले में, उदाहरण के लिए (बी) यह कनेक्शन टूट गया है, क्योंकि वांछित माता-पिता (बी) की नई प्रोटोटाइप संपत्ति पहले से ही नई वस्तु को संदर्भित करती है, और पहले की तरह नहीं। लेकिन इसके साथ उदाहरण (b1) जैसा कि हम देखते हैं कि सब कुछ क्रम में है।

के बाद

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

 function A(str){ this.val = str; } a = new A('test'); //  val   ,        this       A('test'); //  this —   .       val console.log(val) //'test' 

यह कैसे पता करें कि फ़ंक्शन को कैसे कहा गया था? नया है या नहीं? यह बहुत सरलता से किया जाता है:

 function A(str){ if( this instanceof A) // this   A(    new) this.val = str; //   val else retur str; //(     new)   } 

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

 function A(){} A.val = 'str'; 

यह संपत्ति वंशज के लिए सुलभ नहीं होगी, क्योंकि यह प्रोटोटाइप में झूठ नहीं बोलता है, और वंशज की पहुंच केवल वहीं तक है। लेकिन जैसा कि वे कहते हैं "यदि आप वास्तव में चाहते हैं, तो आप कर सकते हैं।" यह वह जगह है जहां प्रोटोटाइप ऑब्जेक्ट - कंस्ट्रक्टर की संपत्ति काम में आती है। जैसा कि हम याद करते हैं, यह फ़ंक्शन को संदर्भित करता है (जब तक कि निश्चित रूप से इसे विशेष रूप से नहीं बदला गया है)। फिर, वैरिएबल वैल प्राप्त करने के लिए, आपको इसे इस तरह एक्सेस करने की आवश्यकता है:

 function A(){} A.val = 'str'; a = new A(); a.constructor.val; //'str' 

सूत्रों का कहना है:
https://developer.mozilla.org
http://dmitrysoshnikov.com/
http://javascript.ru