Pengenalan kepada Pengaturcaraan Fungsian dalam JavaScript: Lakukan monads #12

Dalam pengaturcaraan berfungsi, monad menyediakan cara untuk mengendalikan pengiraan secara berstruktur dan boleh diramal. Di antara pelbagai monad, Do Monad (juga dikenali sebagai "notasi Do" atau "Monad comprehension") ialah binaan berkuasa yang membolehkan pengendalian operasi monad yang lebih mudah dibaca dan gaya imperatif.

Apa itu Do Monad?

Do Monad ialah gula sintaktik yang memudahkan kerja dengan monad dengan membenarkan anda menulis urutan operasi monad dalam gaya yang menyerupai pengaturcaraan imperatif. Daripada merantai operasi dengan .then atau .flatMap, Do Monad membolehkan anda menulis kod yang lebih mudah dan boleh dibaca.

Faedah Do Monad

1. Kebolehbacaan: Ia membolehkan untuk menulis operasi monadik yang kompleks dalam cara yang bersih dan linear.
2. Gaya Imperatif: Menyediakan cara untuk menyatakan pengiraan monadik dalam gaya yang biasa digunakan untuk pengaturcaraan imperatif.
3. Pengendalian Ralat: Memudahkan pengendalian ralat dalam operasi monadik dengan menyediakan struktur yang jelas dan konsisten.

Melaksanakan Do Monad dalam JavaScript

Walaupun JavaScript tidak mempunyai sokongan terbina dalam untuk Do Monad seperti Haskell, kami boleh melaksanakan binaan serupa menggunakan fungsi penjana dan pelari tersuai.

Contoh: Melaksanakan Do Monad Runner

Mari kita mulakan dengan melaksanakan pelari Do Monad yang boleh mengendalikan Promise monads.

function* doGenerator() {
  const a = yield Promise.resolve(1);
  const b = yield Promise.resolve(2);
  const c = yield Promise.resolve(a + b);
  return c;
}

function runDo(genFunc) {
  const iter = genFunc();

  function handle(result) {
    if (result.done) return Promise.resolve(result.value);
    return Promise.resolve(result.value).then(res => handle(iter.next(res)));
  }

  return handle(iter.next());
}

// Usage
runDo(doGenerator).then(result => console.log(result)); // 3

Dalam contoh ini, doGenerator ialah fungsi penjana yang menghasilkan janji. Fungsi runDo melaksanakan penjana, mengendalikan setiap janji yang terhasil dan menghantar nilai yang diselesaikan kembali ke penjana.

Aplikasi Praktikal Do Monad

Do Monad boleh digunakan dalam pelbagai senario di mana operasi monadik perlu disusun mengikut cara yang boleh dibaca dan diselenggara.

Contoh: Mengendalikan Operasi Asynchronous

Mari tingkatkan contoh sebelumnya untuk mengendalikan operasi tak segerak yang lebih kompleks.

function* fetchUserData() {
  const user = yield fetch('https://api.example.com/user/1').then(res => res.json());
  const posts = yield fetch(`https://api.example.com/user/${user.id}/posts`).then(res => res.json());
  const firstPost = posts[0];
  const comments = yield fetch(`https://api.example.com/posts/${firstPost.id}/comments`).then(res => res.json());
  return { user, firstPost, comments };
}

runDo(fetchUserData).then(result => console.log(result));

Dalam contoh ini, fetchUserData ialah fungsi penjana yang menghasilkan janji untuk mengambil data pengguna, siaran mereka dan ulasan pada siaran pertama. Fungsi runDo melaksanakan operasi tak segerak ini dengan cara yang boleh dibaca dan berstruktur.

Contoh: Mengendalikan Nilai Pilihan dengan Mungkin Monad

Kita juga boleh menggunakan corak Do Monad dengan monad lain seperti Maybe.

class Maybe {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Maybe(value);
  }

  map(fn) {
    return this.value === null || this.value === undefined ? Maybe.of(null) : Maybe.of(fn(this.value));
  }

  flatMap(fn) {
    return this.value === null || this.value === undefined ? Maybe.of(null) : fn(this.value);
  }
}

function* maybeDoGenerator() {
  const a = yield Maybe.of(1);
  const b = yield Maybe.of(2);
  const c = yield Maybe.of(a + b);
  return c;
}

function runMaybeDo(genFunc) {
  const iter = genFunc();

  function handle(result) {
    if (result.done) return Maybe.of(result.value);
    return result.value.flatMap(res => handle(iter.next(res)));
  }

  return handle(iter.next());
}

// Usage
const result = runMaybeDo(maybeDoGenerator);
console.log(result); // Maybe { value: 3 }

Dalam contoh ini, maybeDoGenerator ialah fungsi penjana yang berfungsi dengan monad Maybe. Fungsi runMaybeDo melaksanakan penjana, mengendalikan setiap nilai Mungkin yang terhasil dan menghantar semula nilai yang tidak dibalut ke penjana.

Do Monad ialah binaan berkuasa yang memudahkan kerja dengan monad dengan membenarkan anda menulis urutan operasi monad dalam gaya yang lebih mudah dibaca dan penting. Dengan melaksanakan pelari Do Monad, anda boleh mengendalikan operasi tak segerak yang kompleks, nilai pilihan dan pengiraan monadik lain dengan cara yang berstruktur dan boleh diselenggara.

Walaupun JavaScript tidak menyokong sintaks Do Monad secara asli, menggunakan fungsi penjana dan pelari tersuai, anda boleh mencapai fungsi yang serupa. Pendekatan ini meningkatkan kebolehbacaan dan kebolehselenggaraan kod anda, menjadikannya lebih mudah untuk bekerja dengan operasi monadik dalam gaya pengaturcaraan berfungsi.

Atas ialah kandungan terperinci Pengenalan kepada Pengaturcaraan Fungsian dalam JavaScript: Lakukan monads #12. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!