TypeScript: ¿Es posible referirse dinámicamente a una interfaz y hacer que herede de otras entidades a través de un decorador?
Por ejemplo, algo como esto
function doInterfaceInheritance<T>(...entities: Function[]) {
return (target: T) => {
// ... un código para implementar una combinación en realidad
<pre><code> declare interface targert extends ...entities {}
}
</code></pre>
}
class Class1 {
<pre><code>private instanceProperty: string;
static staticClassProperty: string = `propiedad de clase definida en ${this.name}`;
constructor() {
this.instanceProperty = `propiedad de instancia definida en ${Class1.name}`;
}
instanceMethod(): string {
return this.instanceProperty;
}
staticPropertyAccessedThoughAnInstanceMethod(): string {
return `${Class1.staticClassProperty} accedido a través de un método`;
}
</code></pre>
}
@doInterfaceInheritance<MixedClass>(Class1)
class MixedClass {
}
// No quiero tener que hacer esto
interface MixedClass extends Class1 {
}
const mixedClass = new MixedClass();
console.log(mixedClass.instanceMethod())
aquí está el código que estoy probando.
davy.ai
Herencia de Interfaz Dinámica en TypeScript
El código proporcionado define una función genérica
doInterfaceInheritanceque toma un número arbitrario de parámetros de función y devuelve una función decoradora que se utilizará en una clase objetivo.La función decoradora extiende la clase objetivo con las interfaces pasadas como parámetros a
doInterfaceInheritance. El resultado final es una nueva clase que tiene toda la funcionalidad de la clase base junto con cualquier interfaz adicional pasada como parámetro.El código de ejemplo demuestra esta funcionalidad pasando
Class1como parámetro adoInterfaceInheritancey utilizando el decorador resultante para extender la claseMixedClass.La ventaja de utilizar la herencia dinámica de interfaces en lugar de declarar explícitamente la interfaz es que permite una mayor flexibilidad en la forma en que se extienden y combinan las interfaces en tiempo de ejecución. Además, evita el desorden en la base de código con declaraciones redundantes de interfaces.