Pengenalan kepada Pengaturcaraan Fungsian dalam JavaScript: Aplikatif #10

Aplikasi menyediakan cara yang berkesan dan ekspresif untuk berfungsi dengan fungsi dan struktur data yang melibatkan konteks, seperti nilai pilihan, pengiraan tak segerak atau senarai. Aplikatif memanjangkan konsep functors, membolehkan aplikasi fungsi yang dibalut dalam konteks kepada nilai yang juga dibalut dalam konteks.

Apa itu Aplikatif?

Aplikatif ialah sejenis functor yang bukan sahaja menyokong pemetaan fungsi ke atas nilai yang dibalut (seperti functor) tetapi juga membenarkan untuk menggunakan fungsi yang dibalut dengan sendirinya dalam konteks kepada nilai yang dibalut dalam konteks. Aplikatif menyediakan cara untuk mengendalikan operasi yang melibatkan berbilang nilai fungsi.

Sifat Aplikatif

1. Identiti: Menggunakan fungsi identiti yang dibalut pada nilai yang dibalut harus menghasilkan nilai yang dibalut. [ teks{A.of(x).ap(A.of(f))} equiv text{A.of(f(x))} ]
2. Homomorphism: Menggunakan fungsi yang dibalut pada nilai yang dibalut harus menghasilkan hasil yang sama seperti menggunakan fungsi itu pada nilai dan kemudian membalutnya. [ teks{A.of(f).ap(A.of(x))} equiv text{A.of(f(x))} ]
3. Pertukaran: Menggunakan fungsi yang dibalut pada nilai yang dibalut hendaklah sama dengan menggunakan nilai yang dibalut pada fungsi yang menggunakan fungsi yang dibalut. [ teks{A.of(f).ap(u)} equiv text{u.ap(A.of(f => f(x)))} ]

Melaksanakan Aplikatif dalam JavaScript

Mari kita terokai cara melaksanakan dan menggunakan aplikatif dalam JavaScript.

Contoh: Melaksanakan Mungkin sebagai Aplikatif

Jenis Maybe sering digunakan untuk mewakili nilai pilihan. Mari lanjutkan Mungkin untuk menyokong operasi aplikatif.

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));
  }

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

// Usage
const add = (a) => (b) => a + b;

const maybeAdd = Maybe.of(add);
const maybeTwo = Maybe.of(2);
const maybeThree = Maybe.of(3);

const result = maybeAdd.ap(maybeTwo).ap(maybeThree);
console.log(result); // Maybe { value: 5 }

Dalam contoh ini, Maybe melaksanakan kaedah ap, yang menggunakan fungsi yang dibalut dalam konteks Maybe kepada nilai yang dibalut dalam konteks Maybe yang lain. Ini membolehkan operasi rantaian yang melibatkan nilai pilihan.

Bekerja dengan Aplikatif dalam Amalan

Aplikasi amat berguna apabila berurusan dengan pengiraan yang melibatkan berbilang konteks, seperti menggabungkan berbilang operasi tak segerak atau mengendalikan berbilang nilai pilihan.

Contoh: Menggabungkan Pelbagai Janji

Mari kita lihat cara aplikatif boleh membantu dalam menggabungkan pelbagai janji.

const fetchData = (url) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(`Data from ${url}`);
    }, 1000);
  });
};

const add = (a) => (b) => a + b;

const promiseAdd = Promise.resolve(add);
const promiseTwo = fetchData('url1').then((data) => parseInt(data.split(' ')[2]));
const promiseThree = fetchData('url2').then((data) => parseInt(data.split(' ')[2]));

const result = promiseAdd
  .then((fn) => promiseTwo.then((a) => fn(a)))
  .then((fn) => promiseThree.then((b) => fn(b)));

result.then(console.log); // Output after 2 seconds: NaN (since "from" cannot be parsed as an int)

Dalam contoh ini, kami menggabungkan berbilang janji menggunakan corak aplikatif. Walaupun contoh mempunyai isu logik dengan penghuraian, ia menunjukkan cara aplikatif boleh digunakan untuk menyusun operasi yang melibatkan konteks.

Contoh: Mengendalikan Pelbagai Nilai Pilihan

Aplikasi juga berguna untuk menggabungkan berbilang nilai pilihan.

const add = (a) => (b) => a + b;

const maybeAdd = Maybe.of(add);
const maybeFive = Maybe.of(5);
const maybeNull = Maybe.of(null);

const result1 = maybeAdd.ap(maybeFive).ap(maybeFive); // Maybe { value: 10 }
const result2 = maybeAdd.ap(maybeFive).ap(maybeNull); // Maybe { value: null }

console.log(result1); // Maybe { value: 10 }
console.log(result2); // Maybe { value: null }

Dalam contoh ini, kami menggunakan corak aplikatif untuk menggabungkan berbilang nilai Mungkin, mengendalikan kehadiran null dengan anggun.

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