👈🏿 🥒 🐅 जावास्क्रिप्ट तरीके 🌧️ 🥐 🥁

हर दिन, हर जावास्क्रिप्ट प्रोग्रामर को पता चलता है कि जेएस एक वस्तु-उन्मुख भाषा है। और यहां, वह इस तथ्य की गलतफहमी से उत्पन्न होने वाले कुछ खतरों का सामना करता है कि जेएस कक्षाओं की भाषा नहीं है (जैसे पास्कल या त्से-दो-क्रॉस), लेकिन प्रोटोटाइप।

तो, पहले से ही विरासत की समस्या के बारे में बहुत कुछ लिखा गया है (जो जेएस में नहीं है)। मैं कम प्रबुद्ध, लेकिन लगभग अधिक महत्वपूर्ण नुकसान के बारे में बात करने की कोशिश करूंगा: विधियों का सक्षम कार्यान्वयन।

प्रोग्रामर कक्षाओं को उनसे परिचित रूप में घोषित करने का प्रयास करते हैं, जिससे मेमोरी लीक और अन्य अप्रिय चीजें होती हैं। वास्तव में, आपको केवल यह जानने की आवश्यकता है कि प्रोटोटाइप का उपयोग कैसे करें।

यह लेख मुख्य रूप से शुरुआती जेएस प्रोग्रामर के लिए है।

नीचे मैं "क्लास" की अवधारणा का उपयोग उस अर्थ में करूँगा जिसमें इसे पास्कल या टेस-टू-क्रॉस में समझा जाता है; भले ही जेएस में ऐसी कक्षाएं नहीं हैं, आम तौर पर बोलना, कुछ चीजें बहुत ही समान रूप और अर्थ में हैं।

शुरू से ही, दो बुनियादी बातें हर किसी के लिए जानी जाती हैं:

क्लास को एक कंस्ट्रक्टर फ़ंक्शन द्वारा वर्णित किया जाता है;
तरीके फ़ंक्शन गुण हैं।

इसलिए, प्रोग्रामर बहुत स्वाभाविक रूप से लिखना शुरू करते हैं:

function Test(){ //     this.x=5; this.y=3; //   this.sum=function(){ return this.x+this.y; } //     alert("Constructor: x="+this.x+", y="+this.y+", sum="+this.sum()); }

उसके बाद, ऐसा लगता है कि हमें वही मिलता है जो हम चाहते थे: हम दो गुण x (मूल रूप से 5) और y (मूल रूप से 3) और योग विधि के साथ टेस्ट क्लास प्राप्त करते हैं, जो x और y के योग की गणना करता है। निर्माण करते समय, एक्स, खिलाड़ी और योग वाला एक ईलेट प्रदर्शित किया जाता है।

लेकिन वास्तव में क्या होता है? टेस्ट ऑब्जेक्ट का निर्माण करते समय, टेस्ट फ़ंक्शन को हर बार कहा जाता है। और हर बार यह एक नया अनाम फ़ंक्शन बनाता है और इसे योग संपत्ति में असाइन करता है! परिणामस्वरूप , प्रत्येक ऑब्जेक्ट अपनी अलग विधि योग बनाता है । यदि हम एक सौ टेस्ट ऑब्जेक्ट बनाते हैं, तो हम मेमोरी में सौ सौ कार्य करते हैं।

जाहिर है, यह नहीं किया जा सकता है। और जितनी जल्दी हो सके इसे महसूस करना महत्वपूर्ण है।

इस तथ्य को समझने के बाद, नौसिखिए प्रोग्रामर अक्सर निम्नलिखित कार्य करते हैं: वे अलग से राशि समारोह बनाते हैं, और निर्माणकर्ता इसे संपत्ति के लिए असाइन करते हैं:

  function Test(){ //     this.x=5; this.y=3; //   this.sum=Test_sum; //     alert("Constructor: x="+this.x+", y="+this.y+", sum="+this.sum()); } //   function Test_sum(){ return this.x+this.y; }

परिणामस्वरूप, वास्तव में, Test_sum फ़ंक्शन केवल एक बार बनाया जाता है, और हर बार एक नई टेस्ट ऑब्जेक्ट का निर्माण किया जाता है, केवल योग लिंक बनाया जाता है।

इसी समय, यह एक अनपढ़ विकल्प है। जावास्क्रिप्ट के मूल के उपयोग से सब कुछ बहुत अधिक खूबसूरती से और सही तरीके से किया जा सकता है: प्रोटोटाइप:

  function Test(){ //     this.x=5; this.y=3; //     alert("Constructor: x="+this.x+", y="+this.y+", sum="+this.sum()); } //   Test.prototype.sum=function(){ return this.x+this.y; }

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

  function Test(){ //     alert("Constructor: x="+this.x+", y="+this.y+", sum="+this.sum()); } // , ,     Test.prototype.x=5; Test.prototype.y=3; Test.prototype.sum=function(){ return this.x+this.y; }

बुरी बात यह है कि गुण और विधियों की घोषणाएं निर्माणकर्ता में उपयोग किए जाने के बाद जाती हैं। लेकिन आपको इसे साथ रखना होगा ...

Test.prototype के एकाधिक पुनरावृत्ति भी यहां अप्रिय है। कुछ दृष्टिकोण से, यह याद रखना अच्छा होगा कि JS Tse-two-cross नहीं है, और हमारे पास एक प्रस्ताव है। दूसरी ओर, कई प्रतिष्ठित लोग इसके साथ उपयोग करने की सलाह नहीं देते हैं। इसलिए, निम्न विकल्पों का उपयोग नहीं किया जाना चाहिए ।

सचमुच, एक अप्रिय आश्चर्य हमें इंतजार कर रहा है: यह कोड काम नहीं करता है।

  function Test(){ //     alert("Constructor: x="+this.x+", y="+this.y+", sum="+this.sum()); } // , ,     with(Test.prototype){ x=5; y=3; sum=function(){ return this.x+this.y; } }

क्यों यह काम नहीं करता है किसी तरह से एक रहस्य है। यह पसंद है या नहीं, शब्द प्रोटोटाइप को दोहराना होगा:

  function Test(){ //     alert("Constructor: x="+this.x+", y="+this.y+", sum="+this.sum()); } // , ,     with(Test){ prototype.x=5; prototype.y=3; prototype.sum=function(){ return this.x+this.y; } }

यहां लाभ टेस्ट कंस्ट्रक्शन की पूरी फिलिंग की घोषणाओं को एक ब्लॉक में बांटने में है - शेष कंस्ट्रक्टर के अपवाद के साथ। लेकिन इससे निपटा जा सकता है यदि आप याद रखें कि एक फ़ंक्शन को कम से कम तीन सिंटैक्स के माध्यम से घोषित किया जा सकता है:

  with(Test=function(){ //     alert("Constructor: x="+this.x+", y="+this.y+", sum="+this.sum()); }){ //     prototype.x=5; prototype.y=3; //   prototype.sum=function(){ return this.x+this.y; } }

परिणाम लगभग प्राकृतिक रिकॉर्ड है जिसकी हमने शुरुआत की थी, जब तक कि इस शब्द को प्रोटोटाइप के साथ बदल नहीं दिया गया था ; ठीक है, वे शुरुआत में "अन्य रचनात्मक कार्यों" में चले गए - जैसा कि मैंने कहा, दुर्भाग्य से, हमें इसके साथ काम करना होगा।

हालांकि, यदि गुण और विधियों को बनाने के अलावा निर्माणकर्ता से कुछ भी आवश्यक नहीं है, तो सुंदरता पूरी तरह से प्राप्त की जाती है:

  with(Test=new Function){ //     prototype.x=5; prototype.y=3; //   prototype.sum=function(){ return this.x+this.y; } }

हालांकि, यह मत भूलो कि खंड के साथ अनुशंसित नहीं है। इसलिए, अंत में, हम घोषणा के तीसरे संस्करण पर ध्यान केंद्रित करेंगे।

जावास्क्रिप्ट तरीके

More articles: