Satu pandangan tentang Pengendalian Ralat Gaya Go dalam JavaScript

Hampir semua orang yang menggunakan JavaScript setiap hari tahu bahawa cuba-tangkap boleh menyakitkan untuk ditangani, terutamanya apabila anda mempunyai lebih daripada satu ralat untuk dikendalikan.

Kebanyakan penyelesaian yang dicadangkan cuba menyalin pendekatan Golang - yang mengendalikan segala-galanya sebagai nilai pulangan. Ia, antara lain, ialah ciri hebat Go, tetapi JS adalah bahasa yang sama sekali berbeza (duh) dan saya fikir kita boleh melakukan lebih baik daripada salin-tampal daripada Go.

Dalam Go, apabila kami ingin mengendalikan ralat, kami mengembalikannya daripada panggilan fungsi sama ada sebagai nilai kedua dalam tuple atau sebagai nilai pulangan bagi panggilan fungsi. Berikut ialah coraknya:

result, error := DoSomething()
if error != nil {
 // handle error
}

Pendekatan ini membolehkan untuk mengendalikan ralat secara eksplisit menggunakan aliran kawalan standard.

Untuk menggunakan corak ini dalam javascript, penyelesaian yang paling biasa ialah mengembalikan hasil sebagai tatasusunan:

const handler = async (promise) => {
  try {
    const result = await promise()
    return [result, null];
  } catch(error) {
    return [null, error];
  }
}

const [response, error] = await handle(fetch('http://go.gl'))
if (error !== null) {
  // handle error
}

Seperti yang anda lihat, ini hampir salin-tampal terus corak daripada Go.

Mengembalikan nilai konsisten

Corak ini berfungsi dengan baik, tetapi dalam javascript kita boleh melakukan lebih baik daripada ini. Idea teras corak ini adalah untuk mengembalikan ralat sebagai nilai, jadi mari kita sesuaikan dengan SoC yang lebih baik.

Daripada mengembalikan null atau Ralat, kami boleh menghiasi hasilnya dengan antara muka yang konsisten. Itu akan meningkatkan SoC kami dan memberi kami nilai pulangan yang ditaip kuat:

interface Status {
  Ok(): boolean;
  Fail(): boolean;
  Of(cls: any): boolean;
}

Status antara muka tidak semestinya Ralat, tetapi kami boleh menyemak jenisnya menggunakan status.Of(Error). Kami sentiasa boleh mengembalikan objek yang memenuhi Status. Contoh penggunaan ialah:

const [response, error] = await handle(res.json())
if (error.Of(SyntaxError)) {
  // handle error
  console.log("not a json")
  return
}

Sekarang, dalam JavaScript hasil kami tidak semestinya satu tuple. Kita sebenarnya boleh mencipta kelas kita sendiri yang berkelakuan sebagai tuple apabila ia diperlukan:

interface IResult<T> {
  0: T;
  1: Status;
  value: T;
  status: Status;
  Of(cls: any): boolean;
  Ok(): boolean;
  Fail(): boolean;
}

Contoh penggunaan:

const result = await handle(res.value.json())
if (result.Of(SyntaxError)) {
  // handle error
  console.log("not a json")
  return
}

Perlaksanaan

Berikutan pendekatan ini, saya telah mencipta fungsi sedia untuk digunakan - Grip.

Grip ditaip dengan kuat dan boleh menghiasi fungsi dan janji yang sama.

Saya menggunakan git untuk mengehoskan pakej sedemikian, jadi untuk memasang gunakan github:

bun add github:nesterow/grip # or pnpm

penggunaan:

Fungsi cengkaman menerima fungsi atau janji dan mengembalikan hasil dengan nilai dan status pulangan.
Hasilnya boleh dibuat sama ada sebagai objek atau tupel.

import { grip } from '@nesterow/grip';

Mengendalikan hasil sebagai objek:

Hasilnya boleh dikendalikan sebagai objek: {value, status, Ok(), Fail(), Of(type)}

const res = await grip(
  fetch('https://api.example.com')
);

if (res.Fail()) {
    handleErrorProperly();
    return;
}

const json = await grip(
  res.value.json()
);

if (json.Of(SyntaxError)) {
    handleJsonParseError();
    return;
}

Mengendalikan hasil sebagai tupel:

Hasilnya juga boleh diterima sebagai tupel jika anda ingin menangani ralat dalam gaya Go'ish:

const [res, fetchStatus] = await grip(
  fetch('https://api.example.com')
);
if (fetchStatus.Fail()) {
    handleErrorProperly();
    return;
}

const [json, parseStatus] = await grip(
  res.json()
);
if (parseStatus.Of(SyntaxError)) {
    handleJsonParseError();
    return;
}

Jika anda suka perkara ini, lakukan pengendalian ralat, lihat repositori. Sumbernya adalah kira-kira 50LOC, tanpa jenis dan 100 dengan jenis.

Atas ialah kandungan terperinci Satu pandangan tentang Pengendalian Ralat Gaya Go dalam JavaScript. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!