Utilizzando un decoratore ottenere l'elenco delle interfacce implementate

Question

fai a sapere se è possibile ottenere la gamma di interfacce implementate da una classe utilizzando un decoratore:

interface IWarrior { 
    // ... 
} 

interface INinja { 
    // ... 
} 

Quindi, se faccio qualcosa di simile:

@somedecorator 
class Ninja implements INinja, IWarrior { 
// ... 
} 

In fase di esecuzione Ninja avrà un'annotazione che contiene ["INinja", "IWarrior"]?

Grazie

Answer 1

Attualmente, i tipi vengono utilizzati solo durante lo sviluppo e il tempo di compilazione. Le informazioni sul tipo non sono tradotte in alcun modo nel codice JavaScript compilato. Ma puoi comunque passare l'elenco di stringhe al parametro decoratore in questo modo:

interface IWarrior { 
    // ... 
} 

interface INinja { 
    // ... 
} 


interface Function { 
    interfacesList: string[]; 
} 

@interfaces(["INinja", "IWarrior"]) 
class Ninja implements INinja, IWarrior { 

} 

function interfaces(list: string[]) { 
    return (target: any) => { 
     target.interfacesList = list; 
     return target; 
    } 
} 

console.log(Ninja.interfacesList); 

Answer 2

Poiché tutte le informazioni sulle interfacce viene gettato via al momento della compilazione questo non sarà possibile. Non c'è modo per l'implementazione del somedecorator per accedere alle informazioni che sono state gettate via dal compilatore.

Passando i nomi di interfaccia al decoratore come stringhe è possibile, questo non è tuttavia utile poiché tutte le informazioni fornite dalle interfacce andranno perse in fase di esecuzione.

Una buona domanda di overflow dello stack su decoratori d'esecuzione:

How to implement a typescript decorator?

Edit:

Così, dopo la ricerca di questo per un po 'la risposta alla tua domanda è ancora no. Per due motivi:

1. Nessuna informazione sulle interfacce è possibile accedere dopo il tempo di compilazione (con o senza decoratori)
2. Decoratori non ottengono l'accesso alle proprietà ereditate di una classe.

esempi Som per illustrare questo:

function myDecorator() { 
    // do something here.. 
} 

interface INamed { name: string; } 

interface ICounted { getCount() : number; } 

interface ISomeOtherInterface { a: number; } 

class SomeClass { 
    constructor() { } 
} 

class Foo implements INamed { 
    constructor(public name: string) { }  
} 

@myDecorator 
class Bar extends Foo implements ICounted { 

    private _count: number; 
    getCount() : number { return this._count; } 

    constructor(name: string, count: number, public someProp: ISomeOtherInterface, public someClass: SomeClass) { 
     super(name); 
     this._count = count; 
    } 
} 

questo si tradurrà in codice compilato (con il flag --emitDecoratorMetadata):

function myDecorator() { 
    // do something here.. 
} 
var SomeClass = (function() { 
    function SomeClass() { 
    } 
    return SomeClass; 
})(); 
var Foo = (function() { 
    function Foo(name) { 
     this.name = name; 
    } 
    return Foo; 
})(); 
var Bar = (function (_super) { 
    __extends(Bar, _super); 
    function Bar(name, count, someProp, someClass) { 
     _super.call(this, name); 
     this.someProp = someProp; 
     this.someClass = someClass; 
     this._count = count; 
    } 
    Bar.prototype.getCount = function() { return this._count; }; 
    Bar = __decorate([ 
     myDecorator, 
     __metadata('design:paramtypes', [String, Number, Object, SomeClass]) 
    ], Bar); 
    return Bar; 
})(Foo); 

Qualsiasi informazione che sarà disponibile a noi in il decoratore (ad eccezione della classe stessa) è contenuto nella parte __decorate:

__decorate([ 
     myDecorator, 
     __metadata('design:paramtypes', [String, Number, Object, SomeClass]) 
    ], Bar); 

Allo stato attuale ora nessuna informazione sull'ereditarietà o le interfacce sono passate insieme ai decoratori. Tutto ciò che un decoratore per una classe fa è decorare il costruttore. Questo probabilmente non cambierà, certamente non per le interfacce (dal momento che tutte le informazioni su di esse vengono gettate via al momento della compilazione).

Come possiamo vedere nell'array di tipi di __metadata otteniamo le informazioni sul tipo per String, Number e la classe SomeClass (argomenti del costruttore). Ma l'interfaccia ISomeOtherInterface è segnalata come Object, questo perché nessuna informazione sulle interfacce typescript viene mantenuta nel javascript compilato. Quindi la migliore informazione che possiamo ottenere è Object.

È possibile utilizzare qualcosa come https://github.com/rbuckton/ReflectDecorators per lavorare meglio con i decoratori, ma sarà comunque possibile accedere alle informazioni solo in __decorato e __metadata.

Quindi per riassumere.Nessuna informazione sull'ereditarietà o le interfacce per una classe è disponibile in un decoratore. Le interfacce probabilmente non saranno mai disponibili per un decoratore (o in qualsiasi altro posto nel codice compilato).