`ฟังก์ชันใหม่ ()` ด้วยตัวพิมพ์เล็ก“ f” ใน JavaScript

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

    var someObj = new function () {
        var inner = 'some value';
        this.foo = 'blah';

        this.get_inner = function () {
            return inner;
        };

        this.set_inner = function (s) {
            inner = s;
        };
    };

ทันทีที่ใช้ "this" จะกลายเป็นสมบัติสาธารณะของ someObj ดังนั้น someObj.foo, someObj.get_inner () และ someObj.set_inner () จึงมีให้บริการแบบสาธารณะ นอกจากนี้ set_inner () และ get_inner () เป็นวิธีการที่ได้รับสิทธิพิเศษดังนั้นจึงสามารถเข้าถึง "inner" ได้โดยการปิด

อย่างไรก็ตามฉันไม่เห็นการอ้างอิงถึงเทคนิคนี้ที่ใดเลย แม้แต่ JSLint ของ Douglas Crockford ก็บ่นเกี่ยวกับเรื่องนี้:

• การก่อสร้างแปลก ๆ ลบ "ใหม่"

เรากำลังใช้เทคนิคนี้ในการผลิตและดูเหมือนว่าจะทำงานได้ดี แต่ฉันค่อนข้างกังวลเกี่ยวกับเรื่องนี้เพราะไม่ได้บันทึกไว้ที่ใด ไม่มีใครรู้ว่านี่เป็นเทคนิคที่ถูกต้องหรือไม่?

ฉันเคยเห็นเทคนิคนั้นมาก่อนมันถูกต้องคุณกำลังใช้นิพจน์ฟังก์ชันราวกับว่ามันเป็นฟังก์ชันตัวสร้าง

แต่ IMHO คุณสามารถบรรลุสิ่งเดียวกันได้ด้วยนิพจน์ฟังก์ชันเรียกใช้อัตโนมัติฉันไม่เห็นจุดที่จะใช้ตัวnewดำเนินการในลักษณะนั้น:

var someObj = (function () {
    var instance = {},
        inner = 'some value';

    instance.foo = 'blah';

    instance.get_inner = function () {
        return inner;
    };

    instance.set_inner = function (s) {
        inner = s;
    };

    return instance;
})();

วัตถุประสงค์ของตัวnewดำเนินการคือการสร้างอินสแตนซ์ออบเจ็กต์ใหม่การตั้งค่า[[Prototype]]คุณสมบัติภายในคุณสามารถดูว่าสิ่งนี้ทำโดย[Construct]คุณสมบัติภายในอย่างไร

โค้ดด้านบนจะให้ผลลัพธ์ที่เทียบเท่า

รหัสของคุณคล้ายกับโครงสร้างที่แปลกน้อยกว่า

function Foo () {
    var inner = 'some value';
    this.foo = 'blah';

    ...
};
var someObj = new Foo;

เพื่อชี้แจงบางแง่มุมและทำให้ JSLint ของ Douglas Crockford ไม่บ่นเกี่ยวกับโค้ดของคุณนี่คือตัวอย่างบางส่วนของการสร้างอินสแตนซ์:

1. o = new Object(); // normal call of a constructor

2. o = new Object;   // accepted call of a constructor

3. var someObj = new (function () {  
    var inner = 'some value';
    this.foo = 'blah';

    this.get_inner = function () {
        return inner;
    };

    this.set_inner = function (s) {
        inner = s;
    };
})(); // normal call of a constructor

4. var someObj = new (function () {  
    var inner = 'some value';
    this.foo = 'blah';

    this.get_inner = function () {
        return inner;
    };

    this.set_inner = function (s) {
        inner = s;
    };
}); // accepted call of a constructor

ในตัวอย่างที่ 3 นิพจน์ใน (... ) เป็นค่าเป็นฟังก์ชัน / ตัวสร้าง ดูเหมือนว่าใหม่ (ฟังก์ชัน () {... }) () ดังนั้นหากเราไม่ใส่วงเล็บปิดท้ายตามตัวอย่างที่ 2 นิพจน์ยังคงเป็นการเรียกตัวสร้างที่ถูกต้องและดูเหมือนตัวอย่างที่ 4

JSLint ของ Douglas Crockford "คิดว่า" คุณต้องการกำหนดฟังก์ชันให้กับ someObj ไม่ใช่อินสแตนซ์ และท้ายที่สุดมันเป็นเพียงคำเตือนไม่ใช่ข้อผิดพลาด