为什么 TypeScript 将类打包在 IIFE 中？

这是一个 TypeScript 类：

class Greeter {
    public static what(): string {
        return "Greater";
    }

    public subject: string;

    constructor(subject: string) {
        this.subject = subject;
    }

    public greet(): string {
        return "Hello, " + this.subject;
    }
}

当 TS 以 ES5 为目标时，它会被转译为 IIFE：

var Greeter = /** @class */ (function () {
    function Greeter(subject) {
        this.subject = subject;
    }
    Greeter.what = function () {
        return "Greater";
    };
    Greeter.prototype.greet = function () {
        return "Hello, " + this.subject;
    };
    return Greeter;
}());

然而，当它作为构造函数呈现时，它通常以相同的方式工作。当然，这看起来更像 JavaScript 和手写:)

function Greeter(subject) {
    this.subject = subject;
}
Greeter.what = function () {
    return "Greater";
};
Greeter.prototype.greet = function () {
    return "Hello, " + this.subject;
};

Usage:

两个代码块的工作方式相同：

Greater.what();  // -> "Greater"
var greater = new Greater("World!");
greater.greet(); // -> "Hello, World!

将其打包到 IIFE 中的好处或动机是什么？

我做了一个天真的基准：

console.time("Greeter");
for(let i = 0; i < 100000000; i++) {
    new Greeter("world" + i);
}
console.timeEnd("Greeter");

它显示出几乎相同的实例化速度。当然，我们不能期望有任何差异，因为 IIFE 只求解一次。

我想也许是因为封闭，但 IIFE 不接受争论。它一定不是一个闭包。

如果类之间存在继承，TypeScript 会将参数传递给 IIFE。例如，下面的闭包用于以下情况：Greeter延伸一个BaseGreeter class:

var Greeter = /** @class */ (function (_super) {
    // __extends is added by the TS transpiler to simulate inheritance
    __extends(Greeter, _super);
    function Greeter(subject) {
        var _this = _super.call(this) || this;
        _this.subject = subject;
        return _this;
    }
    Greeter.What = function () {
        return "Greater";
    };
    Greeter.prototype.greet = function () {
        return "Hello, " + this.subject;
    };
    return Greeter;
}(BaseGreeter));