Korzystanie dekorator do listy realizowanych interfejsów

Question

wiesz, jeśli jest to możliwe, aby uzyskać szereg interfejsów realizowanych przez klasę za pomocą dekoratora dostać:

interface IWarrior { 
    // ... 
} 

interface INinja { 
    // ... 
} 

więc jeśli coś takiego:

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

W czasie wykonywania Ninja będzie mieć adnotację zawierającą ["INinja", "IWarrior"]?

Dzięki

Answer 1

Obecnie typy są używane tylko podczas programowania i kompilowania. Informacje o typie nie są w żaden sposób tłumaczone na skompilowany kod JavaScript. Ale możesz jednak przekazać listę ciągów do parametru dekoratora w następujący sposób:

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

Ponieważ wszystkie informacje o interfejsach jest wyrzucane w czasie kompilacji nie będzie możliwe. Nie ma sposobu na wdrożenie somedecorator do dostępu do informacji, które zostały wyrzucone przez kompilator.

Przekazywanie nazw interfejsów do dekoratora w postaci ciągów jest możliwe, nie jest to jednak użyteczne, ponieważ wszystkie informacje dostarczone przez interfejsy znikną w czasie wykonywania.

Dobrym przepełnienie stosu pytanie o dekoratorów wykonawczych:

How to implement a typescript decorator?

Edit:

Więc po badaniu tym przez chwilę odpowiedź na to pytanie wciąż nie ma. Z dwóch powodów:

1. Brak informacji na temat interfejsów można uzyskać po czasie kompilacji (z lub bez dekoratorów)
2. Dekoratorzy nie uzyskać dostęp do odziedziczonych właściwości klasy.

przykłady Som to zilustrować:

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; 
    } 
} 

To spowoduje skompilowanego kodu (z --emitDecoratorMetadata flagą):

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); 

wszelkie informacje, które będą dla nas dostępne w dekorator (z wyjątkiem samej klasy) znajduje się w __dekorowanej części:

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

W obecnej postaci do dekoratorów nie są przekazywane żadne informacje na temat dziedziczenia ani interfejsów. Wszystkim dekoratorem na zajęcia jest dekorowanie konstruktora. Prawdopodobnie to się nie zmieni, na pewno nie dla interfejsów (ponieważ wszystkie informacje na ich temat są wyrzucane podczas kompilacji).

Jak możemy se w tablicy typów __metadata otrzymujemy informacje o typie dla ciągu, liczby i klasy SomeClass (argumenty konstruktora). Ale interfejs ISomeOtherInterface jest zgłaszany jako Object, ponieważ w skompilowanym javascriptie nie są przechowywane żadne informacje o interfejsach maszynopisu. Najlepsze informacje, jakie możemy uzyskać, to Object.

Możesz użyć czegoś takiego jak https://github.com/rbuckton/ReflectDecorators, aby lepiej współpracować z dekoratorami, ale nadal będziesz mieć dostęp tylko do informacji w __dekoracji i __metadanych.

Podsumowując.Brak informacji na temat dziedziczenia lub interfejsów dla klasy jest dostępny w dekoratorze. Interfejsy prawdopodobnie nigdy nie będą dostępne dla dekoratora (ani nigdzie indziej w skompilowanym kodzie).