Modèle JavaScript pour plusieurs constructeurs

J'ai besoin de différents constructeurs pour mes instances. Quel est le modèle courant pour cela?

JavaScript n'a pas de surcharge de fonctions, y compris pour les méthodes ou les constructeurs.

Si vous souhaitez qu'une fonction se comporte différemment en fonction du nombre et des types de paramètres que vous lui passez, vous devrez les renifler manuellement. JavaScript appellera volontiers une fonction avec plus ou moins que le nombre d'arguments déclaré.

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

Vous pouvez également accéder argumentssous forme de tableau pour obtenir d'autres arguments transmis.

Si vous avez besoin d'arguments plus complexes, il peut être judicieux de les placer tout ou partie dans une recherche d'objet:

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

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

Python montre comment les arguments par défaut et nommés peuvent être utilisés pour couvrir la plupart des cas d'utilisation d'une manière plus pratique et plus élégante que la surcharge de fonctions. JavaScript, pas tellement.

Comment trouvez-vous celui-ci?

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

Foobar.prototype = {
    foobar: null
};

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

vous pouvez utiliser une classe avec des méthodes statiques qui retournent une instance de cette 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)

avec ce modèle, vous pouvez créer plusieurs constructeurs

Je n'avais pas envie de le faire à la main comme dans la réponse de bobince, alors j'ai complètement déchiré le modèle d'options de plugin de jQuery.

Voici le constructeur:

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

Voici différentes méthodes d'instanciation:

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

Et voici ce que cela a fait:

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

En allant plus loin avec la réponse d'eruciform, vous pouvez enchaîner votre newappel dans votre initméthode.

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

Parfois, les valeurs par défaut des paramètres sont suffisantes pour plusieurs constructeurs. Et quand cela ne suffit pas, j'essaie d'envelopper la plupart des fonctionnalités du constructeur dans une fonction init (other-params) qui est appelée par la suite. Pensez également à utiliser le concept d'usine pour créer un objet capable de créer efficacement les autres objets de votre choix.

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

Répondre car cette question est renvoyée en premier dans google mais les réponses sont désormais obsolètes.

Vous pouvez utiliser des objets de destruction comme paramètres de constructeur dans ES6

Voici le modèle:

Vous ne pouvez pas avoir plusieurs constructeurs, mais vous pouvez utiliser la déstructuration et les valeurs par défaut pour faire ce que vous voulez.

export class myClass {

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

    // ..
  }
}

Et vous pouvez le faire si vous souhaitez prendre en charge un constructeur «sans paramètre».

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

Utilisations:

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

C'est l'exemple donné pour plusieurs constructeurs en Programmation en HTML5 avec JavaScript et CSS3 - Réf d'examen .

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