Ca și în titlu: Are namespace suport masina de scris? Dacă da, cum le folosesc?
Are suport typescript spațiu de nume?
Typescript permite definirea modulelor strâns legate de ceea ce va fi în ECMAScript 6. Următorul exemplu este luat din spec:
module outer {
var local = 1;
export var a = local;
export module inner {
export var x = 10;
}
}
După cum vedeți, modulele au nume și pot fi imbricate. Dacă utilizați punctele în numele module, dactilografiat va compila acest lucru module imbricate după cum urmează:
module A.B.C {
export var x = 1;
}
Acest lucru este egal cu
module A {
module B {
module C {
export var x = 1;
}
}
}
Ce este, de asemenea, important este că, dacă reutilizați exact același nume modul într-un program dactilografiat, codul va aparține aceluiași modul. Prin urmare, puteți utiliza module imbricate pentru a pune în aplicare namespace hierarchichal.
Ca de versiunea 1.5, typescript acceptă namespacecuvinte cheie. Namespaces sunt echivalente cu modulele interne.
De Ce este nou dactilografiat :
Inainte de:
module Math { export function add(x, y) { ... } }După:
namespace Math { export function add(x, y) { ... } }
Pentru a defini un modul intern, acum puteți utiliza ambele moduleși namespace.
Aici este un exemplu typescript spațiu de nume:
///<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();
}
}
}
Puteți verifica mai multe aici: http://www.codebelt.com/typescript/javascript-namespacing-with-typescript-internal-modules/
Nu există nici un cuvânt cheie „spațiu de nume“, dar modulele interne (folosind cuvântul cheie „modul“) și modulele externe (folosind cuvântul cheie „export“) oferă o modalitate similară de a împărți codul în ierarhii logice.
Fals...
module A.B.C {
export var x = 1;
}
este egal cu
module A {
export module B {
export module C {
export var x = 1;
}
}
}
pentru că puteți scrie în afara modulului A:
var y = A.B.C.x;
Dar :
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













