為什么我不能在TypeScript類中聲明局部變量和函數？

Question

在TypeScript中，如果沒有編譯器將其添加到原型中，我似乎無法在類中聲明函數。 例如：

class MyTypeScriptClass {
    // method, is added to prototype
    foo1(): void {
        alert('invoked foo1');
    }

    // private method also added to prototype
    private foo2(): void {
        alert('invoked foo2');
    }

    //// can I have a local function, without making it a private method?
    //function foo3() {
    //    alert('invoked foo3');
    //}
}

以上編譯如下：

var MyTypeScriptClass = (function () {
    function MyTypeScriptClass() { }
    MyTypeScriptClass.prototype.foo1 = function () {
        alert('invoked foo1');
    };
    MyTypeScriptClass.prototype.foo2 = function () {
        alert('invoked foo2');
    };
    return MyTypeScriptClass;
})();

我正在尋找的是可以編譯為以下JavaScript的typescript：

var fvm = new FlasherViewModel2();
    var MyTypeScriptClass = (function () {
        function MyTypeScriptClass() { }
        MyTypeScriptClass.prototype.foo1 = function () {
            alert('invoked foo1');
        };
        MyTypeScriptClass.prototype.foo2 = function () {
            alert('invoked foo2');
        };
        function foo3() {
            alert('invoked foo3');
        }
        return MyTypeScriptClass;
    })();

可以嗎？

（作為旁注，我知道foo3不能從外部代碼調用。我實際上會從類中的另一個方法調用foo3，例如，將函數傳遞給jQuery fadeOut。）

Answer 1

正如apsillers所提到的， private static可能就是你想要的。 雖然它在當前版本中不受支持，但您可以在未來的某個時間點在TypeScript中擁有一個private static成員（設計團隊根據類似的反饋改變了對此的想法）。

Answer 2

我剛剛發現了另一種在typescript類中使用私有方法的方法，盡管這種模式可能聞起來有點滑稽。 據我所知道的，當你裹在班上你只能做這個module 。 例如：

module MyApp {
    // not accessible externally, `this` must be passed in if needed
    function foo3(that: MyTypeScriptClass): void {
        that.foo1();
        alert('invoked foo3');
    }

    // not accessible externally
    function foo4(): void {
        alert('invoked foo4');
    }

    export class MyTypeScriptClass {
        // normal method, is added to prototype
        foo1(): void {
            alert('invoked foo1');
        }

        // private method also added to prototype, is accessible externally
        private foo2(): void {
            alert('invoked foo2');
            foo3(this);
            foo4();
        }
    }
}

以上編譯成：

var MyApp;
(function (MyApp) {
    function foo3(that) {
        that.foo1();
        alert('invoked foo3');
    }
    function foo4() {
        alert('invoked foo4');
    }
    var MyTypeScriptClass = (function () {
        function MyTypeScriptClass() { }
        MyTypeScriptClass.prototype.foo1 = function () {
            alert('invoked foo1');
        };
        MyTypeScriptClass.prototype.foo2 = function () {
            alert('invoked foo2');
            foo3(this);
            foo4();
        };
        return MyTypeScriptClass;
    })();
    MyApp.MyTypeScriptClass = MyTypeScriptClass;    
})(MyApp || (MyApp = {}));

有了上述內容，外部javascript可以在MyTypeScriptClass的實例上調用foo2() ，但foo3()和foo4()都不能在運行時從外部訪問。 最大的警告是，如果您的私有方法需要訪問實例的成員，則必須將this作為函數參數傳遞。 基本上，這些是私有靜態方法。

var instance = new MyApp.MyTypeScriptClass();

// public, accessible externally
instance.foo1();

// will not compile in a .ts file, but works at runtime from manual js file
instance.foo2();

// runtime exception, foo3 is not defined
foo3(instance);
MyApp.foo3(instance);

// runtime exception, foo4 is not defined
foo4();
MyApp.foo4();

這種方法也適用於標量變量，但變量本質上也是靜態的 - 不同的類實例不能有不同的值。 要做到這一點，據我所知，你仍然需要在類中聲明它們。 將它們標記為private將使打字稿編譯器不允許外部調用它們，但其他javascript代碼仍然可以從外部訪問它們。