tutorial - Patrón de JavaScript para múltiples constructores

strip_tags javascript

Question

Necesito diferentes constructores para mis instancias. ¿Cuál es un patrón común para eso?

Answer 1

¿Cómo encuentras este?

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

Foobar.prototype = {
    foobar: null
};

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

Answer 2

A veces, los valores predeterminados para los parámetros son suficientes para múltiples constructores. Y cuando eso no es suficiente, intento envolver la mayoría de las funciones del constructor en una función init (other-params) que se llama después. También considere utilizar el concepto de fábrica para crear un objeto que pueda crear efectivamente los otros objetos que desee.

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

Answer 3

Así que sí, como se expresó anteriormente, con múltiples soluciones, lo que se ve en general en cosas como la fecha son los métodos estáticos:

Date.UTC("some params"); 

Aunque este no es un constructor apropiado, esto es

function someObject(a,b,c,d,e,f) {
 a = a || "default";
 b = b || "defaultb"
}

¿Puede ir mecanografiado o transpilelo a es5?

constructor(a:string, b = "default value", c:number? //optional
) {

}

Answer 4

Este es el ejemplo dado para múltiples constructores en Programación en HTML5 con JavaScript y CSS3 - Ref . De 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"));

Answer 5

JavaScript no tiene una función de sobrecarga, incluidos los métodos o constructores.

Si desea que una función se comporte de manera diferente según el número y los tipos de parámetros que le pase, deberá olfatearlos manualmente. JavaScript gustará llamar a una función con más o menos que el 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);
}

También puede acceder a los arguments como una matriz para obtener cualquier otro argumento pasado.

Si necesita argumentos más complejos, puede ser una buena idea colocar algunos o todos dentro de una búsqueda de objetos:

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

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

Python demuestra cómo los argumentos predeterminados y nombrados se pueden usar para cubrir la mayoría de los casos de uso de una manera más práctica y elegante que la sobrecarga de funciones. JavaScript, no tanto.

Answer 6

No tenía ganas de hacerlo a mano como en la respuesta de Bobince, así que simplemente arranqué por completo el patrón de opciones del complemento de jQuery.

Aquí está el constructor:

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

Aquí hay diferentes formas de creación de instancias:

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

Y esto es lo que hizo:

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 7

Yendo más allá con la respuesta de eruciform, puedes encadenar tu new llamada a tu método 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'');