Xatoliklarni boshqarish

Maxsus xatoliklar, Error'ni kengaytirish

Ilovamiz murakkablashgani sari, bizga o'z maxsus xato turlari kerak bo'ladi. Masalan, tarmoq operatsiyasida HttpError, ma'lumotlarni tekshirishda ValidationError va hokazo. Bunday xatolar HTTP status kodi yoki noto'g'ri maydon nomi kabi qo'shimcha ma'lumotlarni saqlashi kerak. JavaScriptda o'z xatolarimizni yaratish uchun ularni Errordan meros olib (extends) yasaymiz.

Nega Error'ni kengaytiramiz?

Faraz qilaylik, bizda readUser(json) funksiyasi bor — u JSON matnini o'qiydi. To'liq ishlashi uchun foydalanuvchida name va age maydonlari bo'lishi kerak. Agar ular bo'lmasa, bu SyntaxError emas — chunki JSON o'zi to'g'ri. Bu boshqa turdagi xato. Uni ValidationError deb ataymiz.

Bizning xato klassimiz standart xatolar kabi message, name, stack xususiyatlarini qo'llab-quvvatlashi kerak. Buning uchun eng oson yo'l — o'rnatilgan Error klassidan meros olish.

Error'dan extends qilish

Error klassini kengaytiramiz. Errorning tuzilishi taxminan shunday (soddalashtirilgan):

// JavaScript'ning ichki o'rnatilgan Error klassi (taxminan)
class Error {
  constructor(message) {
    this.message = message;
    this.name = "Error"; // o'rnatilgan xatolar uchun turli nomlar
    this.stack = /* chaqiruvlar steki */;
  }
}

Endi undan ValidationErrorni meros olamiz:

validation-error.js

// natija shu yerda chiqadi

Muhim jihatlar:

super(message)ni chaqirish shart — bu Error konstruktoriga messageni beradi va this.messageni to'g'ri o'rnatadi;
this.nameni o'zimiz belgilaymiz — chunki Error konstruktori uni "Error" qilib qo'yadi. Odatda klass nomi bilan bir xil qilinadi.

instanceof bilan tekshirish

Endi readUserni yozamiz va ValidationError tashlaymiz. Xatoni ushlaganda uning aynan qaysi tur ekanligini instanceof orqali aniqlaymiz:

instanceof.js

// natija shu yerda chiqadi

instanceof nafaqat aynan klassni, balki uning barcha ota-klasslarini ham tan oladi. Ya'ni ValidationError ham Errorning avlodi bo'lgani uchun:

instanceof-hierarchy.js

// natija shu yerda chiqadi

Xatoni tekshirishda odatda aniq (ValidationError) turdan umumiy (Error) tur tomon boradigan tartibda instanceof ishlatiladi. Aks holda umumiy tur birinchi bo'lib "ushlab olib", aniq shohobchalarga yetib bormaydi.

Xatoliklar ierarxiyasi

Ilova o'sgani sari, xatolar ham ko'payadi. Masalan, PropertyRequiredError — aynan qaysi maydon yetishmayotganini bildiradigan aniqroq xato. U ValidationErrordan meros olishi mumkin. Shunday qilib ierarxiya (daraxt) hosil bo'ladi:

Error
 └── ValidationError
      └── PropertyRequiredError

ierarxiya.js

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

// ValidationError'ni yanada aniqlashtiramiz
class PropertyRequiredError extends ValidationError {
  constructor(property) {
    super("Maydon yo'q: " + property);
    this.name = "PropertyRequiredError";
    this.property = property; // qaysi maydon — qo'shimcha ma'lumot
  }
}

function readUser(json) {
  let user = JSON.parse(json);
  if (!user.age) throw new PropertyRequiredError("age");
  if (!user.name) throw new PropertyRequiredError("name");
  return user;
}

try {
  readUser('{"age": 25}');
} catch (err) {
  if (err instanceof ValidationError) { // PropertyRequiredError HAM shu turga kiradi!
    console.log("Noto'g'ri ma'lumot: " + err.message);
    console.log("Yetishmayotgan maydon: " + err.property);
    console.log("Xato nomi: " + err.name);
  } else if (err instanceof SyntaxError) {
    console.log("JSON Sintaksis xatosi: " + err.message);
  } else {
    throw err;
  }
}

// natija shu yerda chiqadi

E'tibor bering: catchda biz instanceof ValidationError deb tekshirsak, u PropertyRequiredErrorni ham qamrab oladi — chunki u ValidationErrorning avlodi. Bu ierarxiyaning kuchi: bitta tekshiruv butun bir tarmoqni ushlaydi.

this.nameni har bir konstruktorda qo'lda yozib chiqish zerikarli. Buning o'rniga asosiy maxsus xato klassi yaratib, unda this.name = this.constructor.name deb yozish mumkin — shunda avlodlar nomni avtomatik oladi.

auto-name.js

// natija shu yerda chiqadi

Xatolarni o'rash (Wrapping exceptions)

Ierarxiya foydali, lekin muammosi bor. Faraz qilaylik, readUserni chaqiruvchi kod turli-tuman xatolar (ValidationError, SyntaxError, kelajakda yana boshqalar) haqida qayg'urishi kerak. Har safar yangi xato turi qo'shilganda, uni chaqiruvchi hamma joyda tekshiruvni yangilashimiz kerak bo'ladi. Bu noqulay.

Yechim — wrapping (o'rash) texnikasi:

Barcha "quyi darajali" xatolarni umumlashtiruvchi bitta klass yaratamiz — masalan, ReadError;
readUser ichidagi try...catch quyi darajali xatolarni (ValidationError, SyntaxError) ushlaydi;
So'ng ularni bitta umumiy ReadError ichiga "o'rab", uni tashlaydi. Asl xato esa cause (sabab) xususiyatida saqlanadi.

Endi chaqiruvchi kod faqat bitta ReadErrorni tekshirsa kifoya. Tafsilot kerak bo'lsa, err.causeni ochib ko'radi:

wrapping.js

class ReadError extends Error {
  constructor(message, cause) {
    super(message);
    this.cause = cause; // asl (o'ralgan) xato
    this.name = "ReadError";
  }
}

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

function validateUser(user) {
  if (!user.age) throw new ValidationError("'age' yo'q");
  if (!user.name) throw new ValidationError("'name' yo'q");
}

try {
    validateUser(user);
  } catch (err) {
    if (err instanceof ValidationError) {
      throw new ReadError("Validatsiya Xatosi", err); // o'raymiz
    } else {
      throw err;
    }
  }
  return user;
}

// Chaqiruvchi kod endi FAQAT ReadError'ni biladi:
try {
  readUser("{buzuq json}");
} catch (err) {
  if (err instanceof ReadError) {
    console.log("Umumiy xato: " + err.message);
    console.log("Asl (cause) xato: " + err.cause.name + " -> " + err.cause.message);
  } else {
    throw err;
  }
}

// natija shu yerda chiqadi

Endi ikkinchi holatni — validatsiya xatosini — sinab ko'ring: JSON to'g'ri, lekin maydon yo'q:

wrapping-2.js

// natija shu yerda chiqadi

Zamonaviy JavaScriptda Error konstruktori ikkinchi argument sifatida { cause } obyektini qabul qiladi: new Error("...", { cause: err }). Bu causeni saqlashning standart usuli. Yuqorida biz uni sodda ko'rinishda qo'lda o'rnatdik.

Wrapping'ning asosiy foydasi — abstraksiya darajasi. Chaqiruvchi kod pastki qavatdagi barcha xato turlarini bilishi shart emas; u faqat "o'qishda xato bo'ldi" (ReadError) degan umumiy ma'lumotni oladi, kerak bo'lganda esa cause orqali chuqurroq kirib ko'radi.

Xulosa

O'z xatolarimizni class MyError extends Error ko'rinishida yasaymiz;
Konstruktorda super(message)ni chaqirish va this.nameni belgilash shart;
Xatolarni err instanceof MyError orqali tekshiramiz — u ota-klasslarni ham qamrab oladi;
Xatolardan ierarxiya (daraxt) yasash mumkin: aniqroq xatolar umumiyroqlaridan meros oladi;
this.name = this.constructor.name nomni avtomatik olishga yordam beradi;
Wrapping: past darajali xatolarni bitta umumiy xatoga o'rab, aslini causeda saqlaymiz — bu chaqiruvchi kodni soddalashtiradi.