JavaScript-Muster für mehrere Konstruktoren

Ich benötige verschiedene Konstruktoren für meine Instanzen. Was ist ein gängiges Muster dafür?

JavaScript hat keine Funktionsüberladung, auch nicht für Methoden oder Konstruktoren.

Wenn sich eine Funktion je nach Anzahl und Art der Parameter, die Sie an sie übergeben, unterschiedlich verhalten soll, müssen Sie sie manuell abhören. JavaScript ruft gerne eine Funktion mit mehr oder weniger als der angegebenen Anzahl von Argumenten auf.

function foo(a, b) {
    if (b===undefined) // parameter was omitted in call
        b= 'some default value';

    if (typeof(a)==='string')
        this._constructInSomeWay(a, b);
    else if (a instanceof MyType)
        this._constructInSomeOtherWay(a, b);
}

Sie können auch argumentsals Array zugreifen , um weitere Argumente zu erhalten.

Wenn Sie komplexere Argumente benötigen, kann es eine gute Idee sein, einige oder alle in eine Objektsuche einzufügen:

function bar(argmap) {
    if ('optionalparam' in argmap)
        this._constructInSomeWay(argmap.param, argmap.optionalparam);
    ...
}

bar({param: 1, optionalparam: 2})

Python zeigt, wie Standard- und benannte Argumente verwendet werden können, um die meisten Anwendungsfälle praktischer und eleganter abzudecken als das Überladen von Funktionen. JavaScript, nicht so sehr.

Wie findest du das?

function Foobar(foobar) {
    this.foobar = foobar;
}

Foobar.prototype = {
    foobar: null
};

Foobar.fromComponents = function(foo, bar) {
    var foobar = foo + bar;
    return new this(foobar);
};

Sie können eine Klasse mit statischen Methoden verwenden, die eine Instanz dieser Klasse zurückgeben

    class MyClass {
        constructor(a,b,c,d){
            this.a = a
            this.b = b
            this.c = c
            this.d = d
        }
        static BAndCInstance(b,c){
            return new MyClass(null,b,c)
        }
        static BAndDInstance(b,d){
            return new MyClass(null,b, null,d)
        }
    }

    //new Instance just with a and other is nul this can
    //use for other params that are first in constructor
    const myclass=new MyClass(a)

    //an Instance that has b and c params
    const instanceWithBAndC = MyClass.BAndCInstance(b,c)

    //another example for b and d
    const instanceWithBAndD = MyClass.BAndDInstance(b,d)

Mit diesem Muster können Sie mehrere Konstruktoren erstellen

Ich hatte keine Lust, es von Hand zu machen, wie in Bobince's Antwort, also habe ich das Plugin-Optionsmuster von jQuery komplett abgerissen.

Hier ist der Konstruktor:

//default constructor for Preset 'class'
function Preset(params) {
    var properties = $.extend({
        //these are the defaults
        id: null,
        name: null,
        inItems: [],
        outItems: [],
    }, params);

    console.log('Preset instantiated');
    this.id = properties.id;
    this.name = properties.name;
    this.inItems = properties.inItems;
    this.outItems = properties.outItems;
}

Hier sind verschiedene Arten der Instanziierung:

presetNoParams = new Preset(); 
presetEmptyParams = new Preset({});
presetSomeParams = new Preset({id: 666, inItems:['item_1', 'item_2']});
presetAllParams = new Preset({id: 666, name: 'SOpreset', inItems: ['item_1', 'item_2'], outItems: ['item_3', 'item_4']});

Und hier ist, was das gemacht hat:

presetNoParams
Preset {id: null, name: null, inItems: Array[0], outItems: Array[0]}

presetEmptyParams
Preset {id: null, name: null, inItems: Array[0], outItems: Array[0]}

presetSomeParams
Preset {id: 666, name: null, inItems: Array[2], outItems: Array[0]}

presetAllParams
Preset {id: 666, name: "SOpreset", inItems: Array[2], outItems: Array[2]}

Wenn Sie die Antwort von eruciform weiter verfolgen, können Sie Ihren newAnruf in Ihre initMethode einbinden .

function Foo () {
    this.bar = 'baz';
}

Foo.prototype.init_1 = function (bar) {
    this.bar = bar;
    return this;
};

Foo.prototype.init_2 = function (baz) {
    this.bar = 'something to do with '+baz;
    return this;
};

var a = new Foo().init_1('constructor 1');
var b = new Foo().init_2('constructor 2');

Manchmal reichen Standardwerte für Parameter für mehrere Konstruktoren aus. Und wenn das nicht ausreicht, versuche ich, den größten Teil der Konstruktorfunktionalität in eine init-Funktion (other-params) zu packen, die anschließend aufgerufen wird. Verwenden Sie auch das Factory-Konzept, um ein Objekt zu erstellen, mit dem die anderen gewünschten Objekte effektiv erstellt werden können.

http://en.wikipedia.org/w/index.php?title=Factory_method_pattern&oldid=363482142#Javascript

Beantworten, da diese Frage zuerst in Google zurückgegeben wird, die Antworten jedoch veraltet sind.

Sie können Destructuring-Objekte als Konstruktorparameter in ES6 verwenden

Hier ist das Muster:

Sie können nicht mehrere Konstruktoren haben, aber Sie können Destrukturierungs- und Standardwerte verwenden, um das zu tun, was Sie wollen.

export class myClass {

  constructor({ myArray = [1, 2, 3], myString = 'Hello World' }) {

    // ..
  }
}

Und Sie können dies tun, wenn Sie einen 'parameterlosen' Konstruktor unterstützen möchten.

export class myClass {

      constructor({myArray = [1, 2, 3], myString = 'Hello World'} = {}) {

        // ..
      }
}

export default class Order {

    static fromCart(cart) {
        var newOrder = new Order();
        newOrder.items = cart.items;
        newOrder.sum = cart.sum;

        return newOrder;
    }

    static fromOrder(id, order) {
        var newOrder = new Order();
        newOrder.id = id;
        newOrder.items = order.items;
        newOrder.sum = order.sum;

        return newOrder;
    }
}

Useges:

  var newOrder = Order.fromCart(cart)
  var newOrder = Order.fromOrder(id, oldOrder)

Dies ist das Beispiel für mehrere Konstruktoren in der Programmierung in HTML5 mit JavaScript und CSS3 - Exam Ref .

function Book() {
    //just creates an empty book.
}


function Book(title, length, author) {
    this.title = title;
    this.Length = length;
    this.author = author;
}

Book.prototype = {
    ISBN: "",
    Length: -1,
    genre: "",
    covering: "",
    author: "",
    currentPage: 0,
    title: "",

    flipTo: function FlipToAPage(pNum) {
        this.currentPage = pNum;
    },

    turnPageForward: function turnForward() {
        this.flipTo(this.currentPage++);
    },

    turnPageBackward: function turnBackward() {
        this.flipTo(this.currentPage--);
    }
};

var books = new Array(new Book(), new Book("First Edition", 350, "Random"));