为什么要在匿名函数（）调用中嵌入JavaScript类？-WhyembedtheJavaScriptclassinananonymousfunction()call?

14  

The following is called an Immediately Invoked Function Expression:

以下称为立即调用的函数表达式：

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

It is used to keep the global scope clean. Though, in this case it isn't necessary since the return value is assigned to a variable Greeter. The only time this pattern is useful is when you want "private" static members.

它用于保持全局范围的清洁。但是，在这种情况下，由于返回值被赋值给变量Greeter，因此没有必要。此模式唯一有用的时间是您想要“私有”静态成员。

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

3  

Besides the obvious scoping/closure reasoning. Using an anonymous function that invokes itself immediately pre-loads (interprets) the class definition. This allows any JIT optimizations to be front loaded within the execution. In short, for larger more complex applications it will improve performance.

除了明显的范围/结束推理。使用调用自身的匿名函数可以预先加载（解释）类定义。这允许在执行中预先加载任何JIT优化。简而言之，对于更大更复杂的应用程序，它将提高性能。

2  

The anonymous function / self executing closure is usually used to encapsulate scope so that only the returned value is accessible outside of it. (or anything you attach to other objects, like window)

匿名函数/自执行闭包通常用于封装作用域，以便只能在其外部访问返回的值。 （或任何附加到其他对象的东西，如窗口）

2  

This is to allow for private members. In this example, all members are public so your two constructions are equivalent. However, if you want to provide for private members you need to hide them from the calling scope via a closure. Thus if you have a private member like so:

这是为了允许私人会员。在此示例中，所有成员都是公共的，因此您的两个构造是等效的。但是，如果要为私有成员提供，则需要通过闭包将它们隐藏在调用范围内。因此，如果您有这样的私人会员：

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

You would probably get something like this:

你可能会得到这样的东西：

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

The greeting variable will be available to any function defined inside the anonymous function, but invisible everywhere else.

greeting变量可用于匿名函数内定义的任何函数，但在其他任何地方都不可见。

1  

The anonymous function is probably there to prevent name collition with other parts of the code. Think of it this way, inside your anonymous function, you could even declare a variable called "$" to be whatever you want, and at the same time, be using jQuery on other parts of your code without conflict.

匿名函数可能是为了防止名称与代码的其他部分碰撞。可以这样想，在你的匿名函数中，你甚至可以将一个名为“$”的变量声明为你想要的任何东西，同时在你的代码的其他部分使用jQuery而不会发生冲突。

-4  

The closure is the sole mean to call the constructors with parameters:

闭包是用参数调用构造函数的唯一方法：

var w = new Greeter("hello")

There are other methods but all complicated and with limitations and drawbacks.

还有其他方法，但都很复杂，有局限和缺点。