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
}

当类在Typescript中实现自身时，这是什么意思

1 个答案: