当一个类在 Typescript 中实现自身时是什么意思

Question

我正在尝试将依赖注入添加到一个普通的 Typescript 项目中，发现一个名为 inversify 的 npm 包。 所以看看我遇到这段代码的例子：

import { Container, injectable, inject } from "inversify";

@injectable()
class Katana {
    public hit() {
        return "cut!";
    }
}

@injectable()
class Shuriken {
    public throw() {
        return "hit!";
    }
}

@injectable()
class Ninja implements Ninja {

    private _katana: Katana;
    private _shuriken: Shuriken;

    public constructor(katana: Katana, shuriken: Shuriken) {
        this._katana = katana;
        this._shuriken = shuriken;
    }

    public fight() { return this._katana.hit(); };
    public sneak() { return this._shuriken.throw(); };

}

var container = new Container();
container.bind<Ninja>(Ninja).to(Ninja);
container.bind<Katana>(Katana).to(Katana);
container.bind<Shuriken>(Shuriken).to(Shuriken);

忍者类实现忍者类是什么意思？

class Ninja implements Ninja {

在示例中容器将类绑定到自身，是否与此相关？

var container = new Container();
container.bind<Ninja>(Ninja).to(Ninja);

Answer 1

我认为这没有任何意义或增加任何类型安全性。这只是编译器如何执行类型检查的一个怪癖。在类已经完全输入之后检查实现。因此编译器可以检查涉及类本身的implements 子句。

在这种情况下，在implements 子句中使用该类并不是特别有用（因为您基本上是在说该类应该实现它自己总是这样做的）。我们可以使用这个特性做一些有用的事情，例如我们可以确保类成员是特定类型的

class Test implements Record<keyof Test, () => void> {
  test() { } 
}

class Test2 implements Record<keyof Test2, () => void>{
    test(a: number) { }  // error
}