Mi a különbség a belső és külső modulok géppel?

Question

Mi a különbség a belső és külső modulok géppel?

szavazat

40

Még egy ideig nem olvassa a géppel nyelvspecifikáció vagyok, és kissé zavaros, mi a különbség a belső és a külső modulokat. Itt látható a leírás alapján közvetlenül a specifikáció:

Belső modulok (szakasz 9.2.2) helyi vagy exportált tagja más modulok (beleértve a globális modul és külső modul). Belső modulok deklarálni ModuleDeclarations hogy adja a nevét és a test. A név útvonal több mint egy azonosító egyenértékű egy sor beillesztett belső modul nyilatkozatok.

Külső modulok (9.4) külön-külön betöltött szervei hivatkozott kód segítségével külső modulok nevét. Külső modul van írva, mint egy külön file, amely legalább egy behozatali vagy kiviteli nyilatkozat. Ezen túlmenően, a külső modulokat lehet deklarálni AmbientModuleDeclarations a globális modul, amely közvetlenül meghatározza a külső modul nevek sztring literálok. Ennek leírása további szakaszban 0.

Abból, amit érteni azt hiszem, hogy a külső modulok megfelelnek az írógéppel fájlokat anélkül körülfogó modulmeghatározásokat hogy egyszerűen exportálni egy sor különböző típusú és / vagy változó. Egy másik géppel fájlt tudok egyszerű import egy külső modul foo.ts aimport foo = module(foo);

Tud valaki magyarázni nekem a destinction közötti külső és belső modulok?

typescript

A kérdést 11/10/2012 15:10
a forrás felhasználó Valentin

Más nyelveken...

3 válasz

szavazat

6

Szerint Anders előadások: http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript (34:40), és géppel dokumentáció, a külső modulok olyan modulok, amelyek alapján tetején AMD (aszinkron modell Definition) vagy CommonJS.

Külső modulok alkalmasak értelemben elrejti a belső nyilatkozatokat a modulmeghatározásokat és azt mutatják, csak a módszerek és paraméterek társult a bejelentett változó.

Tegyük fel, hogy van egy Mainosztály egy meghatározott logmódszerrel helyezzük transfer.jsfájlt. A belső módszerei Mainosztály csak akkor látható, ha importál transfer.jsfájl tetején a forrás js fájlt, így: ///<reference path="transfer.js"/>. Így a fordító megszünteti a bejárás minden js fájlokat futásidőben.

Ez egy hatalmas előnye a külső modulok. Egy másik az, ha próbál hivatkozni, külső módszer vagy osztály, amely a szokásos top-down javascript flow később definiáljuk, mint az metódusmeghívást. A külső modulok a hivatkozott osztály példányai csak metódusmeghívást.

Válaszolt 11/10/2012 15:49
a forrás felhasználó Simo Endre

szavazat

1

Belső modul:

Megadhatjuk modulokat a typescritp fájlokat.
Minden definiált változók a modul hatókörű a modulhoz, és eltávolítjuk a globális környezetben.
Amikor fordítod a géppel fájlokat a modulok alakítjuk változók fészek kialakításához szükséges névtér-szerű tárgyak. Figyeljük meg, hogy a meghatározott osztályból a modulon belül szépen izoláljuk egy életedrõl (Azonnal meghívás Function Expression).
Az alábbi kód azt mutatja, hogy a MyClass változó hatókörű a MyInternalModule modult. Nem lehet hozzáférni a modulon kívüli ezért az utolsó sorban a kód azt mutatja, a hiba nem találja nevét MyClass.
Akkor hozzáférhet a változó külső modul segítségével az export kulcsszó.
Azt is kiterjeszti a belső modulok, megoszthatják ezeket a fájlokat, és hivatkozás őket a hármas perjel szintaxis. (///)

példa :

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

Lefordított géppel:

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

Külső modul:

példa :

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

Válaszolt 29/09/2016 07:35
a forrás felhasználó vsjondhale

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

Szakaszok 9,3 és 9,4 a leírás magyarázza ezt világosabban. Majd szaporodnak itt néhány példát adott az említett szakaszok.

külső modulok

Tegyük fel, hogy a következő kód az main.ts.

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

Ez a fájl hivatkozik egy külső modul logáltal meghatározott bármilyen log.tsexport.

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

Vegyük észre, hogy log.tsnem használja a modulekulcsszót bárhol. Csak exportálja a dolgokat export.

belső modulok

Ez a fájl két belső modulok 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); 
  } 
}

Ezek úgy viselkednek, (többnyire), mint a külső modulokat, de tartalmazza egy fájlt, és akkor nem kell hivatkozni semmilyen külső fájlokat kell használni őket. Úgy kell belsejében egy moduleblokkot, amikor definiálva vannak.