TypeScript - Überladung eines Konstruktors / mehrerer Konstruktoren

In diesem Artikel wird gezeigt, wie der Konstruktor in TypeScript überladen wird. Im TypeScript-Konstruktor sieht das Überladen anders aus, als in C++, Java, oder C#. Die Hauptidee des Konstruktorüberladens besteht darin, dass ein gemeinsamer Konstruktor erstellt wird. Dieser gemeinsamen Konstruktor überprüft, welche Art von Parametern zum Erstellen des Objekts übergeben wird, und später eine Logik für den richtigen Fall erstellt. Nützlich ist es, Konstruktordefinitionen hinzuzufügen, damit andere Programmierer wissen, wie man Klassen ruchtig verwenden soll. 

Einfache Übersicht:

class MyClassName {

    public constructor(a : number);
    public constructor(a : number, b : number);
    public constructor(array : Array<number>);

    public constructor(...args : Array<any>) { // gemeinsamer Konstruktor

        // Argumente überprüfen und das richtige Szenario ausführen
       // oder neuen Fehler auslösen ('Konstruktor wird nicht unterstützt!');
    }
}

// MyClassName wird hier verwendet...

Unten findet man ein praktisches Beispiel:

1. Mehrere Konstruktoren - ein praktisches Beispiel

Das Überladen von Konstruktoren erfordert ein bisschen Logik zu schreiben, um festzustellen, welcher Konstruktor verwendet wurde. public constructor(...args : Array<any>) entspricht einer allgemeinen Logik, bei der abhängig von den verwendeten Argumenten der Sonderfall der Objekterstellung verwendet werden soll.  

class Point {
    private coordinates : Array<number>;

    public constructor(x : number, y : number);
    public constructor(x : number, y : number, z : number);
    public constructor(x : number, y : number, z : number, ...coordinates : Array<number>);
    public constructor(coordinates : Array<number>);

    public constructor(...args : Array<any>) { // gemeinsamer logischer Konstruktor
        if(args.length == 0)
            throw new Error('Arguments are not defined.');
    
        let arg = args[0];

        if(Array.isArray(arg)) {
            if(arg.length < 2)
                throw new Error('Minimum number of dimmensions is 2.');
        
            this.coordinates = arg;
        } else
            this.coordinates = args;
    }

    public getCoordinate(dimmension : number) : number {
        return this.coordinates[dimmension];
    }

    public toString() : string {
        let result = '{';

        if(this.coordinates.length > 0) {
            result += ' ' + this.coordinates[0];

            for(let i = 1; i < this.coordinates.length; ++i)
                result += ', ' + this.coordinates[i];
        }

        return result + ' }';
    }
}

let a = new Point(1, 2);
let b = new Point(1, 2, 3);
let c = new Point(1, 2, 3, 4);
let d = new Point([1, 2]);
let e = new Point([1, 2, 3]);
let f = new Point([1, 2, 3, 4]);

console.log(a.toString());
console.log(b.toString());
console.log(c.toString());
console.log(d.toString());
console.log(e.toString());
console.log(f.toString());

Ausgabe:

{ 1, 2 }
{ 1, 2, 3 }
{ 1, 2, 3, 4 }
{ 1, 2 }
{ 1, 2, 3 }
{ 1, 2, 3, 4 }

Hinweis: Eine große Anzahl von Überlastungen kann zu einer großen Anzahl von Fehlern führen. Daher ist es besser, diese Technik zu vermeiden. 

2. Literaturverzeichnis

1. Methods Overloading - Microsoft Docs