Come nel titolo: does namespace supporto tipografico? Se sì, come posso usarli?
Supportati da dattiloscritto dello spazio dei nomi?
Dattiloscritto permette di definire moduli strettamente correlati a quello che sarà in ECMAScript 6. Il seguente esempio è preso dal spec:
module outer {
var local = 1;
export var a = local;
export module inner {
export var x = 10;
}
}
Come si può vedere, i moduli hanno nomi e possono essere nidificate. Se si utilizzano i punti di nomi di modulo, dattiloscritto compilerà questo per moduli annidati nel seguente modo:
module A.B.C {
export var x = 1;
}
Quest'ultimo è pari
module A {
module B {
module C {
export var x = 1;
}
}
}
Ciò che è anche importante è che se si riutilizza lo stesso nome del modulo in un programma dattiloscritto, il codice apparterrà allo stesso modulo. Quindi, è possibile utilizzare i moduli annidati per implementare gli spazi dei nomi hierarchichal.
A partire dalla versione 1.5, supporta tipografico namespaceparola chiave. Namespace sono equivalenti ai moduli interni.
Da Cosa c'è di nuovo in tipografico :
Prima:
module Math { export function add(x, y) { ... } }Dopo:
namespace Math { export function add(x, y) { ... } }
Per la definizione di un modulo interno, ora è possibile utilizzare entrambi modulee namespace.
Ecco un esempio dattiloscritto spazio dei nomi:
///<reference path='AnotherNamespace/ClassOne.ts'/>
///<reference path='AnotherNamespace/ClassTwo.ts'/>
module MyNamespace
{
import ClassOne = AnotherNamespace.ClassOne;
import ClassTwo = AnotherNamespace.ClassTwo;
export class Main
{
private _classOne:ClassOne;
private _classTwo:ClassTwo;
constructor()
{
this._classOne = new ClassOne();
this._classTwo = new ClassTwo();
}
}
}
È possibile controllare più qui: http://www.codebelt.com/typescript/javascript-namespacing-with-typescript-internal-modules/
Non v'è alcuna parola chiave 'namespace', ma moduli interni (usando la parola chiave 'modulo') e moduli esterni (usando la parola chiave 'esportazione') offrono un modo simile per partizionare il vostro codice in gerarchie logiche.
False ...
module A.B.C {
export var x = 1;
}
è uguale a
module A {
export module B {
export module C {
export var x = 1;
}
}
}
perché si può scrivere al di fuori del modulo A:
var y = A.B.C.x;
Ma :
module A {
module B {
module C {
export var x = 1;
}
var y = C.x; // OK
}
//var y = B.C.x; // Invalid
}
//var y = A.B.C.x; // Invalid













