`nowa funkcja ()` z małą literą „f” w JavaScript

Mój kolega używa „nowej funkcji ()” z małą literą „f” do definiowania nowych obiektów w JavaScript. Wydaje się, że działa dobrze we wszystkich głównych przeglądarkach, a także wydaje się być dość skuteczny w ukrywaniu zmiennych prywatnych. Oto przykład:

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

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

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

Jak tylko "this" zostanie użyte, staje się publiczną własnością jakiegoś obiektuObj. Więc someObj.foo, someObj.get_inner () i someObj.set_inner () są dostępne publicznie. Dodatkowo set_inner () i get_inner () są metodami uprzywilejowanymi, więc mają dostęp do "inner" poprzez domknięcia.

Jednak nigdzie nie widziałem żadnego odniesienia do tej techniki. Nawet JSLint Douglasa Crockforda narzeka na to:

• dziwna konstrukcja. Usuń „nowy”

Używamy tej techniki w produkcji i wydaje się, że działa dobrze, ale trochę mnie to niepokoi, ponieważ nie jest nigdzie udokumentowane. Czy ktoś wie, czy to poprawna technika?

Widziałem już tę technikę, jest prawidłowa, używasz wyrażenia funkcyjnego tak, jakby to była funkcja konstruktora .

Ale IMHO, możesz osiągnąć to samo za pomocą wyrażenia funkcji automatycznego wywoływania, naprawdę nie widzę sensu używania newoperatora w ten sposób:

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

Celem newoperatora jest tworzenie nowych instancji obiektów, ustawianie [[Prototype]]właściwości wewnętrznej, możesz zobaczyć, jak jest to wykonane przez [Construct]właściwość wewnętrzną.

Powyższy kod da równoważny wynik.

Twój kod jest podobny do mniej dziwnej konstrukcji

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

    ...
};
var someObj = new Foo;

Aby wyjaśnić niektóre aspekty i sprawić, by JSLint Douglasa Crockforda nie narzekał na Twój kod, oto kilka przykładów instancji:

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

W przykładzie 3. wyrażenie w (...) jako wartość jest funkcją / konstruktorem. Wygląda to tak: new (function () {...}) (). Więc jeśli pominiemy nawiasy końcowe, jak w przykładzie 2, wyrażenie jest nadal prawidłowym wywołaniem konstruktora i wygląda jak przykład 4.

JSLint Douglasa Crockforda „myśli”, że chcesz przypisać funkcję do jakiegoś obiektuObj, a nie do jego instancji. W końcu to tylko ostrzeżenie, a nie błąd.