Übersicht

Vor ES6 wurden RequireJS oder seaJS verwendet, um Modularisierung zu implementieren (dies sind Modularisierungsbibliotheken, die auf der AMD-Spezifikation bzw. der CMD-Spezifikation basieren).

ES6 führte Modularisierung ein, mit der Designphilosophie, Modulabhängigkeiten und Ein-/Ausgabevariablen zur Kompilierungszeit zu bestimmen.

ES6-Modularisierung ist in zwei Module unterteilt: export (@) und import.

Funktionen

ES6-Module aktivieren automatisch den Strict Mode, unabhängig davon, ob du ihn am Anfang des Moduls hinzufügst.use strict;。

Module können verschiedene Arten von Variablen importieren und exportieren, wie Funktionen, Objekte, Strings, Zahlen, boolesche Werte, Klassen usw.

Jedes Modul hat seinen eigenen Kontext. In jedem Modul deklarierte Variablen sind lokale Variablen und verschmutzen nicht den globalen Gültigkeitsbereich.

Jedes Modul wird nur einmal geladen (es ist ein Singleton). Wenn dieselbe Datei im selben Verzeichnis erneut geladen wird, wird sie direkt aus dem Speicher gelesen.

export und import

Grundlegende Verwendung

Module importieren und exportieren verschiedene Arten von Variablen, wie Strings, Zahlen, Funktionen und Klassen.

  • Exportierte Funktionsdeklarationen und Klassendeklarationen müssen Namen haben (der Befehl export default ist gesondert zu betrachten).
  • Nicht nur Deklarationen können exportiert werden, auch Referenzen (wie Funktionen) können exportiert werden.
  • Der Befehl export kann überall im Modul vorkommen, muss sich aber auf der obersten Ebene des Moduls befinden.
  • Der Befehl import wird an den Anfang des gesamten Moduls gehoben und zuerst ausgeführt.
/*-----export [test.js]-----*/ let myName = "Tom"; let myAge = 20; let myfn = function(){ return "Mein Name ist" + myName + "! I'm '" + myAge + "Jahre alt." } let myClass = class myClass { static a = "Juhu!"; } export { myName, myAge, myfn, myClass } /*-----import [xxx.js]-----*/ import { myName, myAge, myfn, myClass } from "./test.js"; console.log(myfn());// Mein Name ist Tom! Ich bin 20 Jahre alt. console.log(myAge);// 20 console.log(myName);// Tom console.log(myClass.a );// Juhu!

Es wird empfohlen, geschweifte Klammern zu verwenden, um eine Reihe von zu exportierenden Variablen anzugeben, die am Ende des Dokuments geschrieben werden, um die exportierten Schnittstellen klar zu definieren.

Funktionen und Klassen benötigen beide entsprechende Namen. Das Exportieren am Ende des Dokuments vermeidet auch das Fehlen entsprechender Namen.

Verwendung von as

Die vom export-Befehl exportierten Schnittstellennamen müssen eine Eins-zu-eins-Entsprechung mit den Variablen innerhalb des Moduls haben.

Die importierten Variablennamen müssen mit den exportierten Schnittstellennamen übereinstimmen; die Reihenfolge kann unterschiedlich sein.

/*-----export [test.js]-----*/ let myName = "Tom"; export { myName as exportName } /*-----import [xxx.js]-----*/ import { exportName } from "./test.js"; console.log(exportName);// TomUsageasBenennen Sie die exportierten Schnittstellennamen um, um die Variablen innerhalb des Moduls zu verbergen./*-----export [test1.js]-----*/ let myName = "Tom"; export { myName } /*-----export [test2.js]-----*/ let myName = "Jerry"; export { myName } /*-----import [xxx.js]-----*/ import { myName as name1 } from "./test1.js"; import { myName as name2 } from "./test2.js"; console.log(name1);// Tom console.log(name2);// Jerry

Wenn von verschiedenen Modulen exportierte Schnittstellennamen denselben Namen haben, verwenden Sie as, um die Variablennamen neu zu definieren.

Merkmale des import-Befehls

Schreibgeschützte Eigenschaft: In dem Skript, das das Modul lädt, ist es nicht erlaubt, die Referenz der Schnittstelle zu überschreiben. Das heißt, Sie können die Eigenschaftswerte importierter Variablen vom Objekttyp ändern, aber Sie können die Werte importierter Variablen vom primitiven Typ nicht ändern.

import {a} from "./xxx.js" a = {}; // error import {a} from "./xxx.js" a.foo = "hello"; // a = { foo : 'hello' }

Singleton-Muster: Das mehrfache Ausführen derselben import-Anweisung wird nur einmal ausgeführt, nicht mehrmals. Beim Importieren desselben Moduls und Deklarieren unterschiedlicher Schnittstellenreferenzen werden die entsprechenden Variablen deklariert, aber der Import wird nur einmal ausgeführt.

import { a } "./xxx.js"; import { a } "./xxx.js"; //Entspricht import { a } "./xxx.js"; import { a } from "./xxx.js"; import { b } from "./xxx.js"; //Entspricht import { a, b } from "./xxx.js";

Statisches Ausführungsmerkmal: import wird statisch ausgeführt, daher können Ausdrücke und Variablen nicht verwendet werden.

import { "f" + "oo" } from "methods"; // error let module = "methods"; import { foo } from module; // error if (true) { import { foo } from "method1"; } else { import { foo } from "method2"; } // error

Der Befehl export default

  • In einer Datei oder einem Modul kann es mehrere export- und import-Anweisungen geben, aber nur ein export default.
  • In export default ist default die entsprechende exportierte Interface-Variable.
  • Beim Exportieren mit export müssen Sie beim Importieren { } hinzufügen; bei export default ist dies nicht erforderlich.
  • Die von export default bereitgestellten Member können mit einer beliebigen Variable empfangen werden.
var a = "Mein Name ist Tom!"; export default a; //Nur ein export default var c = "Fehler"; //Fehler, default ist bereits die entsprechende exportierte Variable und darf nicht von einer Variablendeklarationsanweisung gefolgt werden. import b from "./xxx.js"; //Kein {} erforderlich; verwenden Sie eine beliebige Variable, um es zu empfangen.

Kombinierte Verwendung

Hinweis: import() ist ein Vorschlag; wir werden hier vorerst nicht näher darauf eingehen.

export und import können im selben Modul verwendet werden, mit den folgenden Merkmalen:

  • Sie können die exportierten Schnittstellen umbenennen, einschließlich default.
  • Das Kombinieren von export und import kann auch alles exportieren; die vom aktuellen Modul exportierten Schnittstellen überschreiben die geerbten Exporte.
export { foo, bar } from "methods"; //Es ist ungefähr äquivalent zu den folgenden zwei Anweisungen, außer dass die obige import/export-Methode foo und bar nicht in dieses Modul importiert. import { foo, bar } from "methods"; export { foo, bar }; /*------- Funktion 1 --------*/ //Gewöhnliche Umbenennung export { foo as bar } from "methods"; //foo als default erneut exportieren export { foo as default } from "methods"; //default als foo erneut exportieren export { default as foo } from "methods"; /*------- Funktion 2 --------*/ export * from "Methoden";