Einführung in die funktionale Programmierung in JavaScript: Applicatives #10

Applicatives bieten eine leistungsstarke und ausdrucksstarke Möglichkeit, mit Funktionen und Datenstrukturen zu arbeiten, die Kontext beinhalten, wie etwa optionale Werte, asynchrone Berechnungen oder Listen. Applikative erweitern das Konzept von Funktoren und ermöglichen die Anwendung von in einen Kontext eingeschlossenen Funktionen auf Werte, die ebenfalls in einen Kontext eingeschlossen sind.

Was ist ein Applikativ?

Ein Applikativ ist eine Art Funktor, der nicht nur die Zuordnung einer Funktion über einen umschlossenen Wert unterstützt (wie ein Funktor), sondern auch die Anwendung von Funktionen, die selbst in einen Kontext eingeschlossen sind, auf Werte ermöglicht, die in einen Kontext eingeschlossen sind. Applikative bieten eine Möglichkeit, Operationen mit mehreren Funktionswerten abzuwickeln.

Eigenschaften von Applicatives

1. Identität: Das Anwenden einer umschlossenen Identitätsfunktion auf einen umschlossenen Wert sollte den umschlossenen Wert ergeben. [ text{A.of(x).ap(A.of(f))} equiv text{A.of(f(x))} ]
2. Homomorphismus: Das Anwenden einer umschlossenen Funktion auf einen umschlossenen Wert sollte zum gleichen Ergebnis führen wie das Anwenden der Funktion auf den Wert und das anschließende Umschließen. [ text{A.of(f).ap(A.of(x))} equiv text{A.of(f(x))} ]
3. Austausch: Das Anwenden einer umschlossenen Funktion auf einen umschlossenen Wert sollte dem Anwenden des umschlossenen Werts auf eine Funktion entsprechen, die die umschlossene Funktion anwendet. [ text{A.of(f).ap(u)} äquiv. text{u.ap(A.of(f => f(x)))} ]

Applikative in JavaScript implementieren

Lassen Sie uns untersuchen, wie Sie Applikative in JavaScript implementieren und verwenden.

Beispiel: Vielleicht als Applikativ implementieren

Der Maybe-Typ wird häufig zur Darstellung optionaler Werte verwendet. Erweitern wir Maybe, um anwendungsbezogene Vorgänge zu unterstützen.

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 }

In diesem Beispiel implementiert Maybe die ap-Methode, die eine in einen Maybe-Kontext eingeschlossene Funktion auf einen in einen anderen Maybe-Kontext eingeschlossenen Wert anwendet. Dies ermöglicht die Verkettung von Vorgängen mit optionalen Werten.

Arbeiten mit Applicatives in der Praxis

Applikative sind besonders nützlich, wenn es um Berechnungen geht, die mehrere Kontexte umfassen, wie z. B. die Kombination mehrerer asynchroner Operationen oder die Verarbeitung mehrerer optionaler Werte.

Beispiel: Kombination mehrerer Versprechen

Sehen wir uns an, wie Applikative dabei helfen können, mehrere Versprechen zu kombinieren.

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)

In diesem Beispiel kombinieren wir mehrere Versprechen mithilfe des Anwendungsmusters. Während das Beispiel ein logisches Problem mit der Analyse aufweist, zeigt es, wie Applikative zum Sequenzieren von Vorgängen verwendet werden können, die Kontext beinhalten.

Beispiel: Umgang mit mehreren optionalen Werten

Applikative eignen sich auch zum Kombinieren mehrerer optionaler Werte.

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 }

In diesem Beispiel verwenden wir das Anwendungsmuster, um mehrere Maybe-Werte zu kombinieren und das Vorhandensein von Null elegant zu behandeln.

Das obige ist der detaillierte Inhalt vonEinführung in die funktionale Programmierung in JavaScript: Applicatives #10. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!