Mikä on CommonJS:n ja ES Modules:n välinen ero Node:ssa?

Question

IT Interview Practice · Accepted Answer

Node tukee **kahta moduulijärjestelmää**: **CommonJS (CJS)** — alkuperäinen, käyttäen `require`/`module.exports` — ja **ES Modules (ESM)** — standardi, käyttäen `import`/`export`. Ne eroavat syntaksissa, latautumiskäyttäytymisessä ja yhteentoimivuudessa.

## CommonJS — Node:n alkuperäinen

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

// app.js
const { add } = require("./math"); // synchronous, runtime
```

## ES Modules — standardi

```js
// math.mjs (or .js with "type": "module")
export function add(a, b) { return a + b; }
export default something;

// app.mjs
import { add } from "./math.mjs"; // static, hoisted
```

## Tärkeimmät erot

```text
                 CommonJS              ES Modules
Syntax           require/module.exports import/export
Loading          synchronous, runtime  static, hoisted
Top-level await  no                    yes
Tree-shaking     hard                  yes (statically analyzable)
File extension   .cjs / .js (default)  .mjs / .js with "type":"module"
__dirname/__filename available         not available (use import.meta.url)
```

## ESM:n käyttöönotto

```json
// package.json
{ "type": "module" }  // now .js files are treated as ESM
```

Tai käytä `.mjs`-laajennusta erikseen. Ilman tätä Node käyttää oletuksena `.js`:ää CommonJS:nä.

## Yhteentoimivuuden sudenkuopat

```js
// ESM can import CommonJS:
import pkg from "some-cjs-lib"; // works (default import)

// CommonJS CANNOT require() a pure-ESM package (it's async):
const esm = require("esm-only-pkg"); // ❌ ERR_REQUIRE_ESM
// must use dynamic import: const esm = await import("esm-only-pkg");
```

Karkeasti ottaen: CJS ei voi `require()` vain ESM:iin perustuvia paketteja — yleinen siirtamisen ongelma. Huomaa myös, että ESM:iin puuttuu `__dirname` (käytä `import.meta.url`).

## Miksi sillä on väliä

Molemman järjestelmän tunteminen on olennaista todelliselle Node-työlle: ESM on tulevaisuus (standardi, tree-shakeable, top-level await, selaimen mukainen) ja oikea valinta uusille projekteille, mutta suuri osa npm-ekosysteemista ja olemassa olevasta koodista on CommonJS.

Syntaksin erojen ymmärtäminen, ESM:n käyttöönottaminen (`"type": "module"`), ja yhteentoimivuusrajoitusten (erityisesti CJS ei voi vaatia ESM:ää) ymmärtäminen estää yleisen sekaannuksen ja virheet, jotka syntyvät niiden sekoittamisesta.

CommonJS — Node:n alkuperäinen

ES Modules — standardi

Tärkeimmät erot

ESM:n käyttöönotto

Yhteentoimivuuden sudenkuopat

Miksi sillä on väliä

Aiheeseen liittyvät kysymykset