รูปแบบ JavaScript สำหรับตัวสร้างหลายตัว

ฉันต้องการตัวสร้างที่แตกต่างกันสำหรับอินสแตนซ์ของฉัน รูปแบบทั่วไปสำหรับสิ่งนั้นคืออะไร?

JavaScript ไม่มีฟังก์ชันโอเวอร์โหลดรวมถึงวิธีการหรือตัวสร้าง

หากคุณต้องการให้ฟังก์ชันทำงานแตกต่างกันขึ้นอยู่กับจำนวนและประเภทของพารามิเตอร์ที่คุณส่งผ่านไปคุณจะต้องดมกลิ่นด้วยตนเอง JavaScript ยินดีจะเรียกใช้ฟังก์ชันที่มีอาร์กิวเมนต์มากกว่าหรือน้อยกว่าที่ประกาศไว้

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

คุณยังสามารถเข้าถึงargumentsแบบอาร์เรย์เพื่อรับอาร์กิวเมนต์อื่น ๆ ที่ส่งผ่านเข้ามา

หากคุณต้องการอาร์กิวเมนต์ที่ซับซ้อนมากขึ้นอาจเป็นความคิดที่ดีที่จะใส่บางส่วนหรือทั้งหมดไว้ในการค้นหาวัตถุ:

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

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

Python แสดงให้เห็นว่าอาร์กิวเมนต์เริ่มต้นและตั้งชื่อสามารถใช้เพื่อให้ครอบคลุมกรณีการใช้งานส่วนใหญ่ได้อย่างไรในทางปฏิบัติและสง่างามมากกว่าการใช้งานฟังก์ชันมากเกินไป JavaScript ไม่มาก

เจออันนี้ทีไร

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

Foobar.prototype = {
    foobar: null
};

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

คุณสามารถใช้คลาสด้วยวิธีการคงที่ที่ส่งคืนอินสแตนซ์ของคลาสนั้น

    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)

ด้วยรูปแบบนี้คุณสามารถสร้างตัวสร้างหลายตัวได้

ไม่รู้สึกเหมือนทำด้วยมือเหมือนในคำตอบของ Bobince ดังนั้นฉันจึงฉีกรูปแบบตัวเลือกปลั๊กอินของ jQuery ออกไปโดยสิ้นเชิง

นี่คือตัวสร้าง:

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

วิธีต่างๆในการสร้างอินสแตนซ์มีดังนี้

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

และนี่คือสิ่งที่สร้างขึ้น:

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

ยิ่งไปกว่านั้นด้วยคำตอบของ eruciform คุณสามารถเชื่อมโยงการnewโทรเข้ากับ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');

บางครั้งค่าเริ่มต้นสำหรับพารามิเตอร์ก็เพียงพอสำหรับตัวสร้างหลายตัว และเมื่อไม่เพียงพอฉันพยายามรวมฟังก์ชันตัวสร้างส่วนใหญ่ไว้ในฟังก์ชัน init (พารามิเตอร์อื่น ๆ ) ที่ถูกเรียกใช้ในภายหลัง ลองพิจารณาใช้แนวคิดของโรงงานเพื่อสร้างวัตถุที่สามารถสร้างวัตถุอื่น ๆ ที่คุณต้องการได้อย่างมีประสิทธิภาพ

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

ตอบเนื่องจากคำถามนี้ถูกส่งกลับก่อนใน Google แต่ตอนนี้คำตอบล้าสมัยแล้ว

คุณสามารถใช้วัตถุทำลายล้างเป็นพารามิเตอร์ตัวสร้างใน ES6

นี่คือรูปแบบ:

คุณไม่สามารถมีตัวสร้างหลายตัวได้ แต่คุณสามารถใช้การทำลายโครงสร้างและค่าเริ่มต้นเพื่อทำสิ่งที่คุณต้องการได้

export class myClass {

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

    // ..
  }
}

และคุณสามารถทำได้หากคุณต้องการสนับสนุนตัวสร้าง 'ไร้พารามิเตอร์'

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)

นี่คือตัวอย่างที่ได้รับสำหรับการก่อสร้างหลายแห่งในการเขียนโปรแกรมใน HTML5 ด้วย JavaScript และ 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"));