मेरा विस्तार और वर्ग विरासत शैली

इस पोस्ट में मैं बताना चाहता हूं कि मैं एक स्वैच्छिक जावास्क्रिप्ट अनुप्रयोग में विरासत को कैसे लागू करना पसंद करता हूं।

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

समारोह का विस्तार करें

cSO = {}; //     . cSO.extend = function(child, parent, other) { if(parent) { var F = function() {}; F.prototype = parent.prototype; child.prototype = new F(); child.prototype.constructor = child; child.prototype.proto = function() { return parent.prototype; } //   . } else { child.prototype.proto = function() { return; } } /* *     stat,    -  . *    _class.stat   ()   this.stat. *       ,     *  : _class.stat.prototype.myStaticMethod = function() {...<anchor>habracut</anchor> *    ,    prototype. *    stat  ,     . *     stat -  _class.stat.deleteStatVal("name"); */ child.statConstructor = function() {}; if(parent && ("statConstructor" in parent) && parent.statConstructor && typeof (parent.statConstructor) === "function") { var S = function() {}; S.prototype = parent.statConstructor.prototype; child.statConstructor.prototype = new S(); child.statConstructor.prototype.constructor = child.statConstructor; child.statConstructor.prototype.proto = function() { return parent.statConstructor.prototype; } child.statConstructor.prototype.protoStat = function() { return parent.stat; } } else { child.statConstructor.prototype.proto = function() { return; } child.statConstructor.prototype.protoStat = function() { return; } } var oldChildStat = child.stat; //   stat -  ... child.stat = new child.statConstructor(); if(oldChildStat) { //       . for(var k in oldChildStat) { child.stat[k] = oldChildStat[k]; } } child.stat.prototype = child.statConstructor.prototype; if(oldChildStat && oldChildStat.prototype) { //         . for(var k in oldChildStat.prototype) { child.stat.prototype[k] = oldChildStat.prototype[k]; } } child.prototype.stat = child.stat; if(other) { //      . if(other.statConstruct) { child.stat.prototype.construct = other.statConstruct; } } child.stat._class = child; //       . child.stat.deleteStatVal = function(name) { //   ,      . if( name in child.stat) { try { delete child.stat[name]; } catch(e) { } if(parent) { child.stat[name] = child.stat.protoStat()[name]; } } } child.prototype.protoFunc = child.statConstructor.prototype.protoFunc = function(callerFuncName, args, applyFuncName) { /* *          (  *  - -     ).   *  applyFuncName -  callerFuncName    -   *     ,     -. */ if(!args) { args = []; } if(applyFuncName) { //    ,     . } else { applyFuncName = callerFuncName; } var tProto = this; var ok = false; do { if(ok && arguments.callee.caller !== tProto[applyFuncName]) { if(( applyFuncName in tProto) && ( typeof (tProto[applyFuncName]) === "function")) { return tProto[applyFuncName].apply(this, args); } } else if(arguments.callee.caller === tProto[callerFuncName]) { ok = true; } } while(("proto" in tProto) && (tProto = tProto.proto())) return; } if(child.stat.construct) { //         stat.construct child.stat.construct(); } } 

यह कैसे काम करता है, और विस्तार के परिणाम () के बारे में एक छोटी सी जाँच

हम 3 कक्षाएं बनाते हैं, प्रत्येक - पिछले एक का वारिस।

 cSO.class001 = function() { } cSO.extend(cSO.class001, 0, {"statConstruct":function(sc1) { console.log("statConstruct001"); }}); //  statConstruct001 cSO.class001.prototype.construct = function(c1) { console.log('c1'); this.protoFunc("construct", arguments); } cSO.class001.stat.prototype.st = function(s1) { console.log('st1'); this.protoFunc("st"); } cSO.class001.stat.dat = ["hello1"]; cSO.class002 = function() { } cSO.extend(cSO.class002, cSO.class001, {"statConstruct":function(sc2) { console.log("statConstruct002"); this.protoFunc("construct", arguments); }}); //  statConstruct002 statConstruct001 cSO.class002.prototype.construct = function(c2) { console.log('c2'); this.protoFunc("construct", arguments); } cSO.class002.stat.st = function(s2) { console.log('st2'); this.protoFunc("st"); } cSO.class003 = function() { } cSO.extend(cSO.class003, cSO.class002); //  statConstruct002 statConstruct001 cSO.class003.prototype.construct = function(c3) { console.log('c3'); this.protoFunc("construct", arguments); } cSO.class003.stat.prototype.st = function(s3) { console.log('st3'); this.protoFunc("st"); } cSO.class003.stat.dat = ["hello3"]; 

और अब हम पता लगाते हैं कि उनके कार्य किस क्रम में किए गए हैं।

 var obj001 = new cSO.class001(); var obj002 = new cSO.class002(); var obj003 = new cSO.class003(); obj001.construct(); // c1 obj002.construct(); // c2 c1 obj003.construct(); // c3 c2 c1 cSO.class001.stat.st(); // st1 cSO.class002.stat.st(); // st2 st1 cSO.class003.stat.st(); // st3 st1 //    cSO.class002.stat.st  prototype console.log(obj003.stat.dat); // ["hello3"] obj002.stat.dat = ["world"]; console.log(obj002.stat.dat); // ["world"] cSO.class002.stat.deleteStatVal("dat"); console.log(obj002.stat.dat); // ["hello1"] console.log(obj001.stat.dat); // ["hello1"] 

कुछ और स्पर्श जो मुझे महत्वपूर्ण लगे

दैनिक अभ्यास के परिणामस्वरूप, मेरे पास लगभग वस्तुओं की संरचना है:

 _class={ construct:function(){}, //     -. destruct:function(){}, //     -. //  .. stat:{ create:function(){}, //       . collection:[], //        . clearAll:function(){} //       . //  .. } } 

अब मैं समझाऊंगा कि ऐसा क्यों है।
एक क्लास बनाने के लिए, आपको कंस्ट्रक्टर को कॉल करना होगा, इस क्लास की चाइल्ड ऑब्जेक्ट बनाते समय नया Foo () नहीं कहा जाता है।

यहाँ एक उदाहरण है:

 var id = 0; var Foo = function() { this.id = id++; console.log("  ,   boom"); } foo.prototype.boom = function() {} var Bar = function() { } Bar.prototype = new Foo(); var fooOb = new Foo(); //   ,   boom var barOb = new Bar(); var barOb2 = new Bar(); console.log(fooOb.id); // 1 console.log(barOb.id); // 0 console.log(barOb2.id); // 0 

और मैं चाहता हूं कि सभी वस्तुओं, फू कक्षा के वारिस, एक अद्वितीय आईडी हो और उपयोगकर्ता को चेतावनी दें कि वे विस्फोट कर सकते हैं।
इसे लागू करने के लिए, मैं एक विशेष cnstruct विधि बनाता हूं (निर्माता पहले से ही लिया गया है), और प्रत्येक ऑब्जेक्ट बनाते समय इसे निष्पादित करता है। इसे निष्पादित करने के लिए मत भूलना, मैं नए फू () के माध्यम से वस्तुओं को बनाने और स्थिर विधि Foo.stat.create () के माध्यम से ऑब्जेक्ट बनाने से इनकार करता हूं।
निम्नलिखित वास्तव में उपयोग किए जाने वाले वर्ग का एक छोटा संस्करण है, उदाहरण के लिए कि कक्षाएं कैसे प्राप्त की जाती हैं।

वास्तविक उदाहरण

इस वर्ग को आधार श्रृंखला से अंतिम एक (सबसे विपरीत दिशा में सबसे अधिक संभावना) में प्रोटोटाइप श्रृंखला में से कई के रूप में माना जाना चाहिए।

 (function() { var _class = cSO.LocalStorageSyncDataType = function () { /* *     ,  *       . *     ,  . */ } cSO.extend(_class, cSO.ServerSyncDataType, {"statConstruct": function() { this.protoFunc("construct", arguments); //   ,      protoFunc -    . if("addToClassesForSnapshot" in this) { //     cSO.LocalStorageSyncDataType,    ,     . this.addToClassesForSnapshot(this._class); //      . } }}); var _class_stat = _class.stat; //   -   ()     15%-25%   .       . var _class_stat_prototype = _class_stat.prototype; var _class_prototype = _class.prototype; var cfs = _class_stat.classesForSnapshot = []; _class_stat.create = function(args) { //     ,   ..   . this.addedToLocalStorage = false; if(args.addedToLocalStorage) { this.addedToLocalStorage = true; } this.protoFunc("construct", arguments); } _class_prototype.construct = function(args) { /* *    ,    . *         . */ this.addedToLocalStorage = false; if(args.addedToLocalStorage) { this.addedToLocalStorage = true; } this.protoFunc("construct", arguments); } _class_prototype.setLoaded = function(val) { this.protoFunc("setLoaded", arguments); // ,    ,      . } _class_stat.addToClassesForSnapshot = function(clas) { clas = clas || this._class; for(var i = 0; i < cfs.length; i++) { if(cfs[i] === clas) return; } cfs.push(clas); } _class_stat.createAllSnapshots = function() { for(var i = 0; i < cfs.length; i++) { cfs[i].stat.createSnapshot(); } } _class_stat_prototype.createSnapshot = function() { var co = this.collection; var str = ""; for(var i in co) { if(co[i]) { if(!str) { str = "["; } else { str += ","; } str += co[i].getJSON(); } } if(str) str += "]"; this.snapshot = str; } _class_stat.saveAllSnapshotsOnLocalStorage = function() { for(var i = 0; i < cfs.length; i++) { cfs[i].stat.saveSnapshotOnLocalStorage(); } } _class_stat_prototype.saveSnapshotOnLocalStorage = function() { if(this.snapshot) { cSO.localStorage.setItem(this.tableName, this.snapshot); } } _class_stat.setAllBySnapshotsFromLocalStorage = function() { for(var i = 0; i < cfs.length; i++) { cfs[i].stat.setBySnapshotFromLocalStorage(); } } _class_stat_prototype.setBySnapshotFromLocalStorage = function() { var arr = $.parseJSON(cSO.localStorage.getItem(this.tableName)); for(var i = 0; i < arr.length; i++) { if(arr[i]) { this.createOrGet({"cells":arr[i], "addedToLocalStorage":true}); } } } })(); 

मैं जोड़ूंगा कि इस दृष्टिकोण का उपयोग विशेष रूप से ऑब्जेक्ट कक्षाओं के लिए किया जाना चाहिए, और "अकेला" ऑब्जेक्ट्स के लिए (उदाहरण के लिए cSO.localStorage) यह एक पारंपरिक ऑब्जेक्ट फैक्ट्री का उपयोग करने के लायक है।

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