`new function ()` mit Kleinbuchstaben "f" in JavaScript

Mein Kollege hat "new function ()" mit einem Kleinbuchstaben "f" verwendet, um neue Objekte in JavaScript zu definieren. Es scheint in allen gängigen Browsern gut zu funktionieren und es scheint auch ziemlich effektiv zu sein, private Variablen zu verbergen. Hier ist ein Beispiel:

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

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

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

Sobald "this" verwendet wird, wird es ein öffentliches Eigentum von someObj. SomeObj.foo, someObj.get_inner () und someObj.set_inner () sind also alle öffentlich verfügbar. Darüber hinaus sind set_inner () und get_inner () privilegierte Methoden, sodass sie über Closures Zugriff auf "inner" haben.

Ich habe jedoch nirgendwo einen Hinweis auf diese Technik gesehen. Sogar Douglas Crockfords JSLint beschwert sich darüber:

• seltsame Konstruktion. 'Neu' löschen

Wir verwenden diese Technik in der Produktion und sie scheint gut zu funktionieren, aber ich bin etwas besorgt darüber, weil sie nirgendwo dokumentiert ist. Weiß jemand, ob dies eine gültige Technik ist?

Ich habe diese Technik schon einmal gesehen. Sie ist gültig. Sie verwenden einen Funktionsausdruck, als wäre es eine Konstruktorfunktion .

Aber meiner Meinung nach können Sie dasselbe mit einem automatisch aufrufenden Funktionsausdruck erreichen. Ich sehe keinen Sinn darin, den newOperator auf diese Weise zu verwenden:

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

Der Zweck des newOperators besteht darin, neue Objektinstanzen zu erstellen und die [[Prototype]]interne Eigenschaft einzurichten . Sie können sehen, wie dies durch die [Construct]interne Eigenschaft erfolgt.

Der obige Code führt zu einem äquivalenten Ergebnis.

Ihr Code ähnelt dem weniger seltsamen Konstrukt

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

    ...
};
var someObj = new Foo;

Um einige Aspekte zu klären und Douglas Crockfords JSLint dazu zu bringen, sich nicht über Ihren Code zu beschweren, hier einige Beispiele für die Instanziierung:

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

In Beispiel 3. ist der Ausdruck in (...) als Wert eine Funktion / ein Konstruktor. Es sieht so aus: new (function () {...}) (). Wenn wir also Endklammern wie in Beispiel 2 weglassen, ist der Ausdruck immer noch ein gültiger Konstruktoraufruf und sieht aus wie Beispiel 4.

Douglas Crockfords JSLint "denkt", dass Sie die Funktion someObj zuweisen wollten, nicht seiner Instanz. Und schließlich ist es nur eine Warnung, kein Fehler.