`nuova funzione()` con minuscolo "f" in JavaScript

Question

Il mio collega ha utilizzato "nuova funzione()" con una minuscola "f" per definire nuovi oggetti in JavaScript. Sembra funzionare bene in tutti i principali browser e sembra anche essere abbastanza efficace nel nascondere variabili private. Ecco un esempio:

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

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

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

Non appena "questo" viene utilizzato, diventa una proprietà pubblica di alcuniObj. Quindi someObj.foo, someObj.get_inner() e someObj.set_inner() sono tutti disponibili pubblicamente. Inoltre, set_inner() e get_inner() sono metodi privilegiati, quindi hanno accesso a "inner" attraverso le chiusure.

Tuttavia, non ho visto alcun riferimento a questa tecnica da nessuna parte. JSLint di Anche Douglas Crockford lamenta:

• costruzione strano. Elimina 'nuovo'

Stiamo utilizzando questa tecnica nella produzione e sembra funzionare bene, ma io sono un po 'ansioso su di esso perché non è documentato da nessuna parte. Qualcuno sa se questa è una tecnica valida?

Answer 1

Ho visto prima questa tecnica, è valida, si sta usando un'espressione di funzione come se fosse un Constructor Function.

Ma secondo me, è possibile ottenere lo stesso con un'espressione funzione di auto-invocazione, io non vedo proprio il punto di usare l'operatore new in questo modo:

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

Lo scopo dell'operatore new è quello di creare nuove istanze di oggetti, impostando la proprietà interna [[Prototype]], è possibile vedere come questo è fatto dalla proprietà interna [Construct].

Il codice sopra riportato produce un risultato equivalente.

Answer 2

Il codice è solo simile a quello meno strano costrutto

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

    ... 
}; 
var someObj = new Foo; 

Answer 3

Per chiarire alcuni aspetti e fare JSLint di Douglas Crockford di non lamentarsi il codice ecco alcuni esempi di esemplificazione:

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 

Nell'esempio 3. espressione in (...) come valore è una funzione/costruttore. È il seguente: new (function() {...})(). Quindi, se omettiamo le parentesi quadre come nell'esempio 2, l'espressione è ancora una chiamata di costruttore valida e assomiglia ad esempio 4.

JSLint di Douglas Crockford "pensa" che si desidera assegnare la funzione a someObj, non la sua istanza. E dopotutto è solo un avvertimento, non un errore.