Hogyan terjed a modul több AMD fájlokat?

Question

Hogyan terjed a modul több AMD fájlokat?

szavazat

8

Nem tudok rájönni, hogy ez is lehetséges, hogy van egy „export modul” terjedt szinkronizálása több fájlt.

Ha van fájl Contact.ts:

// file Contact.ts
export module Contacts {
   export class Contact {
      ...
   }
}

és a másik ContactView.ts

// file ContactView.ts
export module Contacts {
   export class ContactView {
      model: Contact;  // <---  is not recognized
   }
}

Akkor TSC nem ismeri fel a Kapcsolat osztályban. Mint látható, a Kapcsolat, a ContactView nyilvánítják tartózkodnak ugyanabban a modulban, és az a spec meg kell dolgozni.

Építek egy összetett alkalmazás, amely a require.js és AMD mintákat, így azt kell használni a „kiviteli modul” nyilatkozatot.

Teendő bizonyos típusú „előre nyilatkozat” vagy valami trükkös „import”?

Köszönöm a tanácsot.

EDIT: Jelenleg betölteni az egyes modulok külön importálás útján, de ha észre fogod venni, hogy létrehoz egy hatalmas hulladék kód és sok „import” függőségeket. A kérdésem az volt, hogy van egy módja annak, hogy ugyanazt a névtér (vagyis Kapcsolatok), hogy tudják, a TS, hogy én nem értem, hogy a behozatali. Kerestem a normál // parancsot, de ez nem működik. Én is próbáltam a * .d.ts nyilatkozatot fájlokat nem járt sikerrel eddig.

typescript

A kérdést 08/10/2012 23:18
a forrás felhasználó IgorM

Más nyelveken...

2 válasz

nxn · Answer 1 · 2012-10-09 02:21

A spec lehetővé teszi, hogy meghatározza a belső modulok több fájlon keresztül (lényegében a belső modulok lásd a javascript modul minta). Külső modulok, mint például az AMD vagy CommonJS modulok, a munka a gondolat, hogy minden fájl a tényleges „modul kód”, és a névterek / elnevezési belül nem releváns, mivel a modul lesz betöltve saját új objektumot egyébként.

Lehet írni a következő kódot betölteni a Contact.ts modul belsejében a ContactView.ts modul:

// file ContactView.ts    
import mod = module("./Contact");

export module Contacts {
   export class ContactView {
      model: mod.Contacts.Contact;  // <---  will be recognized
   }
}

És ez jól működik elég, de ha azt akarta, hogy hozzáférést biztosítanak a két modul egy másik területen (például az, hogy egy új modell Kapcsolat magad), akkor kellett volna lényegében importálni mindkettő:

import c = module("./Contact");
import cv = module("./ContactView");

Ami szerintem elég finom, mert te világosan jelölje meg a függőségek. A hátránya az, hogy szokás közös szülő objektumot, úgy, hogy azokat mind abban a „Kapcsolat” modul-minta valószínűleg nem nagy hasznukat.

Egy másik lehetőség az, hogy exportálja a „Kapcsolat” együtt „ContactView”, az alábbiak szerint (nyújtott be ezt a kódot a fajta buta, mert már pontosan ezt teszi át a modell tulajdonsága ContactView, de nem kevésbé ...):

export module Contacts {
   export class ContactView {
       model: mod.Contacts.Contact;
       constructor() {
           this.model = new mod.Contacts.Contact();
       }
    }

    export var Contact = mod.Contacts.Contact;
}

Tehát akkor lenne képes elérni, hogy miután betöltött ContactView.

EDIT: By the way, akkor nem korlátozódhat csupán az exportáló modullal „export modul neve {...}”, akkor export semmit, mint a fájl maga a modul. Így lehet egy fájl, amely éppen az „export function ize () {...}” nélkül modul-minta kódot becsomagolta.

Edit2: Úgy néz ki, mint az AMD is van alkalmassága betöltésére több függőségek és építése „modulok” azoktól, de fogalmam sincs, hogy ez hogyan fog működni a TS, itt egy link, hogy megy át, hogy: http://www.adobe.com /devnet/html5/articles/javascript-architecture-requirejs-dependency-management.html (Constructor modul).

Morten Mertner · Answer 2 · 2012-12-13 00:12

Küzdöttem ugyanezt a kérdést egy ideig, és csak meg akartam osztani, hogy mit csinálok, ha valaki másnak járja át ezt a kérdést.

Először is, én magam meghatározott referencia fájlt, hogy kijelenti, az összes fájl az én modul:

/// <reference path="_contacts.dependencies.ts" />
/// <reference path="../contacts/Contact.ts" />
/// <reference path="../contacts/ContactView.ts" />
/// <reference path="../contacts/ContactModel.ts" />

Figyeljük meg, hogy utak megadott belsejében fájl képest a helyét a referencia fájl maga ( _contacts.ts), ellentétben a .jsreferencia fájlt. Saját könyvtár felépítése a következőképpen néz ki:

modules
    references // all of the reference files
        knockout 
        underscore
        // ... a subfolder for every 3rd party library used
    contacts
    commerce 
    // ... other modules at same level as contacts

Vissza a referencia fájl maga. Az első sor egy külön referencia fájl felsorolja az összes külső könyvtárak által használt modullal, például aláhúzás, pillanat, vagy bármely más létező könyvtár van egy .d.tsdefiníciós fájl. A fennmaradó sorok vannak a fájlok teszik ki a modult.

Belül minden fájlt, amely része a modul azt hivatkozni a fenti fájlt:

/// <reference path="../references/_contacts.ts" />
module Contacts {
    export class Contact { 
        public model: ContactModel;
        // ...
    }
}

Hasonlóképpen, akkor hozzon létre egy referencia fájlt a listához minden modulok:

/// <reference path="_address.ts" />
/// <reference path="_contacts.ts" />
/// <reference path="_commerce.ts" />

És egyszerűen pont erre az Ön forrás fájlokat.

Ez nem oldja meg a problémát, a kibocsátott kódot, hogy külön fájlokat, mégis. Mert ezt a problémát én egy JavaScript minification eszköz, amely képes a csomagban értékesítés akár több fájlt egyetlen forrásból. Attól függően, hogy összeállítás beállításai és használata esetén igényeinek, akkor lehet, hogy alkalmaz valamilyen közrefogja a generált kódot, hogy működjön, mint egy AMD-modul (nem is ismeri azt a részét még).