¿Por qué integrar la clase de JavaScript en una función anónima() la llamada?

Question

Estuve leyendo sobre el nuevo JavaScript como lenguaje de Microsoft, llamado Manuscrito.En el zona de juegos (ejemplo de la sección), hay una clase sencilla de Transcripción sintaxis convertido a código JavaScript.Viniendo de una programación Java fondo, fue muy interesante para mí para aprender programación orientada a objetos es hecho en JavaScript compilado a partir de los Manuscritos.

El Manuscrito de código:

class Greeter {
    greeting: string;
    constructor (message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
}   

var greeter = new Greeter("world");

var button = document.createElement('button')
button.innerText = "Say Hello"
button.onclick = function() {
    alert(greeter.greet())
}

document.body.appendChild(button)

Y el equivalente de código JavaScript:

var Greeter = (function () {
    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();
var greeter = new Greeter("world");
var button = document.createElement('button');
button.innerText = "Say Hello";
button.onclick = function () {
    alert(greeter.greet());
};
document.body.appendChild(button);

El Manuscrito parte es muy similar a Java, por lo que entiendo que.Ahora mi pregunta es ¿por qué en JavaScript, el cuerpo de la Greeter la clase está incrustado en un anónimo function() llame?

¿Por qué no escribir algo como esto?

function Greeter(message) {
    this.greeting = message;
}
Greeter.prototype.greet = function () {
    return "Hello, " + this.greeting;
};

¿Cuáles son las ventajas/desventajas de cada método?

Answer 1

La siguiente se llama Invoca Inmediatamente Expresión De Función:

(function(){ ... })();

Es usado para mantener el alcance global de limpiar.Aunque, en este caso no es necesario ya que el valor de retorno es asignado a una variable Greeter.La única vez que este patrón es útil cuando se desea "privado" estática los miembros de la.

E. g.:

var Greeter = (function () {
    var foo = 'foo', bar = 'bar'; /* only accessible from function's defined
                                     in the local scope ... */

    function Greeter(message) {
        this.greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + this.greeting;
    };
    return Greeter;
})();

Answer 2

Esto es para permitir que los miembros privados.En este ejemplo, todos los miembros son públicos, por lo que su dos construcciones son equivalentes.Sin embargo, si usted quiere mantener a los miembros privados que necesita de ellos para ocultar desde el ámbito de la llamada a través de un cierre.Por lo tanto, si usted tiene un miembro privado así:

class Greeter {
    private greeting: string;
    constructor (message: string) {
        this.greeting = message;
    }
    greet() {
        return "Hello, " + this.greeting;
    }
} 

Usted probablemente va a obtener algo como esto:

var Greeter = (function () {
    var greeting="";
    function Greeter(message) {
        greeting = message;
    }
    Greeter.prototype.greet = function () {
        return "Hello, " + greeting;
    };
    return Greeter;
})();

El saludo variable estará disponible para cualquier función definida dentro de la función anónima, invisible pero en todas las demás.

Answer 3

Además de la obvia de alcance/cierre de razonamiento.El uso de una función anónima que se llama a sí mismo inmediatamente pre-carga (interpreta) la definición de la clase.Esto permite que cualquier JIT optimizaciones para ser cargado dentro de la ejecución.En resumen, para las grandes aplicaciones más complejas se va a mejorar el rendimiento.

Answer 4

La función anónima / ejecución automática de cierre es generalmente utilizado para encapsular el ámbito de aplicación de modo que sólo el valor devuelto es accesible desde fuera de ella.(o cualquier cosa que se conectan a otros objetos, como la ventana)

Answer 5

La función anónima es probablemente para evitar que el nombre de collition con otras partes del código.Creo que de esta manera, dentro de su función anónima, puede incluso declarar una variable llamada "$" para ser lo que quieras, y al mismo tiempo, usar jQuery en otras partes de su código sin conflicto.

Answer 6

El cierre es el único significa llamar a los constructores con parámetros:

var w = new Greeter("hello")

Hay otros métodos, pero nada complicado y con las limitaciones y desventajas.