0

我有一个简单的 TypeScript 文件，如下所示：

module HouseOfSynergy
{
    export module Library
    {
        export class Version
        {
            private _Major: number = 0;
            private _Minor: number = 0;
            private _Build: number = 0;
            private _Revision: number = 0;

            public get Major(): number { return (this._Major); }
            public get Minor(): number { return (this._Minor); }
            public get Build(): number { return (this._Build); }
            public get Revision(): number { return (this._Revision); }

            constructor(major: number, minor: number, build: number, revision: number)
            {
                this._Major = major;
                this._Minor = minor;
                this._Build = build;
                this._Revision = revision;
            }

            public toString(): string
            {
                return (this._Major.toString() + "." + this._Minor.toString() + "." + this._Build.toString() + "." + this._Revision.toString());
            }

            private static _Current: HouseOfSynergy.Library.Version = new HouseOfSynergy.Library.Version(1, 0, 0, 0);
            public static get Current(): HouseOfSynergy.Library.Version { return (HouseOfSynergy.Library.Version._Current); }
        }
    }
}

从 HTML 文件调用静态属性Current，如下所示：

alert(HouseOfSynergy.Library.Version.Current.toString());

谷歌浏览器产生以下错误：

打字稿：
在此处输入图像描述 在此处输入图像描述

HTML/JavaScript：
在此处输入图像描述 在此处输入图像描述

我尝试将静态属性转换为函数，但不断收到相同的错误。Version即使声明类的实例也会new Version(1, 0, 0, 0)产生相同的错误。任何指针将不胜感激。

这是生成的 JavaScript：

var HouseOfSynergy;
(function (HouseOfSynergy) {
    var Library;
    (function (Library) {
        var Version = (function () {
            function Version(major, minor, build, revision) {
                this._Major = 0;
                this._Minor = 0;
                this._Build = 0;
                this._Revision = 0;
                this._Major = major;
                this._Minor = minor;
                this._Build = build;
                this._Revision = revision;
            }
            Object.defineProperty(Version.prototype, "Major", {
                get: function () { return (this._Major); },
                enumerable: true,
                configurable: true
            });
            Object.defineProperty(Version.prototype, "Minor", {
                get: function () { return (this._Minor); },
                enumerable: true,
                configurable: true
            });
            Object.defineProperty(Version.prototype, "Build", {
                get: function () { return (this._Build); },
                enumerable: true,
                configurable: true
            });
            Object.defineProperty(Version.prototype, "Revision", {
                get: function () { return (this._Revision); },
                enumerable: true,
                configurable: true
            });
            Version.prototype.toString = function () {
                return (this._Major.toString() + "." + this._Minor.toString() + "." + this._Build.toString() + "." + this._Revision.toString());
            };
            Object.defineProperty(Version, "Current", {
                get: function () { return (HouseOfSynergy.Library.Version._Current); },
                enumerable: true,
                configurable: true
            });
            Version._Current = new HouseOfSynergy.Library.Version(1, 0, 0, 0);
            return Version;
        }());
        Library.Version = Version;
    })(Library = HouseOfSynergy.Library || (HouseOfSynergy.Library = {}));
})(HouseOfSynergy || (HouseOfSynergy = {}));
4

1 回答 1

1

在命名空间内编写代码时，可以省略完整的命名空间。这不仅使代码不那么冗长且更具可读性......它也可以工作......

module HouseOfSynergy
{
    export module Library
    {
        export class Version
        {   
            public static get Current(): Version { return (Version._Current); }

            private static _Current: Version = new Version(1, 0, 0, 0);

            public get Major(): number { return (this.major); }
            public get Minor(): number { return (this.minor); }
            public get Build(): number { return (this.build); }
            public get Revision(): number { return (this.revision); }

            constructor(private major: number, private minor: number, private build: number, private revision: number)
            {
            }

            public toString(): string
            {
                return (this.major + "." + this.minor + "." + this.build + "." + this.revision);
            }
        }
    }
}

alert(HouseOfSynergy.Library.Version.Current.toString());
于 2016-03-19T16:21:21.813 回答