Pola JavaScript untuk banyak konstruktor

Saya memerlukan konstruktor yang berbeda untuk instance saya. Apa pola umum untuk itu?

JavaScript tidak memiliki kelebihan beban, termasuk untuk metode atau konstruktor.

Jika Anda ingin suatu fungsi berperilaku berbeda bergantung pada jumlah dan jenis parameter yang Anda berikan, Anda harus mengendusnya secara manual. JavaScript akan dengan senang hati memanggil fungsi dengan lebih banyak atau lebih sedikit dari jumlah argumen yang dideklarasikan.

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

Anda juga dapat mengakses argumentssebagai array-like untuk mendapatkan argumen lebih lanjut yang diteruskan.

Jika Anda membutuhkan argumen yang lebih kompleks, ada baiknya untuk meletakkan beberapa atau semuanya di dalam pencarian objek:

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

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

Python mendemonstrasikan bagaimana argumen default dan bernama dapat digunakan untuk mencakup sebagian besar kasus penggunaan dengan cara yang lebih praktis dan anggun daripada overloading fungsi. JavaScript, tidak terlalu banyak.

Bagaimana Anda menemukan yang ini?

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

Foobar.prototype = {
    foobar: null
};

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

Anda bisa menggunakan kelas dengan metode statis yang mengembalikan instance kelas itu

    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)

dengan pola ini Anda dapat membuat multi konstruktor

Tidak merasa ingin melakukannya dengan tangan seperti pada jawaban bobince, jadi saya baru saja merobek pola opsi plugin jQuery.

Inilah konstruktornya:

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

Berikut cara berbeda dalam pembuatan contoh:

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

Dan inilah yang membuatnya:

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

Lebih jauh dengan jawaban eruciform, Anda dapat newmenghubungkan panggilan Anda ke dalam initmetode Anda .

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

Terkadang, nilai default untuk parameter cukup untuk banyak konstruktor. Dan ketika itu tidak mencukupi, saya mencoba untuk membungkus sebagian besar fungsionalitas konstruktor menjadi fungsi init (other-params) yang dipanggil setelahnya. Pertimbangkan juga untuk menggunakan konsep pabrik untuk membuat sebuah objek yang secara efektif dapat membuat objek lain yang Anda inginkan.

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

Menjawab karena pertanyaan ini dikembalikan pertama kali di google tetapi jawaban sekarang sudah ketinggalan zaman.

Anda dapat menggunakan objek Destructuring sebagai parameter konstruktor di ES6

Berikut polanya:

Anda tidak dapat memiliki banyak konstruktor, tetapi Anda dapat menggunakan nilai destruktur dan default untuk melakukan apa yang Anda inginkan.

export class myClass {

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

    // ..
  }
}

Dan Anda dapat melakukan ini jika Anda ingin mendukung konstruktor 'tanpa parameter'.

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)

Ini adalah contoh yang diberikan untuk beberapa konstruktor dalam Pemrograman dalam HTML5 dengan JavaScript dan CSS3 - Referensi Ujian .

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