Question

我正在寻找一个接口，并为此接口创建一个 thin 类包装器，而无需在构造函数和类中重复所有属性。

interface _Notes {
  date: Date;
}

class Notes implements _Notes{
  date: Date;
  constructor (n: _Notes) {
    this.date = n.date;
  }
}

我想要的是这样简单的东西：

class Notes implements _Notes{
  constructor (n: _Notes) {
    Object.assign(this, n)
  }
}

或简单地：

class Notes implements _Notes {}

Answer 1

对于非泛型接口，您可以创建可重用的函数，该函数创建一个类并在构造函数中调用Object.assign()

export interface PropertiesConstructor<Properties> {
    new(p: Properties): Properties;
}

export function Implementation<Properties>(): PropertiesConstructor<Properties> {
    return class {
        constructor(p: Properties) {
            Object.assign(this, p);
        }
    } as PropertiesConstructor<Properties>
}

您可以像这样使用它：

interface _Notes {
  date: Date;
}

class Notes extends Implementation<_Notes>() {
    constructor(n: _Notes) {
        super(n);
    }
}

您仍然必须声明一个构造函数，并且不要忘记将构造函数参数传递给super()，因此它不能完全消除冗余，但是我认为这很有用。

但是，如果您的界面是通用的，就会出现问题：

interface _Data<ItemType> {
  item: ItemType;
}

class Data<ItemType> extends Implementation<_Data<ItemType>>() {

// error: Base class expressions cannot reference class type parameters.

为避免此错误，您可以将any作为接口的类型参数传递，并在类中重新声明所有依赖于类型参数的属性：

interface _Data<ItemType> {
    item: ItemType;
    timestamp: Date;
}

class Data<ItemType> extends Implementation<_Data<any>>() {

    item: ItemType;

    constructor(n: _Data<ItemType>) {
        super(n);
        this.timestamp = new Date();
    }
}

同样，比Titian对the linked question的回答要好得多，但是在此示例中，您仍然不必重新声明timestamp。

从接口创建类，没有冗余

1 个答案: