Konstruktorüberladung in TypeScript

Question

Hat jemand Konstruktor Überladen in TypeScript getan. Auf Seite 64 der Sprachspezifikation (v 0.8) gibt es Anweisungen, die Konstruktorüberladungen beschreiben, aber es wurde kein Beispielcode angegeben.

Ich probiere gerade eine ganz einfache Klassendeklaration aus, die so aussieht,

interface IBox {    
    x : number;
    y : number;
    height : number;
    width : number;
}

class Box {
    public x: number;
    public y: number;
    public height: number;
    public width: number;

    constructor(obj: IBox) {    
        this.x = obj.x;
        this.y = obj.y;
        this.height = obj.height;
        this.width = obj.width;
    }   

    constructor() {
        this.x = 0;
        this.y = 0;
        this.width = 0;
        this.height = 0;
    }
}

Wenn mit tsc BoxSample.ts ausgeführt wird, wirft es eine doppelte Konstruktordefinition aus - was offensichtlich ist. Jede Hilfe ist willkommen.

Answer 1

Im Allgemeinen ist es bei N-Überlastungen besser, diese zu verwenden:

constructor(obj?: {fromType1: IType1} | {fromType2: IType2}) {    
    if(obj){
      if(obj.fromType1){
        //must be of form IType1
      } else if(obj.fromType2){
        //must have used a IType2
      } else {
        throw "Invalid argument 1"
      }
    } else {
      //obj not given
    }
}   

Zumindest können wir jetzt prüfen, welchen Weg wir einschlagen müssen und entsprechend handeln.

Answer 2

Wie chuckj sagte, ist die einfache Antwort ein optionaler Parameter, aber was, wenn wir einen Konstruktor mit mehr als einem Parameter überladen oder die Reihenfolge der Parameter ändern wollen?

Wie sich herausstellte, können Konstruktoren genau wie Funktionen überladen werden:

class FooBar {
  public foo?: number;
  public bar?: string;

  // Constructor A
  constructor(foo: number, bar?: string);
  // Constructor B
  constructor(bar: string, foo?: number);
  // Constructor C
  constructor(bar: string);
  // Constructor D
  constructor(foo: number);
  // Constructor E
  constructor();

  constructor(...args: any[]) {
    switch (args.length) {
      case 2:
        if (typeof args[0] === "number") {
          this.foo = args[0];
          this.bar = args[1];
        } else {
          this.bar = args[0];
          this.foo = args[1];
        }
        break;
      case 1:
        if (typeof args[0] === "number") {
          this.foo = args[0];
        } else {
          this.bar = args[0];
        }
    }

    console.log(this.foo, this.bar);
  }
}

const fooBarConstructorA = new FooBar("150", 25);
const fooBarConstructorB = new FooBar(25, "150");
const fooBarConstructorC = new FooBar("150");
const fooBarConstructorD = new FooBar("150");
const fooBarConstructorE = new FooBar();

Answer 3

Sie sollten bedenken, dass...

contructor()

constructor(a:any, b:any, c:any)

Es ist dasselbe wie new() ou new("a","b","c")

So

constructor(a?:any, b?:any, c?:any)

ist das gleiche wie oben und ist flexibler...

new() ou new("a") ou new("a","b") ou new("a","b","c")