शास्त्रीय विरासत और वस्तु पूलिंग

Question

मैं वर्तमान में एक परियोजना जहां निम्नलिखित विरासत संरचना प्रयोग किया जाता है पर काम कर रहा हूँ:

var Type = function(a){ 
    this.a = a; 
}; 

var SubType = function(a){ 
    Type.call(this, a); 
}; 
SubType.prototype = Object.create(Type.prototype); 
SubType.prototype.constructor = SubType; 

अब, मैं कुछ समीकरण को पूलिंग वस्तु को जोड़ने की कोशिश कर रहा हूँ। पैटर्न मैं वर्तमान में (स्यूडोकोड) की तरह काम करता है कुछ का उपयोग कर रहा:

Type.new = function(){ 
    if object available in pool 
    reset popped pool object 
    return pool object 
    else 
    return new Type() 
} 
var a = Type.new(); 

बेशक

, इन दो पैटर्न का उपयोग कर के साथ समस्या यह है कि निर्माता कॉल उपप्रकार पर अभ्यस्त प्रकार के पूल से आकर्षित है। कारखाने की संरचना में जाने के बिना इसके आसपास कोई रास्ता है? अर्थात। वहाँ की तर्ज पर कुछ करने के लिए एक तरीका है, एक निर्माता में,: यह जानते हुए कि यह हमेशा संदर्भों पर एक जैसी नहीं है

var SubType = function(){ 
    build on top of instanceReturnedFromFunction() 
}; 

, मैं भी विरासत संरचना को बनाए रखने के लिए करना चाहते हैं चाहते हैं ताकि instanceof आदि अभी भी काम करेगा :

Answer 1

इस पद्धति का उपयोग कर के साथ समस्या यह है कि निर्माता SubType पर कॉल अभ्यस्त Type के पूल

वास्तव में है कि एक समस्या नहीं है, कि एक आवश्यकता है से आकर्षित है। Type और SubType उदाहरणों में अलग-अलग प्रोटोटाइप होते हैं, आप उन्हें एक दूसरे के रूप में उपयोग नहीं कर सकते (और swapping prototypes doesn't work either)।
आपको निश्चित रूप से अपने सभी वर्गों के लिए अलग-अलग पूल की आवश्यकता होगी। और अगर आप किसी भी समस्याओं के बिना कि .new कारखाने दृष्टिकोण का उपयोग कर सकते हैं - हालांकि निश्चित रूप से आप उन कारखानों प्रोग्राम के बनाने चाहिए:

function pooledNew() { 
    // `this` is the "class" constructor function 
    if (!this.pool) this.pool = []; 
    var instance = this.pool.length ? this.pool.pop() : Object.create(this.prototype); 
    this.apply(instance, arguments); // reset/initialise 
    return instance; 
} 
function makePooling(constr) { 
    constr.new = pooledNew; 
    constr.pool = []; 
    var proto = constr.prototype; 
    if (proto.constructor !== constr) 
     proto.constructor = constr; 
    if (typeof proto.destroy != "function") 
     proto.destroy = function destroyInstance() { 
      this.constructor.pool.push(this); 
     }; 
    return constr; 
} 

ये उपवर्गीकरण साथ दोषरहित काम करने के लिए तैयार कर रहे हैं अपने उदाहरण में बस करो

makePooling(Type); 
makePooling(SubType); 

ईएस 6 में, सबक्लास भी अपने सुपरक्लास रचनाकारों से new विधि का उत्तराधिकारी होगा।

class Type { 
    constructor(a) { 
     this.a = a; 
    } 
    destroy() { // overwriting default behaviour 
     this.a = null; // for GC 
     this.constructor.pool.push(this); 
    } 
} 
makePooling(Type); 

class SubType extends Type { 
    // you can use super calls in both "constructor" and "destroy" methods 
}