Modullar - ESM va CommonJS

Node da har bir fayl - alohida modul. Undagi o'zgaruvchilar tashqariga chiqmaydi, toki siz ularni ochiq eksport qilmaguningizcha.

Node da ikki modul tizimi bor va ikkalasini ham bilish kerak.

ESM - zamonaviy usul #

Avval eksport qiladigan fayl yozamiz:

export const PI = 3.14159;

export function qosh(a, b) {
    return a + b;
}

export function kopaytir(a, b) {
    return a * b;
}

export default function salomla(ism) {
    return `Salom, ${ism}!`;
}

Endi uni ishlatamiz:

import salomla, { PI, qosh, kopaytir } from "./hisob.mjs";

console.log(salomla("Malika"));
console.log(qosh(2, 3), kopaytir(4, 5));
console.log(PI);

Salom, Malika!
5 20
3.14159

Ikki xil eksport bor:

Odatiy eksport faylda bittagina bo'ladi va uni import qilganda istalgan nom berish mumkin.

Error: Cannot find module '.../hisob'

Nomni o'zgartirish va hammasini olish #

import { qosh as yigindi, PI } from "./hisob.mjs";
import * as hisob from "./hisob.mjs";

console.log(yigindi(10, 20));
console.log(hisob.kopaytir(3, 3));
console.log(typeof hisob.default);
console.log(Object.keys(hisob).sort().join(", "));

30
9
function
PI, default, kopaytir, qosh

as bilan nomni almashtirish mumkin - to'qnashuvlarda foydali.

* as nom esa butun modulni bitta obyekt sifatida beradi.

E'tibor bering: Object.keys natijasi saralangan, chunki modul kalitlari tartibi kafolatlanmaydi.

CommonJS - eski usul #

Node dastlab faqat shu tizimni bilardi va u hali ham juda keng tarqalgan.

const PI = 3.14159;

function qosh(a, b) {
    return a + b;
}

module.exports = { PI, qosh };
module.exports.kopaytir = (a, b) => a * b;

const { PI, qosh } = require("./eski.cjs");
const hammasi = require("./eski.cjs");

console.log(qosh(2, 3));
console.log(PI);
console.log(typeof hammasi.kopaytir);
console.log(Object.keys(hammasi).sort().join(", "));

5
3.14159
function
PI, kopaytir, qosh

CommonJS da module.exports - oddiy obyekt. Unga istalgan narsani qo'yish mumkin.

Ikkisining farqi #

Kengaytmalar va type #

Qaysi tizim ishlashini ikki narsa hal qiladi:

Kengaytma har doim kuchliroq: package.json da "type": "module" bo'lsa ham, .cjs fayli CommonJS bo'lib qolaveradi.

Dinamik import #

import ni shart ichiga yozib bo'lmaydi, lekin funksiya shakli bor:

const kerakmi = true;

if (kerakmi) {
    const hisob = await import("./hisob.mjs");
    console.log(hisob.qosh(7, 8));
}

const nom = "./hisob.mjs";
const { PI } = await import(nom);
console.log(PI);

15
3.14159

import() - vada (Promise) qaytaradigan funksiya. U:

• shart ichida ishlaydi;
• modul nomini o'zgaruvchidan oladi;
• katta modulni faqat kerak bo'lganda yuklashga imkon beradi.

node: prefiksi #

import { join } from "node:path";
import { readFile } from "node:fs/promises";

console.log(join("hujjatlar", "hisobot.txt"));
console.log(typeof readFile);

hujjatlar/hisobot.txt
function

node: - bu ichki modul degan aniq belgi.

Yuqori darajada await #

const boshlanish = "ESM da await";

const natija = await Promise.resolve("darhol ishlaydi");

console.log(boshlanish);
console.log(natija);

ESM da await
darhol ishlaydi

ESM da await ni funksiyadan tashqarida, faylning eng yuqorisida ishlatish mumkin.

CommonJS da bu mumkin emas - u yerda async funksiya o'rab yozish kerak bo'ladi.

Modul bir marta yuklanadi #

let soni = 0;

export function oshir() {
    soni += 1;
    return soni;
}

import { oshir } from "./hisoblagich.mjs";
import { oshir as yana } from "./hisoblagich.mjs";

console.log(oshir(), oshir());
console.log(yana());

1 2
3

Ikki marta import qilindi, lekin hisoblagich umumiy bo'lib qoldi.

Node har bir modulni bir marta yuklaydi va natijani keshda saqlaydi. Keyingi importlar o'sha nusxani oladi.

Ikki tizimni aralashtirish #

import.meta #

console.log(typeof import.meta.url);
console.log(import.meta.url.startsWith("file:"));
console.log(import.meta.url.endsWith(".mjs"));
console.log(typeof import.meta.dirname);

string
true
true
string

CommonJS da __dirname va __filename o'zgaruvchilari bor edi. ESM da ular yo'q, o'rniga import.meta keladi.

import.meta.dirname va import.meta.filename - Node 20.11 dan qo'shilgan qulay shakllar.

Xulosa #

• Har bir fayl - alohida modul; tashqariga faqat eksport qilingani chiqadi.
• ESM: export va import; CommonJS: module.exports va require.
• ESM da fayl kengaytmasi majburiy.
• import - e'lon, oldindan tahlil qilinadi; shu sababdan tree shaking mumkin.
• Kengaytma (.mjs / .cjs) package.json dagi type dan kuchliroq.
• Shart ichida yuklash kerak bo'lsa - await import().
• Ichki modullarni doim node: prefiksi bilan chaqiring.
• ESM da yuqori darajada await ishlaydi.
• Modul bir marta yuklanadi - modul darajasidagi holat global holatga aylanadi.
• Yangi loyihada faqat ESM; CommonJS ni eski kodni o'qish uchun biling.

Keyingi bo'limda npm va paketlarni o'rganamiz.