¿Cuál es la diferencia entre los módulos internos y externos a máquina de escribir?

De acuerdo a las presentaciones de Anders: http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript (34:40) y la documentación de imprenta, los módulos externos son módulos que se basan en la parte superior de AMD (Asynchronous Modelo definición) o CommonJS.

Los módulos externos son útiles en el sentido que ocultan los estados internos de las definiciones del módulo y muestran sólo los métodos y parámetros asociados a la variable declarada.

Suponga que tiene una Mainclase con una definida logmétodo colocado en un transfer.jsarchivo. Los métodos internos de la Mainclase sólo son visibles cuando va a importar el transfer.jsarchivo en la parte superior del archivo js fuente como así: ///<reference path="transfer.js"/>. De esta manera el compilador elimina el recorrido de todos los archivos js en tiempo de ejecución.

Este es un gran beneficio del uso de módulos externos. Otra es cuando está intentando hacer referencia a un método externo o clase que en el de arriba hacia abajo JavaScript normales flujo se define más tarde de la invocación del método. El uso de módulos externos de la clase referenciada se instancia sólo en invocación de método.

Módulo interno:

1. Se pueden definir módulos dentro de sus archivos typescritp.
2. Todas las variables definidas dentro del módulo están en el ámbito al módulo y se retiran del ámbito global.
3. Cuando se compila sus archivos de texto mecanografiado sus módulos se convierten en variables que anidan si es necesario para formar objetos de espacio de nombres similares. Observe que la clase definida dentro del módulo se aísla cuidadosamente utilizando un IIFE (Inmediatamente Se invoca expresión de función).
4. El código siguiente muestra que la variable MyClass como alcance el módulo MyInternalModule. No se puede acceder exterior del módulo es por eso que la última línea del código muestra el error no puede encontrar el nombre MiClase.
5. Se puede acceder a la variable fuera del módulo usando la palabra clave de exportación.
6. También puede extender módulos internos, compartirlos a través de archivos, y hacer referencia a ellos utilizando la sintaxis de triple barra. (///)

Ejemplo :

module MyInternalModule{  
    class MyClass{               //if We write export keyword before the MyClass then last line works fine
        constructor (
            public height: number, 
            public width: number) {
    }
    }                   
    //working properly
    var obj1 = new MyClass(10, 4);
}

// it wont work //Because the out of the scope
var obj2 = new MyInternalModule.MyClass(10,4) //shows error: can not find name MyClass

Compilado Versión de imprenta:

var MyInternalModule;
(function (MyInternalModule) {
    var MyClass = (function () {
        function MyClass(height, width) {
            this.height = height;
            this.width = width;
        }
        return MyClass;
    })();
    //working properly
    var obj1 = new MyClass(10, 4);
})(MyInternalModule || (MyInternalModule = {}));

Módulo externo:

Ejemplo :

// bootstrapper.ts file

// imports the greeter.ts file as the greeter module
import gt = module('greeter');  
export function run() {  
    var el = document.getElementById('content');
    var greeter = new gt.Greeter(el);
    greeter.start(); 
}

// greeter.ts file

// exports the entire module
export class Greeter {  
    start() {
         this.timerToken = setInterval(() => 
             this.span.innerText = 
             new Date().toUTCString(), 500);
    }
}