Node.js Modulimport

Wenn Sie mit dem Schreiben eines Node.js-Projekts beginnen, ist eines der ersten Probleme, auf die Sie stoßen, wie Module importiert werden.

In Node.js sind Module wiederverwendbare JavaScript-Dateien, die über Import und Export miteinander kommunizieren.

Das Node.js-Ökosystem unterstützt hauptsächlich zwei Modulsysteme:CommonJSund ES Modules (ESM)。

Modulsystem Spezifikation Dateiendung Importmethode Exportmethode
CommonJS Frühe Node.js-Nutzung .js require() module.exports / exports
ES-Modul (ESM) ECMAScript-Standard .mjsoder"type": "module" import export / export default

CommonJS-Modulsystem

CommonJS ist das früheste und am weitesten verbreitete Modulsystem in Node.js. Es verwendet synchrones Laden, was bedeutet, dass beim Laden eines Moduls die Programmausführung blockiert wird, bis das Laden abgeschlossen ist.

Import und Export

In CommonJS verwenden Sierequire()die Funktion zum Importieren von Modulen und verwendenmodule.exportsoderexportsdas Objekt zum Exportieren von Modulen.

Exportmethoden:

Code der Datei math.js:

// math.js
function add(a, b) {
  return a + b;
}

module.exports = { add };
// Oder: exports.add = add;

Importmethoden:

Beispiel

// app.js
const math = require('./math.js');

console.log(math.add(2, 3)); // 5

Damit ein Modul externen Zugriff auf seinen Inhalt ermöglicht, muss es module.exports oder exports verwenden, um ihn zu exportieren:

Beispiel

// user.js
const name = 'Alice';
const age = 30;

// Methode 1: Verwenden Sie module.exports, um ein einzelnes Objekt oder einen einzelnen Wert zu exportieren
module.exports = {
  name: name,
  age: age,
  sayHello: () => {
    console.log(`Hallo, mein Name ist ${name}.`);
  }
};

// Methode 2: Verwende exports, um mehrere benannte Variablen zu exportieren
// exports ist eine Referenz auf module.exports
exports.name = name;
exports.age = age;
exports.sayHello = () => {
  console.log(`Hallo, mein Name ist ${name}.`);
};

Importmethoden:

Beispiel

// main.js
const user = require('./user.js');

console.log(user.name); // Ausgabe: Alice
user.sayHello(); // Ausgabe: Hallo, mein Name ist Alice.

// Du kannst auch direkt destrukturieren
const { name, age } = require('./user.js');
console.log(name); // Ausgabe: Alice

CommonJS-Merkmale:

  • Synchrones Laden: Geeignet für serverseitige Umgebungen, da Module normalerweise im lokalen Dateisystem liegen und schnell geladen werden.
  • Laden zur Laufzeit：require()Du kannst es überall im Code aufrufen, wodurch du Module abhängig von Bedingungen dynamisch laden kannst.
  • Caching-Mechanismus：require()Geladene Module werden zwischengespeichert. Beim zweiten Import werden sie direkt aus dem Cache gelesen, wodurch wiederholtes Laden vermieden wird.

ES-Modul-Spezifikation (ESM)

ESM ist der offizielle JavaScript-Modulstandard. Es verwendet asynchrones Laden und ist die erste Wahl für Browser und moderne Node.js-Anwendungen.

In ESM verwendest duimport-Anweisung, um Module zu importieren, und verwendestexport-Anweisung, um Module zu exportieren.

ESM aktivieren:Um ESM in Node.js zu verwenden, musst du"type": "module"hinzufügen oder die Dateiendung zu.mjs ändern。

// package.json
{
  "type": "module"
}

Module exportieren:

Beispiel

// math.mjs
export function add(a, b) {
  return a + b;
}

export default function multiply(a, b) {
  return a * b;
}

Module importieren:

Beispiel

// app.mjs
import multiply, { add } from './math.mjs';

console.log(add(2, 3));      // 5
console.log(multiply(2, 3)); // 6

So aktivierst du:

  • Dateiendung verwenden.mjs

  • Oder dies in package.json hinzufügen:

    {
  "type": "module"
}

ESM unterstützt zwei Exportmethoden: benannte Exporte und Default-Export.

Beispiel

// user.mjs

// Benannter Export
export const name = 'Bob';
export const age = 25;

// Standard-Export
const sayHello = () => {
  console.log(`Hallo, mein Name ist ${name}.`);
};
export default sayHello;

Importmethoden:

Beispiel

// main.mjs

// Benannten Export importieren
import { name, age } from './user.mjs';
console.log(name); // Ausgabe: Bob

// Standard-Export importieren
import sayHello from './user.mjs';
sayHello(); // Ausgabe: Hallo, mein Name ist Bob.

// Benannte und Default-Exporte zusammen importieren
import sayHello, { name } from './user.mjs';
console.log(name);
sayHello();

// Alle benannten Exporte als Eigenschaften eines Objekts importieren
import * as user from './user.mjs';
console.log(user.name);
user.default(); // Der Default-Export wird die default-Eigenschaft sein

ESM-Funktionen:

  • Asynchrones Laden: Standardmäßig ist es asynchron und blockiert nicht den Hauptthread, wodurch es besser für Browserumgebungen geeignet ist, aber in Node.js verhält es sich normalerweise wie synchrones Laden.
  • Statische Analyse：importundexportAnweisungen können Modulabhängigkeiten vor der Codeausführung bestimmen, sodass Tools (wie Webpack, Vite) bessere Optimierungen durchführen können (wieTree Shaking）。
  • Strikter Modus: ESM-Module werden standardmäßig im strikten Modus ausgeführt.

Unterschiede zwischen CommonJS und ESM

Item CommonJS ESM
Syntax require / module.exports import / export
Lademechanismus Synchrones Laden zur Laufzeit Statisches Laden zur Kompilierzeit
Standardmäßige Unterstützung Standardmäßig in Node.js unterstützt Benötigt.mjsoder"type": "module"
Geeignete Szenarien Backend-Skripte, Legacy-Projekte Moderne Frontend- und Backend-Projekte, Tree-shaking
Können sie gemischt werden? Können nicht direkt gemischt werden (erfordert zusätzliche Konfiguration) Können nicht direkt gemischt werden (erfordert zusätzliche Konfiguration)

Gemischte Verwendung

Node.js unterstützt die Koexistenz beider Modulsysteme in neueren Versionen. Sie können CommonJS und ESM im selben Projekt zusammen verwenden, müssen jedoch Folgendes beachten:

  • ESM kann nicht direkt verwendenrequire()undmodule.exports。
  • CommonJS kann nicht direkt verwendenimportundexport。

  • Wenn Sie ein CommonJS-Modul in ESM importieren möchten, können Sie direktimportdie Anweisung verwenden, und ESM behandelt sie als Default-Export.

    // commonjs_module.js
module.exports = { data: 'hello' };

// esm_module.mjs
import commonModule from './commonjs_module.js';
console.log(commonModule.data); // 输出: hello

  • Wenn Sie ein ESM-Modul in CommonJS importieren möchten, müssen Sie dynamischen Import verwendenimport()Funktion.

    // esm_module.mjs
export const name = 'Bob';

// commonjs_module.js
async function loadESM() {
  const { name } = await import('./esm_module.mjs');
  console.log(name);
}
loadESM();

Best-Practice-Vorschläge

Für neue Projekte,wird die Verwendung von ES Modules (ESM) dringend empfohlen. Es ist nicht nur der offizielle Standard für JavaScript, sondern auch besser kompatibel mit modernen Frontend-Toolchains (wie Vite, Next.js) und kann Optimierungstechniken wie Tree Shaking voll ausnutzen, um die Größe des gebündelten Codes zu reduzieren.

Wenn Sie ein altes CommonJS-Projekt pflegen und keine ESM-Funktionen benötigen, können Sie weiterhin CommonJS verwenden. Wenn Sie jedoch neue Abhängigkeiten einführen oder die neuen Funktionen von ESM nutzen möchten, können Sie eine schrittweise Migration oder die Verwendung des gemischten Modus als Übergang in Betracht ziehen.

Andere Erweiterungen