Jaký je rozdíl mezi vnitřními a vnějšími moduly na stroji?

Question

Jaký je rozdíl mezi vnitřními a vnějšími moduly na stroji?

hlasů

40

Strávil jsem nějaký čas čtením specifikace Typescript jazyk a jsem poněkud zmatená o rozdílu mezi interními a externími moduly. Zde je popis přímo z specifikace:

Interní moduly (oddíl 9.2.2), místní nebo vyvážené příslušníci ostatních modulů (včetně globální modulu a externích modulů). Vnitřní moduly jsou deklarovány pomocí ModuleDeclarations, které určují jejich jméno a tělo. Jméno cesta s více než jedním identifikátorem je ekvivalentní k sérii vnořených deklarací vnitřních modulů.

Externí moduly (bod 9.4) jsou samostatně načten těla kódu odkazuje pomocí externích názvů modulů. Externí modul je napsán jako samostatný zdrojový soubor, který obsahuje alespoň jedno prohlášení o dovozu nebo vývozu. Kromě toho externí moduly mohou být deklarovány pomocí AmbientModuleDeclarations v globální modul, který přímo specifikovat externí názvy modul jako řetězcové literály. To je dále popsáno v části 0.

Z toho, co jsem pochopil, myslím, že externí moduly odpovídají strojopisem soubory bez obvodových definice modulu, který jednoduše exportovat sadu typů a / nebo proměnných. Z jiného souboru strojopisem mohu jednoduchý import externí modul foo.ts simport foo = module(foo);

Může mi někdo vysvětlit mi o destinction mezi vnějšími a vnitřními moduly?

typescript

Položena 11/10/2012 v 15:10
zdroj uživatelem Valentin

V jiných jazycích...

3 odpovědí

hlasů

6

Podle Anders prezentace: http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript (34:40) a Typescript dokumentace, externí moduly jsou moduly, které jsou založeny na vrcholu AMD (Asynchronous Model Definition) nebo CommonJS.

Externí moduly jsou užitečné v tom smyslu, že skrýt interní výkazy definice modulu a zobrazí pouze metody a parametry spojené s deklarovanou proměnnou.

Předpokládejme, že máte Maintřídu s definovaným logzpůsobem umístěné v transfer.jssouboru. Vnitřní metody Maintřídy jsou viditelné pouze při importu do transfer.jssouboru v horní části js zdrojového souboru tak, aby: ///<reference path="transfer.js"/>. Tímto způsobem kompilátor eliminuje traversal všech souborů js za běhu.

To je obrovská výhoda použití externích modulů. Dalším z nich je, když se snaží odkazovat na externí metodu nebo třídu, která v normálním shora dolů javascript tok je definován později, než volání metody. Pomocí externích modulů odkazované třída je vytvořena pouze na volání metody.

Odpovězeno 11/10/2012 v 15:49
zdroj uživatelem Simo Endre

hlasů

1

Vnitřní modul:

Můžete definovat moduly v rámci svých typescritp souborů.
Všechny proměnné definované v modulu jsou rozsahem do modulu a odstraněn z globálním rozsahu.
Při kompilaci svůj strojopis soubory vaše moduly jsou převedeny do proměnné, které podle potřeby hnízdo pro vytvoření oboru názvů podobné objekty. Všimněte si, že třída definované v modulu je pečlivě izolována pomocí IIFE (Okamžitě vyvolání výraz funkce).
Kód níže ukazuje, že variabilní MyClass rozsahem do MyInternalModule modulu. Nemohou být přístupné mimo modul, který je důvod, proč poslední řádek kódu ukazuje chyba nemůže najít název Moje_třída.
Můžete získat přístup k proměnné mimo modul pomocí exportu klíčové slovo.
Můžete také rozšířit interní moduly, podělte se o ně v různých souborech, a odkazovat je pomocí trojitého syntaxe lomítko. (///)

Příklad :

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

Compiled Version of strojopisem:

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

Externí modul:

Příklad :

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

Odpovězeno 29/09/2016 v 07:35
zdroj uživatelem vsjondhale

Peter Olson · Accepted Answer · 2012-10-11 15:33

Oddíly 9.3 a 9.4 specifikace vysvětlit jasněji. I zde bude reprodukovat některé z příkladů uvedených v těchto úsecích.

externí moduly

Předpokládejme, že následující kód je main.ts.

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

Tento soubor odkazuje externího modulu log, definovanou jakýmkoli log.tsvývozem.

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

Všimněte si, že log.tsnepoužívá moduleslovo kdekoliv. To prostě vyváží věci s export.

interní moduly

Tento soubor má dvě interní moduly X.Y.Z.

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

Ty se chovají (většinou) jako externí moduly, ale jsou obsaženy v jednom souboru a nemusíte odkazovat nějaké mimo soubory používat. Musejí být obsažen uvnitř modulebloku, pokud jsou definovány.