Átadás osztály paraméter okok „nem newable” hibaüzenet

Próbáld ezt:

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

2 módon átadni osztályok géppel. Ha te:

• tudni, hogy a superclass az osztály te áthaladó (már javasolta Corey Alix):

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

• tudom, az aláírás az osztályok konstruktor függvényt :

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

Kiegészítve az egyéb válaszokat; Van egy segédprogram I. típusú tartani körül, hogy biztosítsa a generikus paraméter / mező egy osztály / newable:

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

Ezután biztosítása kapsz egy osztály konstruktor:

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

A Newable<T>megközelítés működik, ahol typeof T--where Tgenerikus type-- nem.

Például: register<T extends TViewBase>(view: typeof T)eredmények a következő hibaüzenet jelenik meg:

[TS] „T” csak utal olyan típusú, de van használatban, mint egy érték itt.

Tudom, hogy ez egy régi kérdés, de itt megy:

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

Volt a válasz itt .

A helyzettől függően a három megoldás ordít lehet, hogy nem elég:

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

Vannak olyan esetek, ahol szeretnénk felhívni néhány statikus módszerek, mint a myClass.someMethod(). 1és 2nem engedi, hogy erre (és pls ne használjon más az alkalmazás), mert nem tudni, hogy a módszer.

Vagy vannak olyan esetek, amikor azt szeretné, hogy MyClassegy absztrakt osztály, és hozzon létre egy példányt myClass az let instance = new myClass. Ebben az esetben 3nem fog működni.

Amit én csinálok, az ilyen esetekben az, hogy hozzon létre egy speciális típusát MyClass, hogy megoldja a problémákat kiemeltem, fent valahogy így néz ki:

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

BTW. Ne felejtsük el, hogy adjunk visszatérő típusok a módszerek, így kap a megfelelő IntelliSense.

Köszönjük a lényeg - egy kis változás teszi, hogy minden jól működik. Az alábbi példában az „új up” az TestView, hogy adja át a konkrét vizsgálat szerint ahelyett, hogy új ez a módszer.

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())