扩展接口的接口问题

Question

我希望实现 Observer 接口的类也实现 Comparable 接口，我该怎么做？

interface Comparable<T> {
    equals: (item: T) => boolean;
}

interface Observer extends Comparable<Observer> {
    notify: () => void
}

class TestA implements Observer {
    private name = '';

    equals = (item: TestA) => {
        return this.name === item.name
    }

    notify = () => {}
}

class TestB implements Observer {
    private name = '';

    equals = (item: TestB) => {
        return this.name === item.name
    }

    notify = () => {}
}

错误：

TS2416：类型“TestA”中的属性“等于”不能分配给基本类型“观察者”中的相同属性。类型 '(item: TestA) => boolean' 不可分配给类型 '(item: Observer) => boolean'。参数“item”和“item”的类型不兼容。 “观察者”类型中缺少属性“名称”，但在“TestA”类型中是必需的。

但是，TestA实现了Observer接口，为什么不兼容呢？

当然，我可以这样写：

class TestA implements Observer {
    private name = '';

    equals = (item: Observer) => {
        return this.name === item.name
    }

    notify = () => {}
}

然后我得到这样一个错误，此外，这并不完全正确，因为我只想比较这个类的对象：

“观察者”类型上不存在属性“名称”。

怎么做才对？ “打字稿”：“^3.9.2”

Answer 1

在 TestA 类和 TestB 类中将 equals(item: TestA) 和 equals(item:TestB) 更改为 equals(item : Observer)。

因为 Comparable 类型被指定为 Observable。

在 equals 正文中，您可以将 observable 对象转换为 TestA 并比较其 name 属性，如下所示。

在 TestA 类中。

class TestA implements Observer {
    private name = '';

    equals = (item: Observer) => {
        if(item instanceof TestA){
          return this.name === (item as TestA).name
        }
        return false
    }

    notify = () => {}
}

Answer 2

您是否考虑过使用polymorphic this 代替泛型？您的 Comparable 和 Observer 将变为：

interface Comparable {
    equals: (item: this) => boolean;
}

interface Observer extends Comparable {
    notify: () => void
}

意味着扩展Comparable 的X 类型的对象需要有一个equals() 方法，该方法采用X 类型的值。请注意，这意味着Comparable 在可替换性和继承性方面不像普通类型。一般来说，如果你有interface B extends A {...}，那么你应该可以在任何需要A的地方使用B：

interface A {
    someMethod(x: A): void;
}

interface B extends A {
    someOtherMethod(x: B): void;
}

declare const b: B;
const a: A = b; // okay

但这不适用于Comparable：

declare const o: Observer;
const c: Comparable = o; // error! equals is incompatible

---

无论如何，Comparable 的这个定义将允许您按原样实现：

class TestA implements Observer {
    private name = '';

    equals = (item: TestA) => {
        return this.name === item.name
    }

    notify = () => { }
}

class TestB implements Observer {
    private name = '';

    equals = (item: TestB) => {
        return this.name === item.name
    }

    notify = () => { }
}

但同样，如果您尝试将 TestA 或 TestB 视为 Observer，则会遇到问题：

function takeObservers(o1: Observer, o2: Observer) {
    o1.equals(o2);    
}
takeObservers(new TestA()); // error

因此，您可能会决定实际上不想以这种方式限制 equals()。

---

好的，希望对您有所帮助；祝你好运！

Playground link to code