`nova função ()` com “f” minúsculo em JavaScript

Meu colega tem usado "new function ()" com "f" minúsculo para definir novos objetos em JavaScript. Parece funcionar bem em todos os principais navegadores e também parece ser bastante eficaz em ocultar variáveis ​​privadas. Aqui está um exemplo:

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

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

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

Assim que "this" for usado, ele se tornará propriedade pública de algumObj. Então someObj.foo, someObj.get_inner () e someObj.set_inner () estão todos disponíveis publicamente. Além disso, set_inner () e get_inner () são métodos privilegiados, então eles têm acesso a "interior" por meio de fechamentos.

No entanto, não vi nenhuma referência a essa técnica em qualquer lugar. Até o JSLint de Douglas Crockford reclama disso:

• construção estranha. Excluir 'novo'

Estamos usando essa técnica na produção e parece estar funcionando bem, mas estou um pouco ansioso com isso porque não está documentado em lugar nenhum. Alguém sabe se esta é uma técnica válida?

Já vi essa técnica antes, é válida, você está usando uma expressão de função como se fosse uma função de construtor .

Mas, IMHO, você pode conseguir o mesmo com uma expressão de função de invocação automática, realmente não vejo sentido em usar o newoperador dessa maneira:

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

O objetivo do newoperador é criar novas instâncias do objeto, configurando a [[Prototype]]propriedade interna, você pode ver como isso é feito pela [Construct]propriedade interna.

O código acima produzirá um resultado equivalente.

Seu código é semelhante à construção menos estranha

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

    ...
};
var someObj = new Foo;

Para esclarecer alguns aspectos e fazer com que o JSLint de Douglas Crockford não reclame do seu código, aqui estão alguns exemplos de instanciação:

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

No exemplo 3. expressão em (...) como valor é uma função / construtor. Tem a seguinte aparência: new (function () {...}) (). Portanto, se omitirmos os colchetes finais como no exemplo 2, a expressão ainda é uma chamada de construtor válida e se parece com o exemplo 4.

O JSLint de Douglas Crockford "pensa" que você queria atribuir a função a someObj, não a sua instância. Afinal, é apenas um aviso, não um erro.