Aufruf Konstruktor auf Typoskript-Klasse, ohne neue

Was ist das? Beschreiben Sie die gewünschte Form MyClass und den zugehörigen Konstruktor:

interface MyClass {
  val: number;
}

interface MyClassConstructor {
  new(val: number): MyClass;  //newable
  (val: number): MyClass; //callable
}

Beachten Sie, dass MyClassConstructor ist definiert als sowohl für callable als Funktion und newable als Konstruktor. Dann setzen Sie es um:

const MyClass: MyClassConstructor = function(this: MyClass | void, val: number) {
  if (!(this instanceof MyClass)) {
    return new MyClass(val);
  } else {
    this!.val = val;
  }
} as MyClassConstructor;

Den oben genannten Werken, obwohl es ein paar kleine Falten. Falten: die Implementierung gibt MyClass | undefined, und der compiler nicht erkennen, dass die MyClass return-Wert entspricht dem aufrufbare Funktion und die undefined Wert entspricht der newable Konstruktor... so dass es beschwert. Daher der as MyClassConstructor am Ende. Falten zwei: die this parameter derzeit nicht schmal über control-flow-Analyse, so müssen wir behaupten, dass this ist nicht void bei der Festlegung Ihrer val Eigentum, obwohl zu diesem Zeitpunkt wissen wir, es kann nicht sein void. So haben wir die Verwendung der nicht-null-Behauptung operator !.

Sowieso, Sie können überprüfen, dass diese funktioniert:

var a = new MyClass(5); //MyClass
var b = MyClass(5); //also MyClass

Hoffe, das hilft, viel Glück!

UPDATE

Nachteil: wie bereits erwähnt in @Paleo ist Antwort, wenn Ihr Ziel ist ES2015 oder später mit der class im Quellcode ausgegeben wird class in Ihrer kompilierten JavaScript, und diejenigen, die erfordern new() nach den spec. Ich habe gesehen, Fehler wie TypeError: Class constructors cannot be invoked without 'new'. Es ist durchaus möglich, dass einige JavaScript-Module zu ignorieren, die Skillung, und gerne akzeptieren-Funktion-Stil fordert auch. Wenn Sie nicht kümmern, diese Warnungen (z.B., Ihr Ziel ist ausdrücklich ES5 oder Sie wissen, du gehst zu laufen in einem von diesen nicht spec-konformen Umgebungen), dann können Sie bestimmt die Kraft, Maschinenschrift, zu gehen zusammen mit, dass:

class _MyClass {
  val: number;

  constructor(val: number) {
    if (!(this instanceof MyClass)) {
      return new MyClass(val);
    }

    this.val = val;
  }
}
type MyClass = _MyClass;
const MyClass = _MyClass as typeof _MyClass & ((val: number) => MyClass)

var a = new MyClass(5); //MyClass
var b = MyClass(5); //also MyClass

In diesem Fall haben Sie umbenannt MyClass aus dem Weg zu _MyClass, und definiert MyClass auch ein Typ (der gleiche wie _MyClass) und einen Wert (der gleiche wie der _MyClass - Konstruktor, sondern deren Typ behauptet auch aufrufbar sein, wie eine Funktion.) Dies funktioniert zur compile-Zeit, wie oben gesehen. Ob Ihre Laufzeit ist glücklich mit ihm ist vorbehaltlich der Einschränkungen oben. Ich persönlich würde stick an die Funktion Stil in meiner ursprünglichen Antwort, da ich weiß die sind beide aufrufbar und newable in es2015 und später.

Glück wieder!

UPDATE 2

Wenn Sie nur auf der Suche nach einem Weg, erklären die Art Ihrer bindNew() Funktion von diese Antwort, die eine spec-konform class und produziert etwas, was sowohl newable und aufrufbar wie eine Funktion, können Sie etwas wie das hier tun:

function bindNew<C extends { new(): T }, T>(Class: C & {new (): T}): C & (() => T);
function bindNew<C extends { new(a: A): T }, A, T>(Class: C & { new(a: A): T }): C & ((a: A) => T);
function bindNew<C extends { new(a: A, b: B): T }, A, B, T>(Class: C & { new(a: A, b: B): T }): C & ((a: A, b: B) => T);
function bindNew<C extends { new(a: A, b: B, d: D): T }, A, B, D, T>(Class: C & {new (a: A, b: B, d: D): T}): C & ((a: A, b: B, d: D) => T);
function bindNew(Class: any) {
  //your implementation goes here
}

Dies hat den Effekt, richtig tippe:

class _MyClass {
  val: number;

  constructor(val: number) {    
    this.val = val;
  }
}
type MyClass = _MyClass;
const MyClass = bindNew(_MyClass); 
//MyClass's type is inferred as typeof _MyClass & ((a: number)=> _MyClass)

var a = new MyClass(5); //MyClass
var b = MyClass(5); //also MyClass

Aber Hüte dich vor den überladenen Erklärungen für bindNew() arbeiten nicht für jeden möglichen Fall. Genauer gesagt, es funktioniert für Konstruktoren, die bis zu drei Parameter erforderlich. Konstruktoren mit optionalem Parameter oder mehrere überlast-Signaturen wird wahrscheinlich nicht richtig abgeleitet. So müssen Sie möglicherweise zu zwicken die Testungen je nach Anwendungsfall.

Okay, hoffe , dass hilft. Viel Glück ein drittes mal.

UPDATE 3, AUG 2018

Typoskript 3.0 eingeführt Tupel in Ruhe und spread-Positionen, so dass wir leicht fertig mit den Funktionen einer beliebigen Anzahl und Typ der Argumente, ohne die oben genannten überlastungen und Einschränkungen. Hier ist die neue Erklärung der bindNew():

declare function bindNew<C extends { new(...args: A): T }, A extends any[], T>(
  Class: C & { new(...args: A): T }
): C & ((...args: A) => T);

Lösung mit instanceof und extends arbeiten

Das problem mit den meisten von der Lösung, die ich bisher gesehen haben
verwenden x = X() statt x = new X()
sind:

1. x instanceof X funktioniert nicht
2. class Y extends X { } funktioniert nicht
3. console.log(x) Drucke, die einen anderen Typ als X
4. manchmal zusätzlich x = X() funktioniert, aber x = new X() nicht
5. manchmal ist es überhaupt nicht funktioniert, wenn Sie auf modernen Plattformen (ES6)

Meine Lösungen

TL;DR - Grundlegende Verwendung

Mithilfe des folgenden Codes (auch auf GitHub, siehe: ts-keine neuen) kann man schreiben:

interface A {
  x: number;
  a(): number;
}
const A = nn(
  class A implements A {
    x: number;
    constructor() {
      this.x = 0;
    }
    a() {
      return this.x += 1;
    }
  }
);

oder:

class $A {
  x: number;
  constructor() {
    this.x = 10;
  }
  a() {
    return this.x += 1;
  }
}
type A = $A;
const A = nn($A);

statt der üblichen:

class A {
  x: number;
  constructor() {
    this.x = 0;
  }
  a() {
    return this.x += 1;
  }
} 

nutzen zu können, entweder a = new A() oder a = A()
mit arbeiten instanceof, extends, richtige Vererbung und Unterstützung für moderne Zusammenstellung von Zielen (einige Lösungen funktionieren nur, wenn transpiled zu ES5 oder älter, denn Sie verlassen sich auf class übersetzt function die haben unterschiedliche Aufruf-Semantik).

Voller Beispiele

#1

type cA = () => A;

function nonew<X extends Function>(c: X): AI {
  return (new Proxy(c, {
    apply: (t, _, a) => new (<any>t)(...a)
  }) as any as AI);
}

interface A {
  x: number;
  a(): number;
}

const A = nonew(
  class A implements A {
    x: number;
    constructor() {
      this.x = 0;
    }
    a() {
      return this.x += 1;
    }
  }
);

interface AI {
  new (): A;
  (): A;
}

const B = nonew(
  class B extends A {
    a() {
      return this.x += 2;
    }
  }
);

#2

type NC<X> = { new (): X };
type FC<X> = { (): X };
type MC<X> = NC<X> & FC<X>;
function nn<X>(C: NC<X>): MC<X> {
  return new Proxy(C, {
    apply: (t, _, a) => new (<any>t)(...a)
  }) as MC<X>;
}

class $A {
  x: number;
  constructor() {
    this.x = 0;
  }
  a() {
    return this.x += 1;
  }
}
type A = $A;
const A: MC<A> = nn($A);
Object.defineProperty(A, 'name', { value: 'A' });

class $B extends $A {
  a() {
    return this.x += 2;
  }
}
type B = $B;
const B: MC<B> = nn($B);
Object.defineProperty(B, 'name', { value: 'B' });

#3

type NC<X> = { new (): X };
type FC<X> = { (): X };
type MC<X> = NC<X> & FC<X>;
function nn<X>(C: NC<X>): MC<X> {
  return new Proxy(C, {
    apply: (t, _, a) => new (<any>t)(...a)
  }) as MC<X>;
}

type $c = { $c: Function };

class $A {
  static $c = A;
  x: number;
  constructor() {
    this.x = 10;
    Object.defineProperty(this, 'constructor', { value: (this.constructor as any as $c).$c || this.constructor });
  }
  a() {
    return this.x += 1;
  }
}
type A = $A;
var A: MC<A> = nn($A);
$A.$c = A;
Object.defineProperty(A, 'name', { value: 'A' });

class $B extends $A {
  static $c = B;
  a() {
    return this.x += 2;
  }
}
type B = $B;
var B: MC<B> = nn($B);
$B.$c = B;
Object.defineProperty(B, 'name', { value: 'B' });

#2 Vereinfachtes

type NC<X> = { new (): X };
type FC<X> = { (): X };
type MC<X> = NC<X> & FC<X>;
function nn<X>(C: NC<X>): MC<X> {
  return new Proxy(C, {
    apply: (t, _, a) => new (<any>t)(...a)
  }) as MC<X>;
}

class $A {
  x: number;
  constructor() {
    this.x = 0;
  }
  a() {
    return this.x += 1;
  }
}
type A = $A;
const A: MC<A> = nn($A);

class $B extends $A {
  a() {
    return this.x += 2;
  }
}
type B = $B;
const B: MC<B> = nn($B);

#3 vereinfacht

type NC<X> = { new (): X };
type FC<X> = { (): X };
type MC<X> = NC<X> & FC<X>;
function nn<X>(C: NC<X>): MC<X> {
  return new Proxy(C, {
    apply: (t, _, a) => new (<any>t)(...a)
  }) as MC<X>;
}

class $A {
  x: number;
  constructor() {
    this.x = 10;
  }
  a() {
    return this.x += 1;
  }
}
type A = $A;
var A: MC<A> = nn($A);

class $B extends $A {
  a() {
    return this.x += 2;
  }
}
type B = $B;
var B: MC<B> = nn($B);

In #1 und #2:

• instanceof funktioniert
• extends funktioniert
• console.log korrekt gedruckt
• constructor Eigenschaft von Instanzen der Punkt, um den echten Konstruktor

In #3:

• instanceof funktioniert
• extends funktioniert
• console.log korrekt gedruckt
• constructor Eigenschaft von Instanzen der Punkt an der exponierten wrapper (das kann ein Vorteil oder Nachteil-je nach den Umständen)

Den vereinfachte Versionen bieten nicht alle meta-Daten, die für die Selbstbeobachtung, wenn Sie es nicht brauchen.

Siehe auch

• Meine Antwort: In Typoskript, kann eine Klasse benutzt werden, ohne das Schlüsselwort "new"?
• Mein GitHub repo mit mehr Beispielen: https://github.com/rsp/ts-no-new