nodejs - ¿Cuál es la diferencia entre los módulos internos y externos en TypeScript?

typescript version

Question

He pasado un tiempo leyendo la especificación del lenguaje de mecanografía y estoy algo confundido acerca de la diferencia entre los módulos internos y externos . Aquí está la descripción tomada directamente de la especificación:

Los módulos internos (sección 9.2.2) son miembros locales o exportados de otros módulos (incluidos el módulo global y los módulos externos). Los módulos internos se declaran usando ModuleDeclarations que especifican su nombre y cuerpo. Una ruta de nombre con más de un identificador es equivalente a una serie de declaraciones de módulo interno anidado.

Los módulos externos (sección 9.4) son cuerpos de código cargados por separado a los que se hace referencia usando nombres de módulos externos. Un módulo externo se escribe como un archivo fuente separado que contiene al menos una declaración de importación o exportación. Además, los módulos externos se pueden declarar utilizando AmbientModuleDeclarations en el módulo global que especifica directamente los nombres de los módulos externos como literales de cadenas. Esto se describe con más detalle en la sección 0.

Según lo que he entendido, creo que los módulos externos corresponden a archivos de mecanografía sin incluir definiciones de módulos que simplemente exportan un conjunto de tipos y / o variables. Desde otro archivo de texto mecanografiado, puedo importar un módulo externo en foo.ts con import foo = module("foo");

¿Alguien puede explicarme el destino entre los módulos externos e internos?

Answer 1

Las secciones 9.3 y 9.4 de la especificación explican esto más claramente. Reproduciré aquí algunos de los ejemplos dados en esas secciones.

Módulos externos

Supongamos que el siguiente código está en main.ts

import log = module("log");
log.message("hello");

Este archivo hace referencia a un log módulo externo, definido por cualquier log.ts exportaciones.

export function message(s: string) { 
  console.log(s); 
}

Tenga en cuenta que log.ts no utiliza la palabra clave del module ningún lugar. Simplemente exporta cosas con la export .

Módulos internos

Este archivo tiene dos módulos internos, XYZ .

module A.B.C { 
  import XYZ = X.Y.Z; 
  export function ping(x: number) { 
    if (x > 0) XYZ.pong(x – 1); 
  }
} 
module X.Y.Z { 
  import ABC = A.B.C; 
  export function pong(x: number) { 
    if (x > 0) ABC.ping(x – 1); 
  } 
}

Estos se comportan (en su mayoría) como módulos externos, pero están contenidos en un archivo y no es necesario hacer referencia a ningún archivo externo para usarlos. Deben estar contenidos dentro de un bloque de module cuando están definidos.

Answer 2

Según las presentaciones de Anders: http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript (34:40) y la documentación de Typescript, los módulos externos son módulos que se basan en AMD superior (definición de modelo asíncrono) o CommonJS.

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

Supongamos que tiene una clase Main con un método de log definido colocado en un archivo transfer.js . Los métodos internos de la clase Main solo están visibles cuando se está importando el archivo transfer.js en la parte superior del archivo js de origen como lo siguiente: ///<reference path="transfer.js"/> . De esta forma, el compilador elimina el cruce de todos los archivos js en tiempo de ejecución.

Este es un gran beneficio de usar módulos externos. Otro es cuando intentas hacer referencia a un método o clase externo que en el flujo de javascript normal de arriba hacia abajo se define más adelante que la invocación del método. Al usar módulos externos, la clase referenciada se instancia solo en la invocación del método.

Answer 3

Módulo interno:

1. Puede definir módulos dentro de sus archivos tiposcritp.
2. Todas las variables definidas dentro del módulo tienen un alcance al módulo y se eliminan del alcance global.
3. Cuando compila sus archivos de texto mecanografiado, sus módulos se convierten en variables que anidan según sea necesario para formar objetos similares al espacio de nombres. Tenga en cuenta que la clase definida dentro del módulo está claramente aislada utilizando un IIFE (Expresión de función invocada inmediatamente).
4. El código siguiente muestra que la variable MyClass tiene un alcance en el módulo MyInternalModule. No se puede acceder fuera del módulo, por eso la última línea del código muestra que el error no puede encontrar el nombre MyClass.
5. Puede acceder a la variable fuera del módulo utilizando la palabra clave export.
6. También puede extender módulos internos, compartirlos entre archivos y hacer referencia a ellos utilizando la sintaxis de barra triple. (///)

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

Versión compilada de Typescript:

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);
    }
}