js----modules2（用原文是翻譯詞不達意）

用 IIEF 來創建簡單的繼承結構：

let Castle = (function () {
    function Castle(name) {
        this.name = name;
    }
    Castle.prototype.Build = function () {
        console.log("Castle built :"+ this.name);
    };
    return Castle;
})();
Westros.Structures.Caslte = Castle;

這種結構容易理解由於它層次自然，使用此結構的繼承也相對容易完成。
現在我們定義一個BaseStructure 作爲所有 structures 的父類，實現上面的結構。

let BaseStructure = (function () {
    function BaseStructure() {
    }
    return BaseStructure;
})();
Structures.BaseStructure = BaseStructure;

let Castle = (function (_super) {
    _extends(Castle, _super);
    function Castle(name) {
        this.name = name;
        _super.call(this);
    }
    Castle.prototype.Build = function () {
        console.log("Castle built: "+this.name);
    };
    return Castle;
})(BaseStructure);

You’ll note that the Basestructure is passed into the Castle object when the closure is evaluated.還有一個helper方法_extends()，負責把基類裏面裏面所有的functions複製到派生類裏面。

let _extends = this._extends || function (d,b) {
    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
    function _() {this.constructor = d;};
    _.prototype =b.prototype;
    d.prototype = new _();
}

We can continue the rather nifty closure syntax we’ve adopted for a class to implement an entire module

var Westeros;
(function (Westeros) {
    function (Structures) {
        let Castle = (function(){
            function(name){
                this.name = name;
            }
            Castle.prototype.Build = function(){
                console.log("Castle built:" + this.name);
            };
            return Castle;
        })();
        Structures.Castle = Castle;
    }(Westeros.Structures || (Westeros.Structures = {}));
    var Structres = Westeros.Structures;
})(Westeros || (Westeros = {}));

Within this structure you can see the same code for creating modules that we
explored earlier. It is also relatively easy to define multiple classes inside a single
module. This can be seen in this code

var Westeros;
(function (Westeros) {
    (function (Structures) {
        let Castle = (function(){
            function Castle(name){
                this.name = name;
            }
            Castle.prototype.Build = function(){
                console.log("Castle built:"+ this.name);
                var w = new Wall();
            };
            return Castle;
        })();
        Structures.Castle = Castle;
        var Wall = (function(){
            function Wall(){
                console.log("Wall constructed");
            }
            return Wall;
        })();
        Structures.Wall = Wall;
    })(Westeros.Structures || (Westeros.Structures = {}));
})(Westeros || (Westeros = {}));

Structures.Wall = Wall:
shows exposing the class outside of the
closure. If we want to make private classes that are only available within the module then we only need to exclude that line.
This is actually known as the revealing module pattern. We only reveal the classes that need to be globally available。