JavaScript หลีกเลี่ยงคำหลักใหม่

เอาล่ะ มาดูตัวอย่าง new กัน:

function Bar() {
    var value = 1;
    // Whoops, sorry
    // As Bergi points out, if you have a return value then that overrides the normal object that is returned by new
    // Didn't even notice you have a return in here!
    /*
    return {
        method: function() {
            return value;
        }
    }
    */
    // This does the same thing (approximately) but now calling "(new Bar()) instanceof Bar" will be true
    this.method = function() {
        return value;
    };
}
Bar.prototype = {
    foo: function() {}
};

var b = new Bar();

ในคอนโซล Google Chrome b มีคุณสมบัติชื่อ __proto__ โดยทั่วไป เมื่อคุณโทร b.foo() ขั้นแรกเบราว์เซอร์จะมองหาวิธีการที่เรียกว่า foo หากไม่พบ จะปรากฏใน b.__proto__ และ b.__proto__.__proto__ ไปเรื่อยๆ

ประกาศ: b.__proto__ === Bar.prototype

นั่นหมายความว่าหากคุณโทร new Bar() ซ้ำๆ พวกเขาทั้งหมดจะมี __proto__ เหมือนกัน ซึ่งจะช่วยประหยัดหน่วยความจำ (สิ่งนี้มีผลข้างเคียงหากคุณกลายพันธุ์ Bar.prototype มันจะเปลี่ยนอินสแตนซ์ทั้งหมดของ Bar's __proto__ เช่นกัน)

มาดูวิธีการจากโรงงานของคุณกัน:

var Foo = function () {
    var foo = function () {

    };
    foo.prototype = {
        bar: function () { }
    };
    return new foo();
};

สิ่งนี้ไม่ช่วยประหยัดหน่วยความจำเพราะมันจะสร้าง prototype ใหม่ และตัวสร้างใหม่ ทุกครั้ง ที่คุณเรียก Foo() กล่าวอีกนัยหนึ่งถ้า

var f1 = new Foo(), f2 = new Foo();

คืนค่าเท็จต่อไปนี้: f1.constructor == f2.constructor และ f1.__proto__ == f2.__proto__ สิ่งนี้หมายความว่า? หมายความว่า f1 และ f2 ไม่ แชร์ prototype เหมือนกัน ดังนั้นจึงต้องทำซ้ำออบเจ็กต์ทุกครั้ง บางทีคุณอาจทำสิ่งนี้ได้:

var fooProto = {
  callFoo: function() { alert("test"); }
};
function Foo() {
    var foo = function() {};
    foo.prototype = fooProto;
    return new foo();
};

สิ่งนี้จะใช้จำนวนหน่วยความจำเท่ากันกับตัวสร้างปกติ

แก้ไขด้านข้าง: เบราว์เซอร์สมัยใหม่มีฟังก์ชันในตัวที่ทำงานคล้าย Foo ในตัวอย่างสุดท้าย คุณสามารถใช้ Object.create(fooProto) (แต่เฉพาะในเบราว์เซอร์รุ่นใหม่เท่านั้น)

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