clasa care trece drept cauze parametru „nu este reinnoita“ eroare

Incearca asta:

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

Există 2 moduri de a trece clase de dactilografiat. Daca tu:

• știu superclasa clasei ce trece prin (deja recomandat de Corey Alix):

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

• cunosc semnătura funcției clase constructor :

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

Pentru a completa celelalte răspunsuri; Am un tip de utilitate am păstra în jurul valorii de a asigura un parametru generic / câmp este o clasă / reinnoita:

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

Puteți asigura, atunci veți primi un constructor de clasă:

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

Newable<T>abordare funcționează în cazul în care typeof T--where Teste un type-- generic nu.

De exemplu: register<T extends TViewBase>(view: typeof T)rezultate în următoarea eroare:

[Ts] „T“ se referă numai la un tip, dar este folosit ca valoare aici.

Știu că aceasta este o întrebare veche, dar aici merge:

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

Raspuns a fost găsit aici .

În funcție de situația dumneavoastră, burduful trei soluție nu ar putea fi suficient:

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

Există cazuri în care s- ar dori pentru a apela unele statice metode , cum ar fi myClass.someMethod(). 1și 2nu vă va permite să facă acest lucru (și pls nu utilizați în aplicația dvs.) , deoarece ei nu știu despre această metodă.

Sau există cazuri când doriți să aveți MyClassca o abstractă clasă și de a crea o instanță de Clasa_Mea cu let instance = new myClass. În acest caz, 3va eșua.

Ceea ce fac în aceste cazuri , este de a crea un tip special pentru MyClasscă va rezolva problemele evidențiate mai sus am, care arata ceva de genul:

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

BTW. Nu uitați să adăugați tipuri de returnare la metodele tale astfel încât să obțineți Intellisense corespunzătoare.

Vă mulțumim pentru GIST - o ușoară schimbare totul de lucru bine face. În exemplul de mai jos, „noi up“ TestViewpentru a trece în ecranul de testare de beton, mai degrabă decât a încerca să - l noi în cadrul metodei.

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