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, ਬ੍ਰਾਊਜ਼ਰ-ਸਮਰੂਪ) ਅਤੇ ਨਵੀਆਂ ਪ੍ਰਾਜੈਕਟਾਂ ਲਈ ਸਹੀ ਚੋਣ ਹੈ, ਪਰ npm ਈਕੋਸਿਸਟਮ ਅਤੇ ਮੌਜੂਦਾ ਕੋਡ ਦਾ ਇੱਕ ਬਹੁਤ ਵੱਡਾ ਹਿੱਸਾ CommonJS ਹੈ।

ਸਿੰਟੈਕਸ ਦੇ ਫ਼ਰਕਾਂ, ESM ਨੂੰ ਕਿਵੇਂ ਸਮਰਥ ਕਰਨਾ ਹੈ (`"type": "module"`), ਅਤੇ interop ਸੀਮਾਵਾਂ (ਖਾਸ ਤੌਰ ਤੇ CJS-ਨਹੀਂ-require-ESM) ਨੂੰ ਸਮਝਣਾ ਸਮੱਸਿਆਮੁਲੀ ਉਲਝਨ ਅਤੇ ਗ਼ਲਤੀਆਂ ਨੂੰ ਰੋਕਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਨੂੰ ਮਿਲਾਉਣ ਵੇਲੇ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ।