Node.js'da xatolar va jurnal (log)

SQLite darsida baza bilan ishlaydigan kod yozdingiz. Endi savol: baza javob bermasa nima bo’ladi? Dastur yiqilsa, ertalab uning nega yiqilganini qanday bilasiz?

Serverda console.log ni kuzatib o’tiradigan odam yo’q. Shuning uchun xatoni to’g’ri qayd etish serverda ishlaydigan dastur uchun majburiy ko’nikma.

Error obyekti nimani saqlaydi

JavaScript xatolar darsida try/catch bilan tanishgansiz. Node.js’da Error obyektining uchta maydoni doim ishlaydi:

const error = new Error("Fayl o'qilmadi");

console.log("Xabar:", error.message);
console.log("Nomi:", error.name);
console.log("Stack bormi:", typeof error.stack === "string");

node error-basic.js

Xabar: Fayl o'qilmadi
Nomi: Error
Stack bormi: true

Node.js xatolarida code maydoni

Node.js ning tizim xatolarida qo’shimcha maydon bo’ladi:

const fs = require("node:fs");

try {
  fs.readFileSync("yoq.txt", "utf8");
} catch (error) {
  console.log("Xabar:", error.message);
  console.log("Kod:", error.code);
}

node code-demo.js

Xabar: ENOENT: no such file or directory, open 'yoq.txt'
Kod: ENOENT

message emas, code bo'yicha tekshiring

error.message matni Node.js versiyasi bilan o’zgarishi mumkin, code esa barqaror. Shuning uchun shartni code ga qo’ying:

if (error.code === "ENOENT") {
  // Fayl yo'q
}

Matnni includes("no such file") bilan tekshirish mo’rt yechim.

Tez uchraydigan kodlar:

Kod	Ma’nosi
`ENOENT`	Fayl yoki papka topilmadi
`EACCES`	Ruxsat yo’q
`EADDRINUSE`	Port band
`ECONNREFUSED`	Ulanish rad etildi

O’z xato klassingiz

Dasturda xatoning turi muhim: foydalanuvchi noto’g’ri ma’lumot kiritdimi yoki baza ishlamadimi? Buni ajratish uchun klass yaratiladi:

class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = "ValidationError";
    this.field = field;
  }
}

function createUser(name) {
  if (!name) {
    throw new ValidationError("Ism bo'sh bo'lmasligi kerak", "name");
  }
  return { name };
}

try {
  createUser("");
} catch (error) {
  console.log("Turi:", error.name);
  console.log("Xabar:", error.message);
  console.log("Maydon:", error.field);
  console.log("ValidationError'mi:", error instanceof ValidationError);
  console.log("Error'mi:", error instanceof Error);
}

node custom-error.js

Turi: ValidationError
Xabar: Ism bo'sh bo'lmasligi kerak
Maydon: name
ValidationError'mi: true
Error'mi: true

Ikkala instanceof ham true — bu meros tufayli. Endi xatolarni turiga qarab ajratish mumkin:

try {
  createUser("");
} catch (error) {
  if (error instanceof ValidationError) {
    console.log(`Kiritishda xato: ${error.field}`);
  } else {
    throw error;
  }
}

Kiritishda xato: name

Tanimagan xatoni yutib yubormang

catch blokida hamma xatoni bir xil ushlab, jim o’tkazib yuborish eng xavfli odat:

// Bunday yozmang
try {
  await saveUser(user);
} catch (error) {
  // Hech narsa qilinmadi
}

Bunda kod xatosi ham, baza uzilishi ham ko’rinmay qoladi. Dastur “ishlayotgandek” tuyuladi, lekin ma’lumot saqlanmaydi.

Yuqoridagi misoldagi throw error qatori muhim: siz kutmagan xato yuqoriga o’tib ketishi kerak.

cause — xatoning asl sababi

Pastki qatlamdagi xatoni yuqorida qayta o’rashda asl sabab yo’qolmasligi kerak. Buning uchun cause bor:

const fs = require("node:fs");

function loadConfig(filePath) {
  try {
    const content = fs.readFileSync(filePath, "utf8");
    return JSON.parse(content);
  } catch (error) {
    throw new Error(`Sozlama fayli o'qilmadi: ${filePath}`, {
      cause: error,
    });
  }
}

try {
  loadConfig("yoq.json");
} catch (error) {
  console.log("Yuqori xato:", error.message);
  console.log("Asl sabab:", error.cause.code);
}

node cause-demo.js

Yuqori xato: Sozlama fayli o'qilmadi: yoq.json
Asl sabab: ENOENT

Natijada ikki qatlam ham saqlanadi: dastur tilida tushunarli xabar va texnik sabab. cause siz yozilganda ENOENT butunlay yo’qolardi.

Asinxron kodda try/catch

async/await bilan try/catch odatdagidek ishlaydi:

const fs = require("node:fs/promises");

async function readNotes() {
  try {
    const content = await fs.readFile("yoq.txt", "utf8");
    return content;
  } catch (error) {
    console.log("Ushlandi:", error.code);
    return "";
  }
}

readNotes().then((text) => {
  console.log("Uzunlik:", text.length);
});

node async-catch.js

Ushlandi: ENOENT
Uzunlik: 0

await unutilsa xato ushlanmaydi

Quyidagi kodda try/catch bor, lekin u ishlamaydi:

async function broken() {
  try {
    // await yo'q — Promise qaytadi, xato keyinroq chiqadi
    return fs.readFile("yoq.txt", "utf8");
  } catch (error) {
    console.log("Bu blok ishlamaydi");
  }
}

await yozilmagani uchun funksiya xato yuz berishidan oldin tugaydi. catch bloki kutmaydi va xato ushlanmay yuqoriga chiqib ketadi.

Qoida: try ichida Promise qaytaradigan chaqiruv oldiga har doim await qo’ying.

console.log nega yetarli emas

Xatoni ko’rsatishning eng oson yo’li — console.log. Muammo bir necha:

console.log("Xato:", "Baza ulanmadi");

Xato: Baza ulanmadi

Bu qator serverga yozilganda savollar javobsiz qoladi:

Qachon sodir bo’ldi?
Bu jiddiy xatomi yoki ogohlantirishmi?
Qaysi foydalanuvchida yuz berdi?
Mingta qator ichidan buni qanday qidiraman?

Yechim — jurnalga tuzilgan ma’lumot yozish.

Jurnal darajalari

Hamma yozuv bir xil ahamiyatga ega emas. Shuning uchun daraja ishlatiladi:

Daraja	Qachon
`debug`	Ishlab chiqish paytidagi tafsilot
`info`	Oddiy hodisa: server ishga tushdi
`warn`	Shubhali holat, lekin ish davom etyapti
`error`	Amal bajarilmadi

Oddiy jurnal yozuvchi

logger.js faylini yarating:

const LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };

// Daraja muhitdan olinadi, berilmasa info
const currentLevel = LEVELS[process.env.LOG_LEVEL] || LEVELS.info;

function log(level, message, details = {}) {
  // Joriy darajadan pastini yozmaymiz
  if (LEVELS[level] < currentLevel) {
    return;
  }

  const record = {
    time: new Date().toISOString(),
    level,
    message,
    ...details,
  };

  console.log(JSON.stringify(record));
}

module.exports = { log };

Ishlatib ko’ramiz:

const { log } = require("./logger");

log("debug", "Bu chiqmaydi");
log("info", "Server ishga tushdi", { port: 3000 });
log("error", "Baza ulanmadi", { attempt: 2 });

node log-demo.js

{"time":"2026-09-12T13:05:02.882Z","level":"info","message":"Server ishga tushdi","port":3000}
{"time":"2026-09-12T13:05:02.885Z","level":"error","message":"Baza ulanmadi","attempt":2}

debug yozuvi chiqmadi — joriy daraja info. Uni ko’rish uchun muhit o’zgaruvchisini bering:

node --env-file=.env log-demo.js

.env faylida:

LOG_LEVEL=debug

Muhit o’zgaruvchilari process darsida ko’rilgan.

Endi jurnalni qidirish mumkin: har yozuvda vaqt, daraja va qo’shimcha maydonlar bor.

Xatoni jurnalga yozish

Error obyektini to’g’ridan-to’g’ri JSON.stringify ga bersangiz, bo’sh natija chiqadi:

console.log(JSON.stringify(new Error("Test")));

{}

Sabab: message va stack maydonlari sanab o’tiladigan emas. Shuning uchun ularni qo’lda ajratish kerak:

const { log } = require("./logger");

function logError(message, error) {
  log("error", message, {
    errorName: error.name,
    errorMessage: error.message,
    errorCode: error.code,
  });
}

try {
  require("node:fs").readFileSync("yoq.txt", "utf8");
} catch (error) {
  logError("Sozlama o'qilmadi", error);
}

node log-error.js

{"time":"2026-09-12T13:07:41.201Z","level":"error","message":"Sozlama o'qilmadi","errorName":"Error","errorMessage":"ENOENT: no such file or directory, open 'yoq.txt'","errorCode":"ENOENT"}

Oxirgi chora: ushlanmagan xatolar

Node.js ikki hodisa beradi:

process.on("uncaughtException", (error) => {
  console.log("Ushlanmagan xato:", error.message);
  process.exit(1);
});

process.on("unhandledRejection", (reason) => {
  console.log("Ushlanmagan rad etish:", reason.message);
  process.exit(1);
});

// Ataylab ushlanmagan rad etish
Promise.reject(new Error("Baza javob bermadi"));

node unhandled-demo.js

Ushlanmagan rad etish: Baza javob bermadi

Chiqish kodi 1 bo’ladi.

Bu tinglovchilar tuzatish vositasi emas

uncaughtException ushlangandan keyin dasturni davom ettirish xavfli. Xato yuz berganda o’zgaruvchilar yarim holatda qolgan bo’lishi mumkin: tranzaksiya tugallanmagan, fayl yopilmagan.

Shuning uchun to’g’ri yozuv — xatoni jurnalga yozib, so’ng process.exit(1) bilan chiqish:

process.on("uncaughtException", (error) => {
  logError("Kutilmagan xato, dastur to'xtatilyapti", error);
  process.exit(1);
});

Dasturni qayta ishga tushirishni PM2 bajaradi. Bu tinglovchilarning vazifasi — yiqilish sababini yo’qotmasdan qayd etish, davom etish emas.

Amaliy mashq

node-start papkasida bajaring:

Mavjud bo’lmagan faylni readFileSync bilan o’qib, error.code qiymatini chiqaring;
ValidationError klassini yozib, instanceof bilan uni oddiy Error dan ajrating;
cause opsiyasi bilan xatoni qayta o’rang va ikkala qatlamni ham chiqaring;
try ichida await ni ataylab tushirib qoldiring hamda xato ushlanmay qolishini kuzating;
logger.js ni yozib, uchta darajada yozuv chiqaring va LOG_LEVEL=debug bilan farqni ko’ring;
unhandledRejection tinglovchisini qo’shib, ushlanmagan Promise qanday qayd etilishini tekshiring.

4-qadam eng muhimi: unutilgan await xatoni ko’rinmas qiladi va uni topish uzoq vaqt oladi.

Qisqacha xulosa

Error obyektida message, name va stack maydonlari bor.
Node.js tizim xatolarida code maydoni barqaror — shartni matnga emas, shunga qo’ying.
O’z xato klassingiz xato turini ajratish imkonini beradi.
cause opsiyasi asl sababni yo’qotmasdan xatoni qayta o’raydi.
try ichida await yozilmasa, catch xatoni ushlamaydi.
Tuzilgan JSON jurnal vaqt, daraja va qo’shimcha maydonlarni saqlaydi — uni qidirish mumkin.
uncaughtException va unhandledRejection — oxirgi chora: qayd etib, dasturdan chiqiladi.

Keyingi darsda node:test bilan testlash — kodni qo’lda tekshirishdan voz kechish.