Selamat tinggal Pengecualian! Menguasai Pengendalian Ralat dalam JavaScript dengan Corak Hasil

Corak Hasil ialah pendekatan pengaturcaraan berfungsi yang digunakan dalam banyak bahasa pengaturcaraan seperti Rust, Go, C# (dan bahasa lain) untuk mengendalikan ralat tanpa bergantung pada blok try-catch. Ia melibatkan mewakili hasil operasi sebagai objek yang secara eksplisit menunjukkan kejayaan atau kegagalan. Corak ini amat berguna dalam pengaturcaraan tak segerak.

Apakah Corak Hasilnya?

Corak Keputusan mewakili hasil operasi menggunakan dua keadaan eksplisit:

• Kejayaan (Ok): Mengandungi nilai yang berjaya.
• Kegagalan (Err): Mengandungi ralat atau sebab kegagalan

Cara Melaksanakan Corak Hasil

mari buat objek Utiliti Hasil

const Result = {
  Ok: (value) => ({ isOk: true, value }),
  Err: (error) => ({ isOk: false, error }),
};

mari gunakan Corak Hasil ini dalam Fungsi Async

const fetchData = async (url) => {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      return Result.Err(`HTTP error: ${response.status}`);
    }
    const data = await response.json();
    return Result.Ok(data);
  } catch (err) {
    return Result.Err(err.message);
  }
};

const main = async () => {
  const result = await fetchData("https://jsonplaceholder.typicode.com/posts");
  if (result.isOk) {
    console.log("Success:", result.value);
  } else {
    console.error("Error:", result.error);
  }
};

main();

Faedah Corak Hasil

1. Kebolehbacaan yang Dipertingkat: Mengelak Blok cuba-tangkap Bersarang
Masalah dengan cuba-tangkap:
Menggunakan try-catch untuk pengendalian ralat boleh membawa kepada kod bersarang dalam apabila mengendalikan berbilang operasi. Ini menjadikan kod lebih sukar dibaca dan diselenggara.

Faedah utama Corak Hasil ialah Corak Hasil merangkum ralat sebagai sebahagian daripada nilai pulangan, menghapuskan keperluan untuk blok cuba-tangkap bersarang. Logik pengendalian ralat menjadi lebih bersih dan lebih tersusun.

Mari lihat contoh pengecualian cuba-tangkap bersarang

const process = async (data) =>{
    // YOUR LOGIC TO PROCESS THE DATA
    return result
}

const processData = async () => {
    try {
      const response = await fetch("https://jsonplaceholder.typicode.com/posts");
      const data = await response.json();
      try {
        const processedData = process(data);
        return processedData;
      } catch (processError) {
        console.error("Error processing data:", processError);
      }
    } catch (fetchError) {
      console.error("Error fetching data:", fetchError);
    }
};

Sekarang mari kita laksanakan logik pengambilan data yang sama menggunakan Corak Hasil

const process = async (data) =>{
    // YOUR LOGIC TO PROCESS THE DATA
    return result
}

const processData = async () => {
  const fetchResult = await fetchData("https://jsonplaceholder.typicode.com/posts");
  if (!fetchResult.isOk) return fetchResult;

  const processResult = process(fetchResult.value);
  return processResult;
};

2. Kejelasan: Menyampaikan Dengan Jelas Kemungkinan Kegagalan
Masalah dengan Pengendalian Ralat Tersirat:
Fungsi JavaScript boleh membuang ralat secara tersirat, menjadikannya tidak jelas jika fungsi mungkin gagal melainkan didokumenkan secara eksplisit. Ini boleh membawa kepada ralat masa jalan yang tidak dijangka.

Bagaimana Corak Hasil Membantu:
Corak Hasil secara eksplisit mengembalikan Ok atau Err, menandakan sama ada operasi berjaya atau gagal. Ini menjadikan gelagat fungsi boleh diramal dan lebih mudah untuk difikirkan.

Contoh pengendalian ralat Tersirat

const processUserInput = (input) => {
  if (!input || input.trim() === "") {
    throw new Error("Input cannot be empty");
  }
  return `Processed: ${input}`;
};

Contoh pengendalian ralat Eksplisit dengan Corak Hasil

const processUserInput = (input) => {
  if (!input || input.trim() === "") {
    return Result.Err("Input cannot be empty");
  }
  return Result.Ok(`Processed: ${input}`);
};

const userInput = "  ";
const result = processUserInput(userInput);

if (result.isOk) {
  console.log("Success:", result.value);
} else {
  console.error("Failure:", result.error);
}

3. Kebolehkomposan: Operasi Rantaian Lebih Mudah
Masalah dengan cuba-tangkap:
Apabila merantai berbilang operasi, satu pengecualian boleh mengganggu keseluruhan aliran. Mengendalikan pengecualian ini dengan cuba-tangkap menambah plat dandang yang ketara.

Bagaimana Corak Hasil Membantu:
Corak Hasil memudahkan komposisi dengan menghantar nilai Ok ke hadapan dan menghentikan pelaksanaan pada Err pertama. Ini memastikan aliran operasi yang bersih dan boleh diramal.

Contoh Corak Tanpa Hasil

const Result = {
  Ok: (value) => ({ isOk: true, value }),
  Err: (error) => ({ isOk: false, error }),
};

Contoh Dengan Corak Hasil

const fetchData = async (url) => {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      return Result.Err(`HTTP error: ${response.status}`);
    }
    const data = await response.json();
    return Result.Ok(data);
  } catch (err) {
    return Result.Err(err.message);
  }
};

const main = async () => {
  const result = await fetchData("https://jsonplaceholder.typicode.com/posts");
  if (result.isOk) {
    console.log("Success:", result.value);
  } else {
    console.error("Error:", result.error);
  }
};

main();

Kesimpulan

Corak Hasil menawarkan alternatif yang hebat dan elegan untuk cuba tangkap untuk pengendalian ralat dalam JavaScript. Dengan menyediakan kebolehbacaan yang lebih baik, pengendalian ralat yang jelas dan kebolehkomposisian, ia meningkatkan keteguhan dan kebolehramalan aliran kerja tak segerak.

Jika anda bekerja dengan logik kompleks atau berbilang operasi tak segerak, pertimbangkan untuk menggunakan Corak Hasil untuk menjadikan kod anda lebih bersih dan lebih boleh diselenggara.

Sila beri pendapat anda tentang corak ini, maaf atas sebarang kesilapan.

Atas ialah kandungan terperinci Selamat tinggal Pengecualian! Menguasai Pengendalian Ralat dalam JavaScript dengan Corak Hasil. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!