JavaScript-da Xatolarni Boshqarish

JavaScript-da xatolarni boshqarish bo'yicha keng qamrovli qo'llanma, asosiy tushunchalar va zamonaviy veb-ishlanmada qo'llaniladigan ilg'or usullarni o'z ichiga oladi.

So'nggi yangilanish: 2024-12-15

Xatolarni boshqarish JavaScript kodini yozishda juda muhim ahamiyatga ega. Bu ishlab chiquvchilarga kutilmagan vaziyatlarni boshqarish, nosozliklarni tuzatish jarayonini yaxshilash va foydalanuvchi tajribasini sezilarli darajada oshirish imkonini beradi. To'g'ri xatolarni boshqarish silliq ishlaydigan dastur bilan kutilmaganda ishdan chiqadigan, foydalanuvchilarni xafa qiladigan va ma'lumotlarni yo'qotishga olib kelishi mumkin bo'lgan dastur o'rtasidagi farqni anglatishi mumkin.

O'rnatilgan Xato Turlari

JavaScript turli xil xato holatlarini boshqarish uchun bir nechta o'rnatilgan xato turlarini taqdim etadi:

  1. Error: Barcha xatolar uchun asosiy obyekt. U umumiy va har qanday turdagi ish vaqti xatosi uchun ishlatilishi mumkin.
  2. SyntaxError: Koddagi sintaksis xatosi, masalan, yopilmagan qavs yoki noto'g'ri belgi mavjud bo'lganda yuzaga keladi.
  3. ReferenceError: E'lon qilinmagan o'zgaruvchiga yoki qamrov doirasidan tashqaridagi o'zgaruvchiga murojaat qilganda yuzaga keladi.
  4. TypeError: Qiymat kutilgan turga mos kelmasa yuzaga keladi, masalan, funksiya bo'lmagan narsani chaqirish yoki null qiymatning xususiyatiga kirish.
  5. RangeError: Qiymat ruxsat etilgan qiymatlar to'plami yoki oralig'ida bo'lmaganda, masalan, noto'g'ri uzunlikdagi massiv yaratishda yuzaga keladi.
  6. URIError: Global URI bilan ishlash funksiyalaridan noto'g'ri foydalanganda, masalan, decodeURI() ga noto'g'ri URI uzatilganda yuzaga keladi.
  7. EvalError: eval() funksiyasidan noto'g'ri foydalanganda yuzaga keladi (zamonaviy JavaScript-da kamdan-kam hollarda ishlatiladi).

Turli xil xato turlarining misoli:

try {
  // SyntaxError
  eval('Salom Dunyo');
  
  // ReferenceError
  console.log(aniqlanmaganOzgaruvchi);
  
  // TypeError
  null.f();
  
  // RangeError
  const arr = new Array(-1);
  
  // URIError
  decodeURIComponent('%');
} catch (xato) {
  console.log(xato.name); // Xato turini qayd etadi
  console.log(xato.message); // Xato xabarini qayd etadi
  console.log(xato.stack); // Stek izini qayd etadi
}

try-catch Operatori

try-catch operatori kod blokida yuzaga kelishi mumkin bo'lgan istisnolarni boshqarish uchun ishlatiladi. U sizga dasturingizni ishdan chiqarmasdan xatolarni boshqarish imkonini beradi.

Sintaksis:

try {
  // Xato yuzaga kelishi mumkin bo'lgan kod
} catch (xato) {
  // Xatoni boshqarish kodi
} finally {
  // Xato yuzaga kelgan yoki ushlanganidan qat'i nazar bajariladi
}

Kengaytirilgan misol:

function sonlarniBoʻlish(a, b) {
  try {
    if (typeof a !== 'number' || typeof b !== 'number') {
      throw new TypeError('Ikkala argument ham son bo'lishi kerak');
    }
    if (b === 0) {
      throw new Error('Nolga bo'lish mumkin emas');
    }
    const natija = a / b;
    console.log(`Natija: ${natija}`);
    return natija;
  } catch (xato) {
    if (xato instanceof TypeError) {
      console.error('Tur xatosi:', xato.message);
    } else if (xato.message === 'Nolga bo'lish mumkin emas') {
      console.error('Matematik xato:', xato.message);
    } else {
      console.error('Kutilmagan xato yuz berdi:', xato.message);
    }
    return null;
  } finally {
    console.log('Bo'lish amaliyoti yakunlandi');
  }
}

console.log(sonlarniBoʻlish(10, 2));  // Natija: 5 \n Bo'lish amaliyoti yakunlandi \n 5
console.log(sonlarniBoʻlish(10, 0));  // Matematik xato: Nolga bo'lish mumkin emas \n Bo'lish amaliyoti yakunlandi \n null
console.log(sonlarniBoʻlish('10', 2));  // Tur xatosi: Ikkala argument ham son bo'lishi kerak \n Bo'lish amaliyoti yakunlandi \n null

Maxsus Xatolarni Yaratish

Siz throw operatori yordamida maxsus xatolarni yaratishingiz mumkin. Bu sizga dasturingiz uchun yanada aniqroq xato turlarini yaratish imkonini beradi, bu esa xatolarni boshqarishni yanada aniq va ma'lumotli qiladi.

Maxsus xato sinfining misoli:

class TekshirishXatosi extends Error {
  constructor(xabar, maydon) {
    super(xabar);
    this.name = 'TekshirishXatosi';
    this.maydon = maydon;
  }
}

function foydalanuvchiniTekshirish(foydalanuvchi) {
  if (!foydalanuvchi.username) {
    throw new TekshirishXatosi('Foydalanuvchi nomi talab qilinadi', 'username');
  }
  if (!foydalanuvchi.email) {
    throw new TekshirishXatosi('Email talab qilinadi', 'email');
  }
  if (foydalanuvchi.yosh < 18) {
    throw new TekshirishXatosi('Foydalanuvchi kamida 18 yoshda bo'lishi kerak', 'yosh');
  }
}

try {
  foydalanuvchiniTekshirish({ username: 'john_doe', email: 'john@example.com', yosh: 16 });
} catch (xato) {
  if (xato instanceof TekshirishXatosi) {
    console.error(`'${xato.maydon}' maydonida tekshirish xatosi:`, xato.message);
  } else {
    console.error('Noma'lum xato:', xato);
  }
}

Async/Await Xatolarni Boshqarish

Asinxron kod bilan ishlashda, xatolarni yanada sinxron ko'rinadigan tarzda boshqarish uchun async/await bilan try-catch bloklaridan foydalanishingiz mumkin. Bu asinxron kodingizni o'qish va saqlashni osonlashtiradi.

Asinxron funksiyadagi xatolarni boshqarish misoli:

Promise Xatolarni Boshqarish

Promise-lar bilan ishlashda, xatolarni boshqarish uchun .catch() metodidan foydalanishingiz mumkin. Bu ayniqsa asinxron operatsiyalar zanjiri mavjud bo'lganda foydalidir.

Promise xatolarini boshqarish misoli:

function foydalanuvchiniOlish(id) {
  return fetch(`https://api.example.com/users/${id}`)
    .then(javob => {
      if (!javob.ok) {
        throw new Error(`HTTP xato! holat: ${javob.status}`);
      }
      return javob.json();
    });
}

function foydalanuvchiPostlariniOlish(foydalanuvchiId) {
  return fetch(`https://api.example.com/users/${foydalanuvchiId}/posts`)
    .then(javob => {
      if (!javob.ok) {
        throw new Error(`HTTP xato! holat: ${javob.status}`);
      }
      return javob.json();
    });
}

foydalanuvchiniOlish(1)
  .then(foydalanuvchi => {
    console.log('Foydalanuvchi:', foydalanuvchi);
    return foydalanuvchiPostlariniOlish(foydalanuvchi.id);
  })
  .then(postlar => {
    console.log('Foydalanuvchi postlari:', postlar);
  })
  .catch(xato => {
    console.error('Olish zanjirida xato:', xato);
  });

Xatolarni Boshqarishning Eng Yaxshi Amaliyotlari

  1. Aniq bo'ling: Iloji boricha aniq xato turlarini ushlang va chiqaring. Bu yanada aniq xatolarni boshqarish imkonini beradi.
  2. Kontekst bering: Xato xabarlariga tegishli ma'lumotlarni qo'shing. Bu nosozliklarni tuzatishni osonlashtiradi va foydalanuvchilar yoki jurnallash tizimlariga ko'proq foydali ma'lumot beradi.
  3. Bo'sh catch bloklaridan qoching: Har doim ushlangan xatolarni boshqaring yoki qayta chiqaring. Bo'sh catch bloklari muammolarni yashirishi va nosozliklarni tuzatishni qiyinlashtirishi mumkin.
  4. Tozalash uchun finally dan foydalaning: Xato yuz bergan yoki bermagan bo'lsa ham, resurslar to'g'ri ozod qilinishini ta'minlang.
  5. Xatolarni jurnallang: Nosozliklarni tuzatish va kuzatish uchun xatolarni kuzatib boring. Ishlab chiqarish muhitlarida jurnallash xizmatidan foydalanishni o'ylab ko'ring.
  6. Tez muvaffaqiyatsizlik: Noto'g'ri shartlar aniqlangan zahoti xatolarni chiqaring. Bu muammolarni bajarish jarayonining ertaroq bosqichida aniqlashga yordam beradi.
  7. Yumshoq degradatsiya: Iloji boricha zaxira xatti-harakatlarini ta'minlang. Bu muhim bo'lmagan xatolar yuz berganda foydalanuvchi tajribasini yaxshilashi mumkin.
  8. Maxfiy ma'lumotlarni oshkor qilmang: Foydalanuvchilarga ko'rsatilishi mumkin bo'lgan xato xabarlariga maxfiy ma'lumotlarni kiritmaslikka e'tibor bering.

Tez-tez So'raladigan Savollar

  1. S: try-catch bloklarini qachon ishlatishim kerak? J: try-catch ni xato chiqarishi mumkin bo'lgan kod bilan ishlayotganingizda va uni yumshoq boshqarmoqchi bo'lganingizda ishlating. Bu ayniqsa I/O operatsiyalari, tahlil qilish operatsiyalari va muvaffaqiyatsiz bo'lishi mumkin bo'lgan funksiyalarni chaqirish uchun foydalidir.
  2. S: Xatolarni boshqarishda throw va return o'rtasidagi farq nima? J: throw xato yoki favqulodda holatni bildirish uchun ishlatiladi va joriy funksiya bajarilishini darhol to'xtatadi. return esa shunchaki qiymatni chaqiruvchiga qaytaradi va normal bajarilishni davom ettiradi.
  3. S: Asinxron koddagi xatolarni qanday boshqaraman? J: Promise-lar uchun .catch() metodidan foydalaning. async/await bilan try-catch bloklaridan foydalanishingiz mumkin. Callback-lar uchun xato parametrlarini tekshiring.
  4. S: Har doim maxsus xato sinflarini yaratishim kerakmi? J: Maxsus xato sinflari dasturingizdagi turli xil xato turlarini farqlash kerak bo'lganda foydalidir. Oddiy skriptlar uchun yoki o'rnatilgan xato turlari yetarli bo'lganda, maxsus sinflar zarur bo'lmasligi mumkin.
  5. S: Kodimdagi xatolarni boshqarishni qanday sinab ko'rishim mumkin? J: Siz ataylab xatolar keltirib chiqaradigan va ular to'g'ri boshqarilayotganini tekshiradigan birlik testlarini yozishingiz mumkin. Jest kabi vositalar xato stsenariylarini sinab ko'rish uchun expect(() => {}).toThrow() kabi metodlarni taqdim etadi.

Qo'shimcha Manbalar

  1. MDN Web Docs: Error
  2. JavaScript.info: Xatolarni boshqarish, "try...catch"
  3. Node.js Hujjatlari: Xatolar
  4. MDN-da JavaScript Xatolari Havolasi