Cara menulis aplikasi Node.js dan mengendalikan toleransi kesalahan

Node.js ialah bahasa pengaturcaraan sebelah pelayan yang popular yang digunakan secara meluas untuk membina pelbagai jenis aplikasi rangkaian. Apabila membina aplikasi web menjadi semakin mencabar, aplikasi Node.js yang boleh mengendalikan toleransi kesalahan menjadi semakin popular. Dalam artikel ini, kita akan mempelajari secara mendalam cara menulis aplikasi Node.js dan mengendalikan toleransi kesalahan.

1. Ralat pengendalian

Tidak kira betapa teguhnya program, ralat tidak dapat dielakkan. Jika anda tidak mengendalikan ralat dengan betul, program anda boleh menyebabkan beberapa masalah, seperti ranap program, tingkah laku tidak mesra kepada pengguna, dsb. Beberapa cara untuk mengendalikan ralat adalah seperti berikut:

1 Gunakan pernyataan cuba...tangkap

Pernyataan cuba...tangkap ialah cara standard untuk mengendalikan ralat. Kod yang boleh menyebabkan ralat dilaksanakan dalam blok kod cuba Jika ralat berlaku, ia akan ditangkap dan diproses oleh blok kod tangkapan. Berikut ialah contoh pengendalian ralat membaca fail:

try {
  let file = fs.readFileSync('non-existent-file.txt', 'utf8');
} catch (err) {
  console.error('Error:', err);
}

2. Menggunakan fungsi panggil balik

Dalam Node.js, adalah perkara biasa untuk mendayakan fungsi panggil balik. Dalam fungsi panggil balik, biasanya parameter pertama ialah objek ralat Jika tiada ralat berlaku, parameter pertama akan menjadi batal. Berikut ialah contoh menggunakan fungsi panggil balik untuk mengendalikan ralat semasa membaca fail:

fs.readFile('non-existent-file.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error:', err);
  } else {
    console.log(data);
  }
});

3. Gunakan Promise

Gunakan Promise untuk mengendalikan ralat dalam operasi tak segerak. Gunakan kaedah Promise.then() untuk menyemak ralat. Berikut ialah contoh penggunaan Promise:

const readFileAsync = function (filename, encoding) {
  return new Promise(function (resolve, reject) {
    fs.readFile(filename, encoding, function (err, result) {
      if (err) {
        reject(err);
      } else {
        resolve(result);
      }
    });
  });
};

readFileAsync('non-existent-file.txt', 'utf8')
  .then(data => console.log(data))
  .catch(err => console.error('Error:', err));

2 Modul pengendalian pengecualian

Node.js menyediakan proses pengendalian modul pengecualian global.on('uncaughtException', …), Digunakan. untuk menangkap pengecualian yang tidak dikendalikan. Modul ini membolehkan pembangun melakukan tindakan tertentu apabila ralat berlaku dalam atur cara. Berikut ialah contoh mudah:

process.on('uncaughtException', function (err) {
  console.error('Error:', err);
});

Walau bagaimanapun, menggunakan modul ini tidak seharusnya menjadi cara utama untuk menangani ralat. Jika kod anda mengandungi banyak pengecualian yang tidak dikendalikan, ia akan menjadi lebih sukar untuk mengendalikan ralat dalam program anda. Pastikan anda menggunakan modul ini dengan berhati-hati.

3. Ralat mengelog

Apabila mengendalikan ralat, adalah tidak digalakkan untuk merekodkan senarai log ralat ke dalam ingatan. Oleh itu, pendekatan yang lebih baik adalah untuk log ralat ke fail. Berikut ialah contoh menggunakan perisian tengah pengendali ralat untuk mencatat ralat Node.js:

const express = require('express');
const errorHandler = require('errorhandler');
const app = express();

app.use(errorHandler({
  log: true
}));

perisian tengah pengendali ralat membenarkan pengelogan ralat ke konsol dan fail.

4. Mekanisme cuba semula

Sekiranya operasi tidak berjaya, maka biasanya kita membuang ralat. Walau bagaimanapun, dalam beberapa kes, seperti masalah rangkaian, mungkin perlu mencuba semula operasi. Dalam kes ini, mekanisme cuba semula sangat penting.

Berikut ialah fungsi JavaScript yang boleh digunakan untuk mengendalikan ralat dan mencuba semula beberapa kali:

const retry = require('retry');
const fs = require('fs');

const readfileWithRetry = (filename) => {
  const operation = retry.operation();

  return new Promise((resolve, reject) => {
    operation.attempt(currentAttempt => {
      fs.readFile(filename, 'utf-8', (err, fileData) => {
        if (!err) {
          resolve(fileData);
        } else if (operation.retry(err)) {
          console.error('Error:', err);
          console.error('retrying');
        } else {
          reject(operation.mainError());
        }
      });
    });
  });
};

5. Kesimpulan

Dalam artikel ini, kami mempelajari cara Mengendalikan ralat dan toleransi kesalahan dalam Node.js. Walaupun kualiti adalah penting apabila ia datang untuk menulis kod yang seteguh mungkin, ia juga sangat penting apabila ia berkaitan dengan pengendalian ralat. Mengendalikan ralat adalah penting untuk meningkatkan prestasi dan kebolehpercayaan aplikasi.

Atas ialah kandungan terperinci Cara menulis aplikasi Node.js dan mengendalikan toleransi kesalahan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!