टाइपस्क्रिप्ट

Question

में सजावटी के साथ कन्स्ट्रक्टरों को सही ढंग से कैसे लपेटें, सजावट वाले वर्ग को लपेटने की प्रक्रिया सुपरक्लास को उस वर्ग के गुणों तक पहुंचने में असमर्थ होने का कारण बनती है। क्यूं कर?

1. एक डेकोरेटर जो एक नया निर्माता कि सटीक एक ही बात करना चाहिए के साथ एक वर्ग के निर्माता की जगह बनाता है:

   मैं कुछ कोड है कि है।

2. एक संपत्ति के साथ एक बेस क्लास बनाता है।
3. रैपिंग सजावट के साथ बेस क्लास लपेटता है।
4. एक वर्ग बनाता है जो बेस क्लास को बढ़ाता है।
5. विस्तारित कक्षा पर संपत्ति तक पहुंचने का प्रयास करता है। यह वह हिस्सा है जो विफल रहता है।

   function wrap(target: any) { 
       // the new constructor 
       var f: any = function (...args) { 
        return new target(); 
       } 
   
       f.prototype = target.prototype; 
       return f; 
   } 
   
   @wrap 
   class Base { 
       prop: number = 5; 
   } 
   
   class Extended extends Base { 
       constructor() { 
        super() 
       } 
   } 
   
   var a = new Extended() 
   console.log(new Extended().prop) // I'm expecting 5 here, but I get undefined. 
   

   मुझे यकीन है कि यह सामान्य रूप में या तो प्रोटोटाइप या विशिष्ट तरीका है कि टाइपप्रति उन्हें संभालती है कि मैं समझ नहीं होने के कुछ अति सूक्ष्म अंतर है कर रहा हूँ:

यहाँ कोड है।

Answer 1

मेरे लिए इस कोड को works:

function logClass(target: any) { 
    // save a reference to the original constructor 
    var original = target; 

    // the new constructor behaviour 
    var f : any = function (...args) { 
    console.log("New: " + original.name); 
    return original.apply(this, args) 
    } 

    // copy prototype so intanceof operator still works 
    f.prototype = original.prototype; 

    // return new constructor (will override original) 
    return f; 
} 

@logClass 
class Base { 
    prop: number = 5; 
} 

class Extended extends Base { 
    constructor() { 
     super() 
    } 
} 

var b = new Base() 
console.log(b.prop) 

var a = new Extended() 
console.log(a.prop) 

Answer 2

आप run code after and before constructor() with a decorator पसंद है:

function ClassWrapper() { 
    return function(target: any) { 
     // save a reference to the original constructor 
     var original = target; 

     // the new constructor behaviour 
     var f: any = function (...args) { 
      console.log('ClassWrapper: before class constructor', original.name); 
      let instance = original.apply(this, args) 
      console.log('ClassWrapper: after class constructor', original.name); 
      return instance; 
     } 

     // copy prototype so intanceof operator still works 
     f.prototype = original.prototype; 

     // return new constructor (will override original) 
     return f; 
    }; 
} 
@ClassWrapper() 
export class ClassExample { 
    public constructor() { 
     console.info('Running ClassExample constructor...'); 
    } 
} 

let example = new ClassExample(); 

/* 
CONSOLE OUTPUT: 
ClassWrapper: before class constructor ClassExample 
Running ClassExample constructor... 
ClassWrapper: after class constructor ClassExample 
*/