Node లో CommonJS మరియు ES Modules మధ్య తేడా ఏమిటి?

Question

Accepted Answer

Node **రెండు మాడ్యూల్ సిస్టమ్‌లను** మద్దతు ఇస్తుంది: **CommonJS (CJS)** — అసలు, `require`/`module.exports` ఉపయోగించి — మరియు **ES Modules (ESM)** — ప్రమాణం, `import`/`export` ఉపయోగించి. అవి సింటాక్స్, లోడింగ్ ప్రవర్తన మరియు interop లో విభిన్నంగా ఉంటాయి.

## CommonJS — Node యొక్క అసలు

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

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

## ES Modules — ప్రమాణం

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

## ముఖ్య తేడాలు

```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 ను ప్రారంభించడం

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

వేరుగా `.mjs` పొడిగింపును ఉపయోగించండి. ఇది లేకుండా, Node `.js` ను CommonJS కు డిఫాల్ట్ చేస్తుంది.

## Interop సమస్యలు

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

రుకిణ్ణ అంచు: CJS ESM-only ప్యాకేజీలను `require()` చేయలేదు — సాధారణ మైగ్రేషన్ నొప్పి. ESM `__dirname` లేనిది గమనించండి (`import.meta.url` ఉపయోగించండి).

## ఇది ఎందుకు ముఖ్యమైనది

రెండు సిస్టమ్‌లను తెలుసుకోవడం నిజమైన Node పనికి అవసరం: ESM భవిష్యత్తు (ప్రమాణం, tree-shakeable, top-level await, browser-aligned) మరియు కొత్త ప్రాజెక్ట్‌ల కోసం సరైన ఎంపిక, కానీ npm ఇకోసిస్టమ్ మరియు ఉన్న కోడ్ యొక్క విশాల మొత్తం CommonJS.

సింటాక్స్ తేడాలను, ESM ను ఎలా ప్రారంభించాలో (`"type": "module"`), మరియు interop పరిమితులను (ముఖ్యంగా CJS-can't-require-ESM) అర్థం చేసుకోవడం వాటిని మిశ్రమం చేసినప్పుడు తరచుగా సంభవించే గందరగోళం మరియు లోపాలను నిరోధిస్తుంది.