Javascript 使用依赖项注入实例化类常量

我们用角常数来定义类。如何使类常量在实例化时可以在构造函数中有一个参数，但也可以有依赖项注入？我是这样想的：

ClassA.js

class ClassA { ... }

angular.module("myApp").constant("ClassA", ClassA);

class ClassA { ... }

angular.module("myApp").factory("ClassA", () => ClassA);

ClassB.js

class ClassB {
  constructor(constrParams, ClassA) { // mix of constructor parameter and DI
    this.constrParams = constrParams;
    this.ClassA = ClassA;
  }
}

ClassB.$inject = ["ClassA"]; // ClassB needs reference to ClassA
angular.module("myApp").constant("ClassB", ClassB);

class ClassB {
  constructor(constrParams) {
    this.constrParams = constrParams;
    // this.ClassA reference is already injected through factory
  }
}

angular.module("myApp")
.factory("ClassB", ["ClassA", (ClassA) => {
  // this is where dependency injection happens
  ClassB.prototype.ClassA = ClassA;
  return ClassB; // class definition
}]);

在另一个常量中导入ClassB时，我还能这样做吗

ClassC.js

class ClassC {
  constructor(ClassB) {
    this.classBinst = new ClassB("myparams"); // instantiate new ClassB instance
  }
}

ClassC.$inject = ["ClassB"];
angular.module("myApp").constant("ClassC", ClassC);

---

如果您想手动传入任何构造函数参数，我认为您必须手动传入它们

因此，ClassC也必须将ClassA作为参数，将其传递给ClassB：

但是，如果您创建了需要ClassC的ClassD，那么您就会遇到同样的问题——需要传入ClassC及其所有依赖项ClassB和ClassA

但是，如果ClassC是最终级别，并且可以作为单例实例化和注入，那么您可以创建一个实例化ClassC的服务，而不必担心其依赖性：

angular.module("myApp").service('instanceC', ClassC);

angular.module("myApp").controller('myController', function (instanceC) {
    // Everything has been resolved
});

也许您最好创建一个服务，为您创建这些类的实例。该服务可以解析类所需的依赖项并手动传递它们，而控制器可以传递任何自定义参数：

class factory {
    constructor(ClassA, ClassB, ClassC) {
        this.ClassA = ClassA;
        this.ClassB = ClassB;
        this.ClassC = ClassC;
    }

    createB(customParamForClassB) {
        return new this.ClassB(customParamForClassB, this.ClassA)
    }
}

angular.module("myApp").service('factory', factory);

angular.module("myApp").controller('myController', function (factory) {
    let instanceB = factory.createB('myparams');
});

---

我扩展了Frank将类作为服务提供的想法，但使用了工厂结构。工厂提供了可以直接实例化的类定义，而不是服务中的显式create函数。模式如下：

ClassA.js

class ClassA { ... }

angular.module("myApp").constant("ClassA", ClassA);

class ClassA { ... }

angular.module("myApp").factory("ClassA", () => ClassA);

ClassB.js

class ClassB {
  constructor(constrParams, ClassA) { // mix of constructor parameter and DI
    this.constrParams = constrParams;
    this.ClassA = ClassA;
  }
}

ClassB.$inject = ["ClassA"]; // ClassB needs reference to ClassA
angular.module("myApp").constant("ClassB", ClassB);

class ClassB {
  constructor(constrParams) {
    this.constrParams = constrParams;
    // this.ClassA reference is already injected through factory
  }
}

angular.module("myApp")
.factory("ClassB", ["ClassA", (ClassA) => {
  // this is where dependency injection happens
  ClassB.prototype.ClassA = ClassA;
  return ClassB; // class definition
}]);

ClassC.js最终目标-与之前相同

class ClassC {
  constructor() {
    // instantiate new ClassB instance
    this.classBinst = new this.ClassB("myparams");
  }
}

angular.module("myApp").factory("ClassC", ["ClassB", (ClassB) => {
  ClassC.prototype.ClassB = ClassB;
  return ClassC;
}]);

---

相关模式：

我扩展了你的想法，改用工厂。这提供了实际的类定义来实例化，而不是在进行依赖项注入时显式地创建函数