जावास्क्रिप्ट में OOP

मैं आपको createClass क्लास कंस्ट्रक्टर फ़ंक्शन से परिचित कराना चाहता हूं।
क्या इस निर्माता अच्छा है:
1. कोड स्वयं अधिक पठनीय और समझने योग्य लगता है
2. कई विरासत के लिए समर्थन
3. अमूर्त तरीकों के लिए समर्थन
4. स्थिर विधियों और वर्गीय गुणों का अनुरक्षण
5. चतुर उदाहरण (विधि) वर्गों की श्रृंखला में जाँच करता है

तो, तुरंत एक उदाहरण:

var Animal = createClass({ abstracts: ['say'], construct: function(name) { this.name = name; }, eat: function() { return 'ou yeah...'; } }); var Kitty = createClass({ extend: Animal, say: function() { return this.name + ' said: RrrrRRR...Mau..'; }, eat: function() { return Animal.fn.eat.call(this) + 'FISH!!' } }); var Doggy = createClass({ extend: Animal, construct: function(name) { Animal.call(this, name); console.log('doggy have been created'); }, say: function() { return this.name + ' said: GAV!'; }, eat: function() { return Animal.fn.eat.call(this) + 'MEAT!!' } }); var sharik = new Doggy('sharik'); // doggy have been created var murka = new Kitty('murka'); console.log( sharik.eat(), sharik.say()); // ou yeah...MEAT!! sharik said: GAV! console.log( murka.eat(), murka.say()); // ou yeah...FISH!! murka said: RrrrRRR...Mau.. 

सभी वर्ग गुणों को कंस्ट्रक्टर में परिभाषित किया जाना चाहिए (स्थिर कंस्ट्रक्टर में स्थिर गुण, जो नीचे चर्चा की जाएगी)।
पशु वर्ग में उक्त पद्धति का अमूर्तन है। किट्टी और डॉगी कक्षाएं पशु से विरासत में मिलती हैं और कहने की विधि को लागू करती हैं। उसी समय, चूंकि कंस्ट्रक्टर को किट्टी में स्पष्ट रूप से परिभाषित नहीं किया गया है, इसलिए इसे पशु से उधार लिया गया है। डॉगी में, कंस्ट्रक्टर को स्पष्ट रूप से परिभाषित किया जाता है, इसलिए पेरेंट कंस्ट्रक्टर को एनिमल.कॉल (यह, नाम) में स्पष्ट रूप से बुलाया जाना चाहिए। मूल वर्ग की खाने की विधि को Animal.fn.eat.call कहा जा सकता है (यह) Animal.prototyp.eat.call (यह) के समान है

अगले:

 var Singleton = createClass({ statics: { construct: function() { this._instance = null; }, getInstance: function() { if(this._instance === null) { this._instance = new this(); } return this._instance; } } }); var SuperDoggy = createClass({ extend: [Animal, Singleton], say: function() { return this.name + ' said: GAV! GAV! GAV!'; } }); var dog1 = SuperDoggy.getInstance(), dog2 = SuperDoggy.getInstance(); dog1.name = 'Bob'; console.log(dog1 === dog2); // true console.log(dog1.eat(), dog1.say()); // ou yeah... Bob said: GAV! GAV! GAV! 

सिंगलटन के पास एक स्थिर संपत्ति है और एक स्थिर getInstance पद्धति है। इस वर्ग का उपयोग सिंगलटन पैटर्न के कार्यान्वयन के रूप में किया जा सकता है। SuperDoggy को दो पशु वर्गों, सिंगलटन से विरासत में मिला है, और उक्त पद्धति को लागू करता है।
यह स्टैटिक्स ऑब्जेक्ट में निर्माण विधि को अलग से ध्यान देने योग्य है। कक्षा बनाते समय और व्युत्पन्न वर्ग बनाते समय इस पद्धति को कहा जाता है। यह आपको विरासत के दौरान किसी वस्तु के स्थिर गुणों को सही ढंग से कॉपी करने की अनुमति देता है। यदि प्रोटोटाइप ऑब्जेक्ट में एक कंस्ट्रक्टर विधि है जो ऑब्जेक्ट बनाता है, तो एक कंस्ट्रक्टर क्यों नहीं है जो क्लास को ही बनाता है?

विधि के उदाहरण "उदाहरण":

 console.log( dog2.instanceOf(Kitty) === false ); // true console.log( dog2.instanceOf(SuperDoggy) === true ); // true console.log( dog2.instanceOf(Animal) === true ); // true console.log( sharik.instanceOf(Animal, Singleton) === false ); // true console.log( dog2.instanceOf(Animal, Singleton) === true ); // true 

यह विचार मूल रूप से डेविड फ्लेंगन की पुस्तक जावास्क्रिप्ट 5 वें संस्करण से लिया गया था: पुस्तक का एक उदाहरण । नतीजतन, यह कोड लेख में प्रस्तुत एक में विकसित हुआ।

चूंकि स्रोत इतना बड़ा नहीं है, मैं इसे यहीं प्रकाशित करता हूं:

 function createClass(data) { var abstracts = data.abstracts || [], statics = data.statics || {}, extend = data.extend || []; if(!(extend instanceof Array)) extend = [extend]; // define constructor var constructor; if(data.construct) { constructor = data.construct; } else if(extend.length) { constructor = function() { for(var i=0; i<extend.length; i++) { extend[i].apply(this, arguments); } } } else { constructor = function() {}; } // prototype for our class. var proto = {}; delete data.construct; delete data.abstracts; delete data.statics; delete data.extend; // borrow methods from parent classes for(var i=0; i<extend.length; i++) { var parent = extend[i]; // static constructor if( typeof parent.construct == "function") parent.construct.call(constructor); // copy static methods for(var p in parent) { if (typeof parent[p] != "function" || p == "construct") // copy only functions continue; constructor[p] = parent[p]; } // Copy prototype methods for(var p in parent.prototype) { if (typeof parent.prototype[p] != "function" || p == "constructor") continue; proto[p] = parent.prototype[p]; } } // build abstract static methods if(statics.abstracts) { for(var p=0; p<statics.abstracts.length; p++) { proto[ statics.abstracts[p] ] = function() { throw p + ' is static abstract method' }; } } // build abstract prototype methods for(var p=0; p<abstracts.length; p++) { proto[ abstracts[p] ] = function() { throw p + ' is abstract method' }; } // internal methods proto.instanceOf = function(_class) { if(arguments.length > 1) { var res = true; for(var i=0; i<arguments.length; i++) res = res && this.instanceOf(arguments[i]); return res; } if(constructor === _class) return true; for(var i=0; i<extend.length; i++) { if( extend[i].prototype.instanceOf.call(this, _class) ) return true; } return _class === Object; }; // rest of data are prototype methods for(var p in data) { if (typeof data[p] != "function") // copy only functions continue; proto[p] = data[p]; } // static functions of class for(var p in statics) { if (typeof statics[p] != "function") // copy only functions continue; constructor[p] = statics[p]; } // static constructor if( typeof statics.construct == "function") statics.construct.call(constructor); // proto.constructor = constructor; constructor.prototype = proto; constructor.fn = proto; // short case // Finally, return the constructor function return constructor; }