Mi a különbség a CommonJS és az ES Modules között a Node-ban?

Question

Accepted Answer

A Node **két modul rendszert** támogat: a **CommonJS (CJS)** — az eredeti, amely `require`/`module.exports` használ — és az **ES Modules (ESM)** — a standard, amely `import`/`export` használ. Szintaksisban, betöltési viselkedésben és interoperabilitásban különböznek.

## CommonJS — Node eredeti rendszere

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

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

## ES Modules — a standard

```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
```

## Fő különbségek

```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 engedélyezése

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

Vagy explicit módon használja a `.mjs` kiterjesztést. Ennek nélkül a Node a `.js`-t CommonJS-re állítja be alapértelmezettként.

## Interoperabilitási csapdák

```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");
```

A durva él: a CJS nem tudja `require()`-ezni az ESM-only csomagokat — gyakori migrációs fájdalom. Azt is vegye figyelembe, hogy az ESM nem rendelkezik `__dirname`-nel (használja az `import.meta.url`-t helyette).

## Miért fontos ez

Mindkét rendszer ismerete elengedhetetlen a valódi Node munkához: az ESM a jövő (standard, tree-shakeable, top-level await, böngészővel összhangban) és az új projektek helyes választása, de az npm ökoszisztéma és a meglévő kód nagy része CommonJS.

A szintaktikai különbségek megértése, az ESM engedélyezésének módja (`"type": "module"`), és az interoperabilitási korlátozások (különösen CJS-nem-tudja-require-ezni-az-ESM-t) megakadályozza a gyakori félreértéseket és hibákat, amelyek a keveredéskor felmerülnek.