Passen klasse als parameter oorzaken "is niet newable" fout

Probeer dit:

export class MyApp {
    registerView(viewKlass: typeof A.Views.View): void {
        var test = new viewKlass();
    } 
}

Er zijn 2 manieren om klassen passeren met de schrijfmachine. Als jij:

• weet dat de superklasse van de klasse waarin u op doorreis bent (reeds door Corey Alix aanbevolen):

  class MyClass extends MySuperClass{ }
  
  makeMyClass(classRef: typeof MySuperclass) {
      return new classRef();
  }
  
  makeMyClass(MyClass);
  

• weten de ondertekening van de klassen constructorfunctie :

  class MyClass {
      constructor(arg: string) {}
  }
  
  makeMyClass(classRef: { new(arg: string) }) {
      return new classRef('hello');
  }
  
  makeMyClass(MyClass);
  

Om de andere antwoorden aan te vullen; Ik heb een utility type I te houden rond om een ​​generieke parameter te verzekeren / gebied is een klasse / newable:

/* new T() */
export type Newable<T> = { new (...args: any[]): T; };

Vervolgens kunt u ervoor zorgen dat u een klasse constructor:

class MyApp<TViewBase>
{
  register<TView extends TViewBase>(view: Newable<TView>) { 
  }
}

de Newable<T>aanpak werkt, waar typeof T--waar Tis een generieke Motortype- niet.

Bijvoorbeeld: register<T extends TViewBase>(view: typeof T)de resultaten in de volgende foutmelding:

[Ts] T verwijst slechts in type, maar wordt gebruikt als een waarde in.

Ik weet dat dit een oude vraag, maar hier gaat:

...
registerView(viewKlass: { new(): A.Views.View }):void
{
    var test = new viewKlass();
} 

Antwoord werd gevonden hier .

Afhankelijk van uw situatie, kan de drie oplossing blaten niet genoeg zijn:

1. myClass: new (name: string) => MyClass
2. interface IMyClass { new (name: string): MyClass; }; myClass: IMyClass
3. myClass: typeof MyClass

Er zijn gevallen waarin u zou willen sommigen noemen statische methoden zoals myClass.someMethod(). 1en 2zal niet toestaan dat u om dat te doen (en pls gebruik nooit in uw app), omdat ze niet weten over die methode.

Of zijn er gevallen waarin je wilt hebben MyClassals een abstracte klasse en een instantie van myClass met let instance = new myClass. In dat geval 3zal mislukken.

Wat ik doe in deze gevallen is een speciaal type te maken voor MyClassdat zal de kwesties die ik hierboven benadrukt, dat er ongeveer zo uitziet op te lossen:

type MyClassContructor<T extends MyClass> = typeof MyClass & Constructor<T>;

BTW. Vergeet niet om terugkeer types toe te voegen aan uw methodes, zodat u de juiste intellisense krijgen.

Dank u voor de essentie - een kleine verandering maakt het werken allemaal prima. In het onderstaande voorbeeld, we "nieuwe up" van de TestViewdoor te geven in het beton testweergave, veeleer dan te proberen om nieuwe binnen de methode.

module V.Views {
   export class View {
      public someVar: any;
      // the presence of constructor doesn't affect the error triggering
   }
}

module V.App {
    export class Application {
        public registerView(url: string, viewKlass: V.Views.View): void
        {
            var test = viewKlass;
        }
    }
}

var app = new V.App.Application;

class TestView extends V.Views.View {
}

class TestView2 extends V.Views.View {
}

app.registerView('', new TestView())
app.registerView('content/view/:slug/', new TestView2())