Node இல் CommonJS மற்றும் ES Modules இடையே உள்ள வேறுபாடு என்ன?

Question

Accepted Answer

Node **இரண்டு மாடியூல் அமைப்புகளை** ஆதரிக்கிறது: **CommonJS (CJS)** — அசல், `require`/`module.exports` ஐ பயன்படுத்துகிறது — மற்றும் **ES Modules (ESM)** — தரநிலை, `import`/`export` ஐ பயன்படுத்துகிறது. அவை தொடரியல், loading நடத்தை மற்றும் 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) அவற்றை கலக்கும்போது எழும் அடிக்கடி குழப்பம் மற்றும் பிழைகளைத் தடுக்கிறது.