使用 TypeScript 编译类的观察 [重复]

Question

在我继续之前，我想指出我已经问了一些关于 TypeScript、它的编译器以及它在其整个生命周期中已经实现和无法实现的目标以及通向 1.0 版的路线图的一些问题 em>

这个问题与 TypeScript 中 public 和 private 关键字的使用有关，以及它们与编译后的 JavaScript 有何关系。

考虑以下 TypeScript 类：

class Example {
    private messageA: string;
    public messageB: string;

    constructor(message?: string) {
        this.messageA = "private: " + message;
        this.messageB = "public: " + message;
    }

    public showMessageA(): void {
        alert(this.messageA);
    }

    private showMessageB(): void {
        alert(this.messageB);
    }
}

var example = new Example("Hello World");

现在，当我输入 example 时。 intellisense (TypeScript) 告诉我我可以访问messageB 和showMessageA，因为它们都是public。但是，这种行为（虽然可能）在编译后的 JavaScript 中并不明显。

这是我的班级的 JavaScript 编译：

var Example = (function () {
    function Example(message) {
        this.messageA = "private: " + message;
        this.messageB = "public: " + message;
    }
    Example.prototype.showMessageA = function () {
        alert(this.messageA);
    };

    Example.prototype.showMessageB = function () {
        alert(this.messageB);
    };
    return Example;
})();

var example = new Example("Hello World");

现在，如果我将此示例粘贴到我的浏览器控制台（我使用的是 Chrome），我可以访问 messageA、messageB、showMessageA、showMessageB，这意味着在 JavaScript 中，所有访问修饰符都是忽略。

我个人认为这是错误的！ JavaScript 能够对访问修饰符进行建模，因此我认为 TypeScript 应该效仿。

考虑以下手写 JavaScript，它正确地模拟了 private 和 public 变量和函数：

var Example = (function() {
    return function Example(message) {
        var messageA = "private: " + message;
        this.messageB = "public: " + message;

        this.showMessageA = function() {
            alert(messageA);
        }

        var showMessageB = function() {
            alert(this.messageB);
        }
    }
})();

var example = new Example("Hello World");

现在，如果我将此示例粘贴到我的浏览器控制台中，我只能访问 messageB 和 showMessageA，根据我尝试使用 TypeScript 实现的目标是正确的。

问题

1. 为什么 TypeScript 编译器在编译成 JavaScript 时会忽略访问修饰符？
2. 为什么 TypeScript 将所有方法绑定到原型，而不是基于每个实例？
3. 如果 TypeScript 编译类的方式与我的自定义实现相比有什么好处，那是什么，为什么？

Answer 1

使用闭包来模拟私有访问的问题是每个实例都需要自己的每个方法的副本。这意味着每次创建实例时，都必须编译每个方法函数，并且必须为新函数保留内存空间。这并不理想，也不是 TypeScript 试图实现的目标。

Answer 2

从语义上讲，您描述的方法即闭包模型在许多方面都优于 JavaScript 将方法放在原型上的模型——即使对于公共方法也是如此。 EcmaScript 6 委员会（TypeScript 所基于的类系统）中的一些人会更喜欢这种类系统。事实上，TypeScript 的早期内部版本实现了这样的模型。

不幸的是，这样的模型在 JavaScript 中无法高效。它通常要求将每个方法作为每个对象实例的单独闭包分配——即，创建单个对象实例将涉及创建许多函数对象。并且由于 JavaScript 对 this 的处理极其薄弱，以及它的函数标识概念，一般来说，没有简单的方法可以优化这些分配。

因此，EcmaScript 6 选择了当前的模型（尽管它目前只有 public），TypeScript 遗憾地跟进（对于公共和私有）。然后，私有成员仅在 TypeScript 中提供静态检查，没有封装保证。

FWIW，在此模型中提供私有符号的正确方法是私有符号（又名private names），但不幸的是，这些符号没有进入 ES6，并且无论如何都不是 TypeScript 的选项。