Padrão JavaScript para vários construtores

Preciso de construtores diferentes para minhas instâncias. Qual é um padrão comum para isso?

O JavaScript não possui sobrecarga de função, inclusive para métodos ou construtores.

Se você deseja que uma função se comporte de maneira diferente, dependendo do número e tipos de parâmetros que você passar para ela, será necessário farejá-los manualmente. Felizmente, o JavaScript chamará uma função com mais ou menos do que o número declarado de argumentos.

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

Você também pode acessar argumentscomo um array para obter mais argumentos passados.

Se você precisar de argumentos mais complexos, pode ser uma boa ideia colocar alguns ou todos eles dentro de uma pesquisa de objeto:

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

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

O Python demonstra como argumentos padrão e nomeados podem ser usados ​​para cobrir a maioria dos casos de uso de uma maneira mais prática e graciosa do que a sobrecarga de funções. JavaScript, nem tanto.

Como você encontra esse?

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

Foobar.prototype = {
    foobar: null
};

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

você pode usar classe com métodos estáticos que retornam uma instância dessa 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)

com esse padrão, você pode criar vários construtores

Não estava com vontade de fazê-lo manualmente, como na resposta de bobince, então apenas retirei completamente o padrão de opções do plugin do jQuery.

Aqui está o construtor:

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

Aqui estão diferentes maneiras de instanciação:

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

E aqui está o que isso fez:

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

Indo mais longe com a resposta da eruciforme, você pode encadear sua newchamada em seu initmétodo.

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

Às vezes, os valores padrão dos parâmetros são suficientes para vários construtores. E quando isso não é suficiente, tento agrupar a maior parte da funcionalidade do construtor em uma função init (other-params) chamada posteriormente. Considere também usar o conceito de fábrica para criar um objeto que possa efetivamente criar os outros objetos que você deseja.

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

Respondendo porque esta pergunta é retornada primeiro no google, mas as respostas estão desatualizadas.

Você pode usar objetos de Reestruturação como parâmetros do construtor no ES6

Aqui está o padrão:

Você não pode ter vários construtores, mas pode usar valores de desestruturação e padrão para fazer o que deseja.

export class myClass {

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

    // ..
  }
}

E você pode fazer isso se desejar oferecer suporte a um construtor 'sem parâmetros'.

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)

Este é o exemplo dado para vários construtores em Programação em HTML5 com JavaScript e CSS3 - 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"));