typescript - 声明(定义)类成员方法

Question

我有 TypeScript ES6 类，假设它看起来像这样

class Classic
    private _member: Object;
    constructor(member: Object) {
       this._member = member;
    }
}

我有一些丰富的对象，它包含很多我想继承的方法，但那个对象不是 TS 或 ES6 类，它只是 POJO (ObjectLiteral)。

所以我做了快速而肮脏的继承

Object.assign(Classic.prototype, ObjectLiteralWithMethods);

无需深拷贝，一切正常。

我如何告诉 TypeScript Classic 具有这些继承的方法并指定它们的行为？

我搜索了诸如 declare OR define AND class AND method 之类的关键字，但我的 google-fu 是不够的。

我尝试为 Classic 定义接口(interface)，但它也不起作用。

我试着像这样声明类

declare class ObjectLiteralWithMethods {
    public method(): void;
    protected _method(parameter: string): void;
}

然后像这样扩展声明

class Classic extends ObjectLiteralWithMethods { ... }

但是 TypeScript 要我在 constructor 中调用 super()，但失败了。

我知道我可以在 Classic 上实现“虚拟”方法，例如

class Classic {
    dummyMethodImplementation(param: string): string {
        return param;
    }
}

但这会很痛苦且效率低下。我只想定义/声明类 Classic 已扩展。

已解决

有点……

在我的案例中，ObjectLiteralWithMethods 实际上是 jQuery 小部件的原型(prototype)。所以，我扩展了原型(prototype)的所有者。

它需要一些补丁，因为 TS 不知道所有者，所以我做了:

// declaring the properties and methods which will be inherited by my class
declare class JQueryUIWidget {
    public property: string;
    public method(): string;
    ...
}

// must declare a constructor for JQueryUIWidget to be able to extend
// and cast the value to any, so TS do not mind
const Widget: { new (): JQueryUIWidget } = $.Widget as any;

// and then extend that declaration
class Classic extends Widget {
    constructor() {
        super(); // super(); is mandatory here, with plain object it 
                 // did not worked, but since Widget is in fact a Function
                 // it works now
    }
}

Answer 1

有点晚了，但我在将遗留系统的一部分转换为 TypeScript 时有类似的要求，因此这可能会对其他人有所帮助。

如果您知道您的类将在运行时使用其他方法得到增强，并且您只是想为这些方法提供类型信息和智能感知，并且您不想编写丑陋的 stub ，您可以试试这个:

首先，定义详细说明运行时方法的接口(interface):

interface RuntimeImplementedType {
    public method(): void;
}

interface AnotherRuntimeImplementedType {
    public other_method(): void;
}

然后定义一个变量，其类型被指定为一个构造函数，该函数返回您想要通知 TypeScript 您的类在运行时实现的类型的联合。为变量分配一个返回空对象字面量的函数，强制转换为“any”以避免编译器出错，并确保在转译时，实际扩展的只是一个普通的旧空对象。

const Base: new() => RuntimeImplementedType & AnotherRuntimeImplementedType = (() => {}) as any;

现在定义你的新类，从你的构造函数变量扩展:

class Classic extends Base {
    public doSomething() {
        this.method();
        this.other_method();
    }
}

接口(interface)中的所有方法都应该可用，但不必实际提供实现。