Hva er forskjellen mellom interne og eksterne moduler i Loggfila?

Question

Hva er forskjellen mellom interne og eksterne moduler i Loggfila?

stemmer

40

Jeg har brukt litt tid å lese den maskinskrevet manuskript språkspesifikasjonen og er litt forvirret med hensyn til forskjellen mellom interne og eksterne moduler. Her er beskrivelsen tatt direkte fra spesifikasjonen:

Interne moduler (avsnitt 9.2.2), er lokal eller eksportert medlemmer av andre moduler (inkludert den globalt modulen og eksterne moduler). Interne moduler er erklært å bruke ModuleDeclarations som angir deres navn og kropp. Et navn bane med mer enn en identifikator som tilsvarer en serie nestede interne modul erklæringer.

Eksterne moduler (punkt 9.4) er adskilt lastet legemer av kode refereres til ved hjelp av eksterne modulnavn. En ekstern modul er skrevet som et separat kildefilen som inneholder minst ett import og eksport erklæring. I tillegg kan eksterne moduler bli erklært ved hjelp AmbientModuleDeclarations i det globale modul som direkte angir de ytre modul navn som strenger. Dette er nærmere beskrevet i avsnitt 0.

Fra hva jeg har forstått Jeg tror at eksterne moduler tilsvarer Loggfila filer uten omsluttende moduldefinisjoner som bare eksporterer et sett av typer og / eller variabler. Fra en annen loggfila jeg kan enkelt importere en ekstern modul i foo.ts medimport foo = module(foo);

Kan noen forklare meg destinction mellom eksterne og interne moduler?

typescript

Publisert på 11/10/2012 klokken 14:10
kilden bruker Valentin

På andre språk...

3 svar

stemmer

6

Ifølge Anders presentasjoner: http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript (34:40) og typescript dokumentasjon, de eksterne modulene er moduler som er basert på toppen AMD (Asynchronous Modell Definition) eller CommonJS.

Eksterne moduler er nyttige i forstand at de skjuler de indre uttalelser fra moduldefinisjoner og viser bare de metoder og parametre knyttet til de variable deklarert.

Anta at du har en Mainklasse med en definert logmetode plassert i en transfer.jsfil. De interne metoder for Mainklassen er bare synlig når du importerer transfer.jsfilen øverst på kilde js filen som så: ///<reference path="transfer.js"/>. På denne måten kompilatoren eliminerer traversering av alle JS-filer under kjøring.

Dette er en stor fordel av å bruke eksterne moduler. En annen er når du prøver å referere en ekstern metode eller klasse som i normal top-down javascript driften er definert senere enn metodekallet. Ved hjelp av eksterne moduler den refererte klasse blir instansiert bare på metodekall.

Svarte 11/10/2012 kl. 14:49
kilden bruker Simo Endre

stemmer

1

Intern Modul:

Du kan definere moduler innenfor dine typescritp filer.
Alle variabler er definert i modulen er målrettet mot modulen og fjernet fra det globale området.
Når du kompilere Loggfila filene dine moduler er konvertert til variabler som hekker som er nødvendig for å danne navnelignende gjenstander. Legg merke til at den klassen er definert inne i modulen er pent isolert ved bruk av en Iivet (Umiddelbart påkalte funksjon Expression).
Koden nedenfor viser at MyClass variable målrettet mot den MyInternalModule modulen. De kan ikke nås utenfor modulen som er grunnen til at den siste linjen i koden viser feilen kan ikke finne navn MyClass.
Du kan få tilgang til variabelen utenfor modulen ved hjelp av eksport søkeord.
Du kan også utvide interne moduler, dele dem på tvers av filer, og referere dem ved hjelp av trippel slash syntaks. (///)

eksempel :

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

Kompilert versjon av Loggfila:

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

Ekstern Modul:

eksempel :

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

Svarte 29/09/2016 kl. 07:35
kilden bruker vsjondhale

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

§§ 9.3 og 9.4 av spesifikasjonen forklare dette mer tydelig. Jeg skal gjengi her noen av de eksemplene som er gitt i disse avsnittene.

eksterne moduler

Anta følgende kode er i main.ts.

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

Denne filen refererer til en ekstern modul log, definert av uansett log.tseksport.

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

Legg merke til at log.tsikke bruker modulesøkeordet hvor som helst. Den eksporterer bare ting med export.

interne moduler

Denne filen har to interne moduler, 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); 
  } 
}

Disse oppfører seg (for det meste) som eksterne moduler, men de finnes i én fil, og du trenger ikke å referere noen utenfor filer til å bruke dem. De må være inneholdt inne i en moduleblokk når de er definert.