क्या जावास्क्रिप्ट को कक्षाओं की आवश्यकता है?

जावास्क्रिप्ट को एक प्रोटोटाइप-उन्मुख प्रोग्रामिंग भाषा माना जाता है। लेकिन, अजीब तरह से, लगभग कोई भी इस दृष्टिकोण का उपयोग नहीं करता है: सबसे लोकप्रिय जेएस फ्रेमवर्क स्पष्ट रूप से या अंतर्निहित रूप से कक्षाओं पर काम करते हैं।
PLO का शुद्ध प्रोटोटाइप और ECMA स्क्रिप्ट 5 पर इसके कार्यान्वयन के peculiarities - इस अनुच्छेद में मैं वर्गों और निर्माताओं के उपयोग के बिना, जावास्क्रिप्ट में प्रोग्रामिंग का एक वैकल्पिक पद्धति के बारे में बात करना चाहते हैं।

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

इस वर्गीकरण के अनुसार, जावास्क्रिप्ट कहीं बीच में है: एक तरफ, इसमें प्रोटोटाइप हैं, दूसरे पर - कक्षाएं और नए ऑपरेटर, नई वस्तुओं को बनाने के साधन के रूप में, जो प्रोटोटाइप-उन्मुख दृष्टिकोण की विशेषता नहीं है।

कक्षाएं

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

जैसा कि आप जानते हैं , ECMA स्क्रिप्ट 6 में class कीवर्ड को पेश करना संभव है:

  class Duck{ constructor(name){ this.name = name; }, quack(){ return this.name +" Duck: Quack-quack!"; } } ///  class TalkingDuck extends Duck{ constructor(name){ super(name); }, quack(){ return super.quack() + " My name is " + this.name; } } ///  var donald = new TalkingDuck("Donald"); 

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

  var Duck = function(name){ this.name = name; }; Duck.prototype.quack = function(){ return this.name +" Duck: Quack-quack!"; }; ///  var TalkingDuck = function(name){ Duck.call(this, name); } TalkingDuck.prototype = Object.create(Duck.prototype); TalkingDuck.prototype.constructor = TalkingDuck; TalkingDuck.prototype.quack = function(){ return Duck.prototype.quack.call(this) + " My name is " + this.name; }; ///  var donald = new TalkingDuck("Donald"); 

इसलिए, जेएस के वर्तमान संस्करण में पहले से ही कक्षाएं हैं, लेकिन उन्हें बनाने के लिए कोई सुविधाजनक वाक्यविन्यास नहीं है ।
अंत में, आइए तय करें कि एक वर्ग क्या है। यहाँ परिभाषा है ( विकिपीडिया से ):

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

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

प्रोटोटाइप

प्रोटोटाइप उस वर्ग से भिन्न होता है:

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

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

विरासत

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

  var duck$ = {// "$"      "": duck$ == Duck.prototype name: "", quack: function(){ return this.name +" Duck: Quack-quack!"; } }; var donald = { __proto__: duck$, name: "Donald" }; var daffy = { __proto__: duck$, name: "Daffy" }; console.log( donald.quack() ); // Donald Duck: Quack-quack! console.log( daffy.quack() ); // Daffy Duck: Quack-quack! console.log( duck$.isPrototypeOf(donald) ); // true 

daffy और donald एक सामान्य quack() पद्धति का उपयोग करते हैं, जो उन्हें डक $ प्रोटोटाइप प्रदान करता है। एक प्रोटोटाइप की दृष्टि से donald और daffy वस्तु के क्लोन कर रहे हैं duck$ , और एक वर्ग उन्मुख - "वर्ग के उदाहरण" duck$ ।
यदि आप सीधे donald (या daffy ) daffy में कुछ गुण जोड़ते / बदलते हैं, तो इसे "वर्ग का उत्तराधिकारी" duck$ भी माना जा सकता है। V8 बस यही करता है , हर बार प्रॉपर्टी में छिपे वर्गों को जोड़कर।

यह मत भूलो कि __proto__ संपत्ति अभी तक मानकीकृत नहीं है। आधिकारिक तौर पर संपत्ति में हेरफेर __proto__ संभव ECMAScript 5 तरीकों Object.create और Object.getPrototypeOf :

  var donald = Object.create(duck$, { name: {value: "Donald"} }); console.log( Object.getPrototypeOf(donald) === duck$ ); // true }  var donald = Object.create(duck$, { name: {value: "Donald"} }); console.log( Object.getPrototypeOf(donald) === duck$ ); // true 

प्रारंभ

क्लास-ओरिएंटेड दृष्टिकोण के विपरीत, एक प्रोटोटाइप (क्लोनिंग) के आधार पर ऑब्जेक्ट बनाते समय एक कंस्ट्रक्टर और इसकी कॉल की उपस्थिति वैकल्पिक है।
कैसे, तो एक ऑब्जेक्ट के गुणों को प्रारंभ?
गुणों के लिए सरल, गैर-गणना योग्य डिफ़ॉल्ट मान तुरंत प्रोटोटाइप को सौंपा जा सकता है:

 var proto = { name: "Unnamed" }; 

और अगर आपको गणना मूल्यों का उपयोग करने की आवश्यकता है, तो ECMA स्क्रिप्ट 5 के साथ हमारी सहायता के लिए आता है:

आलसी (देरी) प्रारंभ

आलसी इनिशियलाइज़ेशन एक ऐसी तकनीक है, जो आपको पहली बार किसी संपत्ति को एक्सेस करने की अनुमति देती है:

 var obj = { name: "", get lazy(){ console.log("  lazy..."); //  : var value = "   " + this.name; //  ,      //   ,    : Object.defineProperty(this, 'lazy', { value: value, writable: true, enumerable: true }); console.log(" ."); return value; }, //     // ,   - // (       ): set lazy(value){ console.log("  lazy..."); Object.defineProperty(this, 'lazy', { value: value, writable: true, enumerable: true }); } }; console.log( obj.lazy ); //   lazy... //     console.log( obj.lazy );//     //     obj.lazy = "";//   , ..    console.log( obj.lazy ); //  

इस तकनीक के फायदे में शामिल हैं:

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

तुलना तालिका

प्रोटोटाइप	कक्षा (ECMA स्क्रिप्ट 5)	कक्षा (ECMA स्क्रिप्ट 6)
डेटा प्रकार का विवरण ( "वर्ग")
var duck$ = { name: "Unnamed", get firstWords(){ var value = this.quack(); Object.defineProperty( this, 'firstWords', {value: value} ); return value; }, quack: function(){ return this.name +" Duck: Quack-quack!"; } };	var Duck = function(name){ this.name = name||"Unnamed"; this.firstWords = this.quack(); }; Duck.prototype.quack = function(){ return this.name +" Duck: Quack-quack!"; };	class Duck{ constructor(name="Unnamed"){ this.name = name; this.firstWords = this.quack(); }, quack(){ return this.name +" Duck: Quack-quack!"; } }
विरासत
var talkingDuck$ = Object.create(duck$, { quack: {value:function(){ return duck$.quack.call(this) + " My name is " + this.name; }} });	var TalkingDuck = function(name){ Duck.call(this, name); } TalkingDuck.prototype = Object.create(Duck.prototype); TalkingDuck.prototype.constructor = TalkingDuck; TalkingDuck.prototype.quack = function(){ return Duck.prototype.quack.call(this) + " My name is " + this.name; };	class TalkingDuck extends Duck{ constructor(name){ super(name); }, quack(){ return super.quack() + " My name is " + this.name; } }
उदाहरण वस्तुओं का निर्माण करना और आरंभ करना
var donald = Object.create(talkingDuck$); donald.name = "Donald";	var donald = new TalkingDuck("Donald");	var donald = new TalkingDuck("Donald");

भाग 2 - प्रदर्शन: __proto__ के माध्यम से कक्षाएं बनाना

---

प्रयुक्त साहित्य की सूची:
डॉ एक्सल रस्शमेयर - मिथक: जावास्क्रिप्ट को कक्षाओं की आवश्यकता है
अनातो तावलासारी - वर्ग बनाम प्रोटोटाइप: कुछ दार्शनिक और ऐतिहासिक अवलोकन [PDF]
माइक एंडरसन - कक्षा-आधारित ओओपी पर प्रोटोटाइप-आधारित ओओपी के लाभ