Erläuterung des TypeScript-Namespace

Vorwort:

namespace wurden vor TypeScript 1.5 als interne Module bezeichnet, da Module in ES6 noch kein formaler Standard waren. Als ES6 die Spezifikation vorschlug, änderte TypeScript 1.5 seinen Namen offiziell in Namespaces und verwendete namespace , um sie zu definieren.

1. Definition und Verwendung

1.1 Definition

Die Definition eines Namespaces entspricht der Definition eines Objekts, in dem Variablen, Schnittstellen, Klassen, Methoden usw. definiert werden können. Wenn jedoch nicht mit dem Schlüsselwort export festgelegt wird, dass dieser Inhalt extern sichtbar ist, kann von außen nicht darauf zugegriffen werden.

Als nächstes definieren Sie eine .ts-Datei zur regelmäßigen Validierung. Der Implementierungscode lautet wie folgt:

// Validierung.ts
//Erstellen Sie einen Namespace mit dem Namen Validation durch den Namespace namespace Validation {
    // Definieren Sie einen regulären Ausdruck const isLetterReg = /^[A-Za-z]+$/
    // Hier definieren wir einen regulären Ausdruck. Der Unterschied zum vorherigen besteht darin, dass dieser reguläre Ausdruck über export const isNumberReg = /^[0-9]+$/ exportiert wird.
    // Eine Methode exportieren export const checkLetter = (text: any) => {
        returniere isLetterReg.test(Text)
    }
}

Im obigen Code definieren wir einen Namespace namens Validation , definieren darin zwei Eigenschaften und eine Methode und exportieren eine Eigenschaft und eine Methode (das Schlüsselwort „export“ wird beim Namespace-Export verwendet).

1.2 Verwendung

Um den Inhalt eines Namespace in einer Datei zu verwenden, verwenden Sie einfach /// <reference path=“namespace.ts”/> um ihn dort einzuführen, wo der externe Namespace verwendet wird. Beachten Sie den dreifachen Schrägstrich /// am Anfang und geben Sie dann im Pfadattribut den Pfad der Namespace-Datei relativ zur aktuellen Datei an. Der spezifische Code lautet wie folgt:

// index.ts
/// <Referenzpfad='validation.ts' />
let isLetter = Validierung.checkLetter('text')
const reg = Validierung.isNumberReg
console.log(istBuchstabe)
console.log(reg)

Beachten Sie /// <reference path='validation.ts' /> in der ersten Zeile. Der grammatische Aufbau darf nicht falsch sein, sonst schlägt die Kompilierung fehl.

Der Kompilierungsbefehl lautet wie folgt:

tsc --outFile src/index.js index.ts

Der Parameter outFile wird verwendet, um die Ausgabedateien in einer Datei zusammenzuführen

Die kompilierte Datei index.js sieht wie folgt aus:

//Erstellen Sie einen Namespace mit dem Namen „Validation“ über den Namespace var Validation.
(Funktion (Validierung) {
    // Definieren Sie einen regulären Ausdruck var isLetterReg = /^[A-Za-z]+$/;
    // Hier definieren wir einen regulären Ausdruck. Der Unterschied zum vorherigen besteht darin, dass dieser reguläre Ausdruck über export exportiert wird. Validation.isNumberReg = /^[0-9]+$/;
    // Exportiere eine Methode Validation.checkLetter = function (text) {
        returniere isLetterReg.test(text);
    };
})(Validierung || (Validierung = {}));
/// <Referenzpfad='validation.ts' />
var isLetter = Validation.checkLetter('text');
var reg = Validierung.isNumberReg;
console.log(istBuchstabe);
konsole.log(reg);

2. In mehrere Dateien aufteilen

Da unser Entwicklungsinhalt ständig zunimmt, können wir denselben Namespace zur separaten Wartung in mehrere Dateien aufteilen. Obwohl wir ihn in mehrere Dateien aufteilen, gehören sie immer noch zu einem Namespace.

Der Beispielcode lautet wie folgt:

LetterValidation.ts

// LetterValidation.ts
Namespace-Validierung {
    export const isLetterReg = /^[A-Za-z]+$/
    export const checkLetter = (Text: beliebig) => {
        returniere isLetterReg.test(Text)
    }
}

NumberValidation.ts

// NumberValidation.ts
Namespace-Validierung {
    export const isNumberReg = /^[0-9]+$/
    export const checkNumber = (Text: beliebig) => {
        gibt isNumberReg.test(Text) zurück
    }
}

index.ts

// index.ts
/// <Referenzpfad="./LetterValidation.ts"/>
/// <Referenzpfad="./NumberValidation.ts"/>
let isLetter = Validierung.checkLetter('text')
const reg = Validierung.isNumberReg
console.log(istBuchstabe)

Wir kompilieren es mit der Kommandozeile:

tsc --outFile src/index.js index.ts

Der endgültig kompilierte index.js-Code lautet wie folgt:

// LetterValidation.ts
var Validierung;
(Funktion (Validierung) {
    Validierung.isLetterReg = /^[A-Za-z]+$/;
    Validation.checkLetter = Funktion (Text) {
        gibt Validation.isLetterReg.test(text) zurück;
    };
})(Validierung || (Validierung = {}));
// NumberValidation.ts
var Validierung;
(Funktion (Validierung) {
    Validierung.isNumberReg = /^[0-9]+$/;
    Validierung.checkNumber = Funktion (Text) {
        gibt Validation.isNumberReg.test(Text) zurück;
    };
})(Validierung || (Validierung = {}));
/// <Referenzpfad="./LetterValidation.ts"/>
/// <Referenzpfad="./NumberValidation.ts"/>
var isLetter = Validation.checkLetter('text');
var reg = Validierung.isNumberReg;
console.log(istBuchstabe);

Aus den Kompilierungsergebnissen ist ersichtlich, dass wir zuerst die Datei LetterValidation.ts und dann die Datei NumberValidation.ts eingeführt haben. Ihre endgültigen Kompilierungsergebnisse werden ebenfalls in der Reihenfolge der Einführung kompiliert.

3. Aliase

Aliase sind eine Möglichkeit, Namespace-Operationen zu vereinfachen. Die Syntax besteht in der Verwendung des Schlüsselworts „import“. Die Verwendung ist wie folgt:

importiere q = xyz

Es ist zu beachten, dass diese Methode nicht mit der Syntax import x = require('name') des übergeordneten Moduls verwechselt werden sollte. Die Syntax hier erstellt einen Alias ​​für das angegebene Symbol. Mit dieser Methode können Aliase für beliebige Bezeichner erstellt werden, einschließlich in Module importierter Objekte.

// Definieren Sie einen Namespace Namespace Shapes {
    // Definiere einen Unternamespace im Namespace und exportiere ihn export namespace Polygons {
        Exportklasse Dreieck {}
        Exportklasse Quadrat {}
    }
}
// Benennen Sie den exportierten Unternamespace mit der Importsyntax in Polygone um
Polygone importieren = Formen.Polygone
// Instanziieren Sie die Square-Klasse aus dem exportierten Namespace let sq = new polygons.Square()

Anhand dieses Beispiels können wir erkennen, dass die Verwendung des Schlüsselworts import zum Definieren eines Alias ​​für ein Ausgabeelement in einem Namespace den Aufwand für das Abrufen von Attributen auf einer tieferen Ebene verringern kann.

Dies ist das Ende dieses Artikels über TypeScript -Namespaces. Weitere Informationen zu TypeScript-Namespaces finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!