`new function ()` со строчной буквой "f" в JavaScript

Мой коллега использовал «new function ()» со строчной буквой «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 () являются привилегированными методами, поэтому они имеют доступ к «внутреннему» через замыкания.

Однако я нигде не встречал упоминания об этой технике. Даже JSLint Дугласа Крокфорда жалуется на это:

• странная конструкция. Удалить "новый"

Мы используем эту технику в производстве, и она, кажется, работает хорошо, но меня это немного беспокоит, потому что она нигде не задокументирована. Кто-нибудь знает, действительна ли это техника?

Я видел эту технику раньше, это действительно так, вы используете выражение функции, как если бы это была функция-конструктор .

Но 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 Дугласа Крокфорда не жаловаться на ваш код, вот несколько примеров создания экземпляров:

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. выражение in (...) as value является функцией / конструктором. Выглядит это так: new (function () {...}) (). Поэтому, если мы опускаем закрывающие скобки, как в примере 2, выражение все еще является допустимым вызовом конструктора и выглядит как пример 4.

JSLint Дугласа Крокфорда «думает», что вы хотели назначить функцию someObj, а не его экземпляру. А ведь это просто предупреждение, а не ошибка.