Pattern JavaScript per più costruttori

Ho bisogno di diversi costruttori per le mie istanze. Qual è un modello comune per questo?

JavaScript non ha il sovraccarico delle funzioni, incluso per metodi o costruttori.

Se vuoi che una funzione si comporti in modo diverso a seconda del numero e del tipo di parametri che le passi, dovrai annusarli manualmente. JavaScript chiamerà felicemente una funzione con più o meno del numero di argomenti dichiarato.

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);
}

Puoi anche accedere argumentscome un array per ottenere ulteriori argomenti passati.

Se hai bisogno di argomenti più complessi, può essere una buona idea inserirne alcuni o tutti all'interno di una ricerca di oggetti:

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

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

Python dimostra come gli argomenti predefiniti e denominati possono essere usati per coprire la maggior parte dei casi d'uso in un modo più pratico e grazioso rispetto al sovraccarico di funzioni. JavaScript, non così tanto.

Come trovi questo?

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

Foobar.prototype = {
    foobar: null
};

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

puoi usare la classe con metodi statici che restituiscono un'istanza di quella classe

    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)

con questo modello puoi creare multi costruttore

Non avevo voglia di farlo a mano come nella risposta di bobince, quindi ho semplicemente strappato completamente il modello delle opzioni del plugin di jQuery.

Ecco il costruttore:

//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;
}

Ecco diversi modi di istanziazione:

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']});

Ed ecco cosa ha fatto:

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]}

Andando oltre con la risposta di eruciforme, puoi concatenare la tua newchiamata nel tuo initmetodo.

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');

A volte, i valori predefiniti per i parametri sono sufficienti per più costruttori. E quando ciò non è sufficiente, provo a racchiudere la maggior parte delle funzionalità del costruttore in una funzione init (altri parametri) che viene chiamata in seguito. Considera anche l'utilizzo del concetto di fabbrica per creare un oggetto che possa creare efficacemente gli altri oggetti desiderati.

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

Rispondere perché questa domanda viene restituita prima in google ma le risposte ora sono obsolete.

È possibile utilizzare oggetti Destructuring come parametri del costruttore in ES6

Ecco lo schema:

Non puoi avere più costruttori, ma puoi usare la destrutturazione e i valori predefiniti per fare quello che vuoi.

export class myClass {

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

    // ..
  }
}

E puoi farlo se vuoi supportare un costruttore "senza parametri".

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)

Questo è l'esempio fornito per più costruttori nella programmazione in HTML5 con JavaScript e 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"));