Modèle JavaScript pour plusieurs constructeurs

Question

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

Answer 1

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

Si vous voulez une fonction pour se comporter différemment selon le nombre et les types de paramètres que vous passez, vous aurez à renifler manuellement. JavaScript seront heureux de vous appeler une fonction avec plus ou moins de l'déclaré nombre d'arguments.

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 arguments comme un tableau, comme pour aller plus loin, le passage d'arguments dans.

Si vous avez besoin d'arguments plus complexes, il peut être une bonne idée de mettre tous ou certains d'entre eux à l'intérieur d'un objet de recherche:

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

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

Python montre comment par défaut et les arguments nommés peuvent être utilisés pour couvrir la plupart des cas d'utilisation plus pratique et gracieuse façon que la fonction de surcharge. JavaScript, pas tellement.

Answer 2

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

Answer 3

Je n'avais pas envie de le faire à la main comme dans la réponse de bobince, alors je viens de complètement arnaquer le modèle d'options du 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 manières 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]}
 

Answer 4

Pour aller plus loin avec la réponse de eruciform, vous pouvez enchaîner votre appel new dans votre méthode init .

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

Answer 5

Parfois, les valeurs par défaut pour les paramètres est assez pour plusieurs constructeurs. Et quand cela ne suffit pas, j'ai essayer d'envelopper la plupart des constructeur de fonctionnalités dans un init(autres-params) la fonction qui est appelée par la suite. Pensez également à utiliser le concept usine à fabriquer un objet qui peut effectivement créer les autres objets que vous souhaitez.

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