`nouvelle fonction ()` avec "f" minuscule en JavaScript

Mon collègue a utilisé "new function ()" avec un "f" minuscule pour définir de nouveaux objets en JavaScript. Il semble bien fonctionner dans tous les principaux navigateurs et il semble également être assez efficace pour masquer les variables privées. Voici un exemple:

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

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

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

Dès que "this" est utilisé, il devient une propriété publique de someObj. Donc someObj.foo, someObj.get_inner () et someObj.set_inner () sont tous disponibles publiquement. De plus, set_inner () et get_inner () sont des méthodes privilégiées, elles ont donc accès à "interne" grâce aux fermetures.

Cependant, je n'ai vu aucune référence à cette technique nulle part. Même JSLint de Douglas Crockford s'en plaint:

• construction étrange. Supprimer «nouveau»

Nous utilisons cette technique en production et elle semble bien fonctionner, mais je suis un peu inquiète à ce sujet car elle n'est documentée nulle part. Est-ce que quelqu'un sait si c'est une technique valide?

J'ai déjà vu cette technique, elle est valide, vous utilisez une expression de fonction comme s'il s'agissait d'une fonction constructeur .

Mais à mon humble avis, vous pouvez obtenir la même chose avec une expression de fonction à invocation automatique, je ne vois pas vraiment l'intérêt d'utiliser l' newopérateur de cette manière:

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

Le but de l' newopérateur est de créer de nouvelles instances d'objet, de configurer la [[Prototype]]propriété interne, vous pouvez voir comment cela est fait par la [Construct]propriété interne.

Le code ci-dessus produira un résultat équivalent.

Votre code est juste similaire à la construction la moins étrange

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

    ...
};
var someObj = new Foo;

Pour clarifier certains aspects et empêcher JSLint de Douglas Crockford de se plaindre de votre code, voici quelques exemples d'instanciation:

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

Dans l'exemple 3. expression dans (...) as value est une fonction / constructeur. Cela ressemble à ceci: new (function () {...}) (). Donc, si nous omettons les crochets de fin comme dans l'exemple 2, l'expression est toujours un appel de constructeur valide et ressemble à l'exemple 4.

JSLint de Douglas Crockford "pense" que vous vouliez assigner la fonction à someObj, pas à son instance. Et après tout, ce n'est qu'un avertissement, pas une erreur.