3

在 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 的打字稿：

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。）

4

2 回答 2

7

正如 apsillers 所说，private static这可能是您想要的。虽然当前版本不支持它，但您将能够private static在未来的某个时候在 TypeScript 中拥有一个成员（设计团队根据与此类似的反馈改变了这个想法）。

于 2012-12-05T21:05:22.077 回答
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 可以foo2()在 的实例上调用MyTypeScriptClass，但在运行时既不能从外部访问，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将使 typescript 编译器不允许外部调用它们，但其他 javascript 代码仍然可以从外部访问它们。

于 2012-12-07T22:09:43.020 回答