Eine Einführung in ein vernünftiges pures funktionelles Programmieren

Key Takeaways

• reine Funktionen sind für die funktionelle Programmierung von wesentlicher Bedeutung, da sie denselben Ausgang für denselben Eingang zurückgeben, ohne Nebenwirkungen zu verursachen und die Vorhersehbarkeit und Testbarkeit zu verbessern.
• Die funktionale Programmierung reduziert die Programmkomplexität, indem Prozesse in einfachere, unveränderliche Funktionen zerlegt werden, was zur Minimierung von Fehler und zur Verbesserung der Code -Lesbarkeit hilft.
• Überabstraktion in der funktionalen Programmierung, während die Codekomplexität reduziert wird, kann zu Code führen, der schwer zu verstehen und aufrechtzuerhalten ist und die Bedeutung des Gleichgewichts hervorhebt.
• Essentielle JavaScript -Funktionen wie "MAP", "record", "filter" und "compose" sind entscheidend für die Einführung funktionaler Programmierparadigmen und die Erstellung von präziseren und deklarativen Code.
• Tests wird mit reinen Funktionen einfacher, da ihre isolierte Natur eine leichtere Einrichtung von Testbedingungen und erwarteten Ergebnissen ermöglicht.
• Die funktionale Programmierung ist nicht nur ein theoretisches Konzept, sondern ist in praktischen Szenarien wie dem Umgang mit asynchronen Operationen und UI

Dieser Artikel wurde Peer von Panayiotis «Pvgr» Velisarakos, Jezen Thomas und Florian Rappl überprüft. Vielen Dank an alle Peer -Rezensenten von SitePoint, die SitePoint -Inhalte so gut wie möglich gemacht haben! Wenn Sie das Programmieren lernen, werden Sie zunächst in die prozedurale Programmierung eingeführt. Hier steuern Sie eine Maschine, indem Sie eine aufeinanderfolgende Liste von Befehlen füttern. Nachdem Sie ein paar Sprachfundamentaldaten wie Variablen, Aufgaben, Funktionen und Objekte verstehen, können Sie ein Programm zusammenschieben, das das erreicht, was Sie dafür vorgehen - und Sie fühlen sich wie ein absoluter Assistent.

Der Prozess, ein

besseres Programmierer zu werden . Wenn Sie ein besserer Programmierer werden, schreiben Sie kleinere Funktionen, erzielen Sie eine bessere Wiederverwendung Ihres Codes, schreiben Sie Tests für Ihren Code und Sie gewinnen Vertrauen, dass die von Ihnen geschriebenen Programme weiterhin tun, was Sie beabsichtigen. Niemand mag es, Fehler im Code zu finden und zu beheben. Daher geht es auch darum, ein besserer Programmierer zu werden, um bestimmte Dinge zu vermeiden, die fehleranfällig sind. Das Lernen, was zu vermeiden ist, kommt durch Erfahrungen oder beachten Sie den Rat der erfahreneren, wie Douglas Crockford berühmt in JavaScript: Die guten Teile.

funktionale Programmierung gibt uns Möglichkeiten, die Komplexität unserer Programme zu senken, indem wir sie in ihre einfachsten Formen reduzieren: Funktionen, die sich wie reine mathematische Funktionen verhalten. Das Erlernen der Prinzipien der funktionalen Programmierung ist eine großartige Ergänzung Ihrer Fähigkeiten und hilft Ihnen, einfachere Programme mit weniger Fehler zu schreiben.

Die Schlüsselkonzepte der funktionalen Programmierung sind reine Funktionen, unveränderliche Werte, Zusammensetzung und Zähmung Nebenwirkungen.

reine Funktionen

Eine reine Funktion ist eine Funktion, die bei derselben Eingabe immer den gleichen Ausgang zurückgibt und keinen beobachtbaren Nebeneffekt hat.

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

Diese Funktion ist rein . Es hängt nicht von einem Zustand außerhalb der Funktion ab oder ändert sich nicht und wird immer den gleichen Ausgabwert für dieselbe Eingabe zurückgeben.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Diese Funktion ist

unrein , da sie sich außerhalb der Funktion auf externem Veränderungszustand stützt.

Wenn wir diese Variable innerhalb der Funktion bewegen, wird sie rein und wir können sicher sein, dass unsere Funktion unser Alter jedes Mal

. richtig überprüft.

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

reine Funktionen haben keine

Nebenwirkungen . Hier sind einige wichtige, die Sie beachten sollten:

Zugriff auf den Systemzustand außerhalb der Funktion
mutierende Objekte als Argumente
• bestanden
einen HTTP -Anruf
• machen
Benutzereingabe erhalten
Abfragen des Dom

kontrollierte Mutation

Sie müssen sich der Mutatormethoden für Arrays und Objekte bewusst sein, die die Unterblindobjekte ändern. Ein Beispiel hierfür ist der Unterschied zwischen Arrays Splice- und Slice -Methoden.

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

Wenn wir vermeiden, Methoden an Objekten zu mutieren, die an unsere Funktionen übergeben sind, wird unser Programm einfacher zu argumentieren, wir können vernünftigerweise erwarten, dass unsere Funktionen die Dinge unter uns nicht ausschalten.

<span>let items = ['a','b','c'];
</span><span>let newItems = pure(items);
</span><span>// I expect items to be ['a','b','c']
</span>

Vorteile reiner Funktionen

reine Funktionen haben einige Vorteile gegenüber ihren unreinen Gegenstücken:

leichter testbar, da ihre alleinige Verantwortung darin besteht, Eingaben zuzuordnen -> Ausgabe
Ergebnisse sind zwischengespeichert, da der gleiche Eingang immer den gleichen Ausgang ergibt
Selbstdokumentation als Abhängigkeiten der Funktion sind explizit
einfacher zu arbeiten, da Sie sich keine Sorgen um Nebenwirkungen
• machen müssen

Da die Ergebnisse reiner Funktionen zwischengespeichert werden können, können wir sie aus Memoisieren, sodass teure Vorgänge nur dann ausgeführt werden, wenn die Funktionen zum ersten Mal aufgerufen werden. Beispielsweise würde die Memoierung der Ergebnisse der Suche nach einem großen Index zu großen Leistungsverbesserungen bei Wiederaufträgen führen.

unangemessen reine funktionelle Programmierung

Die Reduzierung unserer Programme auf reine Funktionen kann die Komplexität unserer Programme drastisch verringern. Unsere Funktionsprogramme können jedoch auch die Unterstützung von Rain Man erfordern, um zu verstehen, ob wir die funktionale Abstraktion zu weit drücken.

<span>import _ from 'ramda';
</span><span>import $ from 'jquery';
</span>
<span>var Impure = {
</span>  <span>getJSON: _.curry(function(callback<span>, url</span>) {
</span>    $<span>.getJSON(url, callback);
</span>  <span>}),
</span>
  <span>setHtml: _.curry(function(sel<span>, html</span>) {
</span>    <span>$(sel).html(html);
</span>  <span>})
</span><span>};
</span>
<span>var img = function (url) {
</span>  <span>return $('<img />', { src: url });
</span><span>};
</span>
<span>var url = function (t) {
</span>  <span>return 'http://api.flickr.com/services/feeds/photos_public.gne?tags=' +
</span>    t <span>+ '&format=json&jsoncallback=?';
</span><span>};
</span>
<span>var mediaUrl = _.compose(_.prop('m'), _.prop('media'));
</span><span>var mediaToImg = _.compose(img, mediaUrl);
</span><span>var images = _.compose(_.map(mediaToImg), _.prop('items'));
</span><span>var renderImages = _.compose(Impure.setHtml("body"), images);
</span><span>var app = _.compose(Impure.getJSON(renderImages), url);
</span><span>app("cats");
</span>

Nehmen Sie sich eine Minute Zeit, um den obigen Code zu verdauen.

Sofern Sie diese Abstraktionen (Curry, übermäßiges Gebrauch von Compose und Prop) nicht in der funktionalen Programmierung haben, sind sehr schwer zu befolgen, ebenso wie der Ausführungfluss. Der folgende Code ist leichter zu verstehen und zu ändern. Er beschreibt das Programm auch viel deutlicher als der rein funktionale Ansatz oben und es ist weniger Code.

• Die App -Funktion nimmt eine Zeichenfolge von Tags
• holt JSON von Flickr
ab
zieht die URLs die Antwort
• heraus
erstellt ein Array von Knoten
Fügt sie in das Dokument

ein

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

oder diese alternative API unter Verwendung von Abstraktionen wie Fetch und Versprechen hilft uns, die Bedeutung unserer asynchronen Handlungen noch weiter zu klären.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Hinweis: Abrufen und Versprechen sind bevorstehende Standards, damit sie heute Polyfills verwenden müssen.

Die AJAX -Anfrage und die DOM -Operationen werden niemals rein sein, aber wir könnten eine reine Funktion aus dem Rest machen und die Antwort JSON auf eine Reihe von Bildern zuordnen - lasst uns die Abhängigkeit von JQuery vorerst entschuldigen.

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

Unsere Funktion macht jetzt nur zwei Dinge:

Zuordnung von Antwortdaten -> URLS
URLs zuordnen -> Bilder

Die „funktionale“ Methode, um dies zu tun, besteht darin, separate Funktionen für diese beiden Aufgaben zu erstellen, und wir können komponieren, um die Antwort einer Funktion in die andere zu übergeben.

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

Compose gibt eine Funktion zurück, die die Zusammensetzung einer Liste von Funktionen darstellt, wobei jeder den Rückgabewert der folgenden Funktion verbraucht.

Hier ist das, was Kompose tut und die Reaktion von URLs in unsere Bilderfunktion übergeben.

<span>let items = ['a','b','c'];
</span><span>let newItems = pure(items);
</span><span>// I expect items to be ['a','b','c']
</span>

Es hilft, die Argumente zu lesen, die von rechts nach links komponiert werden sollen, um die Richtung des Datenflusss zu verstehen.

Wenn wir unser Programm auf reine Funktionen reduzieren, gibt es uns eine größere Fähigkeit, sie in Zukunft wiederzuverwenden, sie sind viel einfacher zu testen und sie sind selbstdokumentiert. Der Nachteil ist, dass diese funktionellen Abstraktionen bei übermäßigem Gebrauch (wie im ersten Beispiel) die Dinge komplexer machen können, was wir sicher nicht so wollen, was wir wollen. Die wichtigste Frage, die Sie beim Refactoring -Code stellen sollten, ist jedoch:

Ist der Code leichter zu lesen und zu verstehen?

Essentielle Funktionen

Jetzt versuche ich überhaupt nicht, funktionale Programmierung anzugreifen. Jeder Entwickler sollte sich konzertierte Anstrengungen unternehmen, um die grundlegenden Funktionen zu lernen, mit denen Sie gemeinsame Muster bei der Programmierung in viel prägnanteren deklarativen Code abstrahieren können, oder wie Marijn Haverbeke es ausdrückt.

Ein Programmierer, der mit einem Repertoire an grundlegenden Funktionen und vor allem das Wissen über die Verwendung von ihnen ausgestattet ist, ist viel effektiver als einer, der von vorne anfängt. - eloquent JavaScript, Marijn Haverbeke

Hier finden Sie eine Liste der wesentlichen Funktionen, die jeder JavaScript -Entwickler lernen und beherrschen sollte. Es ist auch eine großartige Möglichkeit, Ihre JavaScript -Fähigkeiten aufzuräumen, um jede dieser Funktionen von Grund auf neu zu schreiben.

Arrays

• foreach
• map
• filter
• reduzieren

Funktionen

• dabounce
• komponieren
• partiell
• Curry

weniger ist mehr

Schauen wir uns einige praktische Schritte an, die wir unternehmen können, um den folgenden Code mit funktionalen Programmierkonzepten zu verbessern.

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

Funktionen Abhängigkeit von Shared Status

reduzieren

Dies mag offensichtlich und trivial klingen, aber ich schreibe trotzdem Funktionen, die zugreifen und viel außerhalb von sich selbst ändern. Dies erschwert sie schwieriger zu testen und anfällig für Fehler.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Verwenden Sie mehr lesbare Sprachabstraktionen wie für die Iterate

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

Verwenden Sie Abstraktionen wie MAP mit höherer Ebene, um die Menge an Code zu verringern

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

Funktionen auf ihre einfachsten Formen

<span>let items = ['a','b','c'];
</span><span>let newItems = pure(items);
</span><span>// I expect items to be ['a','b','c']
</span>

reduzieren

Code löschen, bis er nicht mehr funktioniert

<span>import _ from 'ramda';
</span><span>import $ from 'jquery';
</span>
<span>var Impure = {
</span>  <span>getJSON: _.curry(function(callback<span>, url</span>) {
</span>    $<span>.getJSON(url, callback);
</span>  <span>}),
</span>
  <span>setHtml: _.curry(function(sel<span>, html</span>) {
</span>    <span>$(sel).html(html);
</span>  <span>})
</span><span>};
</span>
<span>var img = function (url) {
</span>  <span>return $('<img />', { src: url });
</span><span>};
</span>
<span>var url = function (t) {
</span>  <span>return 'http://api.flickr.com/services/feeds/photos_public.gne?tags=' +
</span>    t <span>+ '&format=json&jsoncallback=?';
</span><span>};
</span>
<span>var mediaUrl = _.compose(_.prop('m'), _.prop('media'));
</span><span>var mediaToImg = _.compose(img, mediaUrl);
</span><span>var images = _.compose(_.map(mediaToImg), _.prop('items'));
</span><span>var renderImages = _.compose(Impure.setHtml("body"), images);
</span><span>var app = _.compose(Impure.getJSON(renderImages), url);
</span><span>app("cats");
</span>

Wir brauchen überhaupt keine Funktion für eine so einfache Aufgabe, die Sprache bietet uns ausreichende Abstraktionen, um sie wörtlich zu schreiben.

testen

einfach in der Lage zu sein, unsere Programme zu testen, ist ein wesentlicher Vorteil von reinen Funktionen. In diesem Abschnitt werden wir also einen Testkabelbaum für unser Flickr -Modul einrichten, das wir uns zuvor angesehen haben.

<span>var app = (tags)=> {
</span>  <span>let url = <span>`http://api.flickr.com/services/feeds/photos_public.gne?tags=<span>${tags}</span>&format=json&jsoncallback=?`</span>
</span>  $<span>.getJSON(url, (data)=> {
</span>    <span>let urls = data.items.map((item)=> item.media.m)
</span>    <span>let images = urls.map((url)=> $('<img />', { src: url }) )
</span>
    <span>$(document.body).html(images)
</span>  <span>})
</span><span>}
</span><span>app("cats")
</span>

starten Sie ein Terminal und lassen Sie Ihren Texteditor aufstellen und bereit. Wir werden Mokka als Testläufer und Babel zum Zusammenstellen unseres ES6 -Code verwenden.

Mokka hat eine Reihe von praktischen Funktionen wie beschreiben und es für die Auflösung unserer Tests und Haken wie vor und nachher für Setup- und TeelaDdown -Aufgaben. Assert ist ein Kernknotenpaket, das einfache Gleichstellungstests, Assert und Assert durchführen kann.

Schreiben wir unseren ersten Test in Test/Beispiel.js

<span>let flickr = (tags)=> {
</span>  <span>let url = <span>`http://api.flickr.com/services/feeds/photos_public.gne?tags=<span>${tags}</span>&format=json&jsoncallback=?`</span>
</span>  <span>return fetch(url)
</span>  <span>.then((resp)=> resp.json())
</span>  <span>.then((data)=> {
</span>    <span>let urls = data.items.map((item)=> item.media.m )
</span>    <span>let images = urls.map((url)=> $('<img />', { src: url }) )
</span>
    <span>return images
</span>  <span>})
</span><span>}
</span><span>flickr("cats").then((images)=> {
</span>  <span>$(document.body).html(images)
</span><span>})
</span>

öffnen Sie Paket.json und ändern Sie das Skript "Test" in der folgenden

<span>let responseToImages = (resp)=> {
</span>  <span>let urls = resp.items.map((item)=> item.media.m )
</span>  <span>let images = urls.map((url)=> $('<img />', { src: url }))
</span>
  <span>return images
</span><span>}
</span>

Dann sollten Sie den NPM -Test aus der Befehlszeile ausführen können, um zu bestätigen, dass alles wie erwartet funktioniert.

<span>let urls = (data)=> {
</span>  <span>return data.items.map((item)=> item.media.m)
</span><span>}
</span><span>let images = (urls)=> {
</span>  <span>return urls.map((url)=> $('<img />', { src: url }))
</span><span>}
</span><span>let responseToImages = _.compose(images, urls)
</span>

boom.

Hinweis: Sie können am Ende dieses Befehls auch ein -W -Flag hinzufügen, wenn Sie möchten, dass Mokka nach Änderungen achten und die Tests automatisch ausführen. Sie werden bei Wiederholungen erheblich ausgeführt.

<span>let responseToImages = (data)=> {
</span>  <span>return images(urls(data))
</span><span>}
</span>

Testen Sie unser Flickr -Modul

Fügen wir unser Modul in lib/flickr.js

<span>let items = ['a', 'b', 'c'];
</span><span>let upperCaseItems = ()=> {
</span>  <span>let arr = [];
</span>  <span>for (let i = 0, ii = items.length; i < ii; i++) {
</span>    <span>let item = items[i];
</span>    arr<span>.push(item.toUpperCase());
</span>  <span>}
</span>  items <span>= arr;
</span><span>}
</span>

hinzu

Unser Modul enthält zwei Methoden: Flickr, um öffentlich konsumiert zu werden, und eine private Funktion _responsetoimages, damit wir dies isoliert testen können.

Wir haben ein paar neue Abhängigkeiten: JQuery, Unterstriche und Polyfills für das Abholen und Versprechen. Um diejenigen zu testen, können wir JSDOM verwenden, um das Fenster DOM -Objekte und das Dokument zu polyieren, und wir können das Sinon -Paket zum Stubieren der Fetch -API verwenden.

<span>// pure
</span><span>function add(a<span>, b</span>) {
</span>  <span>return a + b;
</span><span>}
</span>

öffnen Sie test/_setup.js und wir konfigurieren JSDOM mit unseren Globalen, von denen unser Modul abhängt.

<span>// impure
</span><span>var minimum = 21;
</span><span>var checkAge = function(age) {
</span>  <span>return age >= minimum; // if minimum is changed we're cactus
</span><span>};
</span>

Unsere Tests können in Test/Flickr.js sitzen, bei denen wir Behauptungen über unsere Funktionen ausgeben, die vordefinierte Eingänge ausgeben. Wir „Stub“ oder überschreiben die globale Fetch -Methode, um die HTTP -Anfrage abzufangen und zu fälschen, damit wir unsere Tests ausführen können, ohne die Flickr -API direkt zu treffen.

<span>// pure
</span><span>var checkAge = function(age) {
</span>  <span>var minimum = 21;
</span>  <span>return age >= minimum;
</span><span>};
</span>

Führen Sie unsere Tests erneut mit dem NPM -Test aus und Sie sollten drei Grüne Zecken versichern.

<span>// impure, splice mutates the array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.splice(0,3); // arr may never be the same again
</span><span>};
</span>
<span>// pure, slice returns a new array
</span><span>var firstThree = function(arr) {
</span>  <span>return arr.slice(0,3);
</span><span>};
</span>

Puh! Wir haben unser kleines Modul und die Funktionen, die es ausmachen, erfolgreich getestet, über reine Funktionen gelernt und wie man funktionale Komposition auf dem Weg verwendet. Wir haben das Pure von den unreinen, es lesbar, bestehend aus kleinen Funktionen und gut getestet. Der Code ist einfacher zu lesen, zu verstehen und zu ändern, als das obige unangemessen reine Beispiel für das Refactoring -Code. reine Funktionen, verwenden Sie sie.

Links

Professor Frisby von Professor von Meist angemessener Leitfaden für funktionale Programme - @drboolean - Dieses hervorragende kostenlose Buch über funktionale Programmierung von Brian Lonsdorf ist der beste Leitfaden für FP, auf das ich gestoßen bin. Viele der Ideen und Beispiele in diesem Artikel stammen aus diesem Buch.

• eloquent javaScript - funktionales Programmieren @Marijnjh - Marijn Haverbekes Buch bleibt eines meiner Lieblings -Intros für das Programmieren und hat auch ein großartiges Kapitel über die funktionale Programmierung.
• Unterstrich - Das Graben in eine Versorgungsbibliothek wie Unterstrich, Lodash oder Ramda ist ein wichtiger Schritt, um als Entwickler zu reifen. Wenn Sie verstehen, wie diese Funktionen verwendet werden, werden die Menge an Code, die Sie schreiben, drastisch reduzieren und Ihre Programme deklarativer machen.
-

Das ist alles fürs Erste! Vielen Dank fürs Lesen und ich hoffe, Sie haben dies als eine gute Einführung in die funktionale Programmierung, Wiederaufbauung und Tests in JavaScript gefunden. Es ist ein interessantes Paradigma, das im Moment Wellen schlägt, was vor allem auf die wachsende Beliebtheit von Bibliotheken wie React, Redux, ELM, Cycle und Reactivex entspricht, die diese Muster fördern oder durchsetzen.

Springen Sie hinein, das Wasser ist warm.

häufig gestellte Fragen zur einigermaßen reinen funktionalen Programmierung

Welche Bedeutung haben reine Funktionen in der funktionellen Programmierung? Es sind Funktionen, die immer den gleichen Ausgang für denselben Eingang erzeugen und keine Nebenwirkungen haben. Dies bedeutet, dass sie keinen Zustand außerhalb ihres Geltungsbereichs ändern oder von einem externen Zustand abhängen. Dies macht sie vorhersehbar und leicht zu testen, da Sie nur die Eingabe und Ausgabe berücksichtigen müssen, ohne sich über externe Faktoren zu sorgen. Reine Funktionen fördern auch die Wiederverwendbarkeit und Lesbarkeit des Codes, wodurch Ihr Code leichter zu verstehen und zu warten ist.

Wie unterscheidet sich die funktionelle Programmierung von anderen Programmierparadigmen? Dies steht im Gegensatz zu imperativen Programmierungen, bei denen Programme aus Aussagen bestehen, die bei der Ausführung den globalen Zustand verändern. Funktionelle Programmierung fördert höhere Abstraktionen auf höherer Ebene, wie Funktionen als erstklassige Bürger, und fördert die Programmierung mit Ausdrücken anstelle von Aussagen. Dies führt zu einem deklarativeren und ausdrucksstärkeren Programmstil, der leichter zu begründen ist.

Wie kann ich reine Funktionen in JavaScript implementieren? erzeugt den gleichen Ausgang für denselben Eingang und erzeugt keine Nebenwirkungen. Hier ist ein Beispiel:

Funktion add (a, b) {

return a b;

}

In diesem Beispiel ist die Funktion add eine reine Funktion, da sie immer die zurückgibt, die die zurückgibt Gleiches Ergebnis bei den gleichen Argumenten und ändert keinen externen Zustand. Sie machen Ihren Code vorhersehbarer und einfacher zu testen und zu debuggen, da Sie nur die Eingabe und Ausgabe der Funktion berücksichtigen müssen. Sie machen Ihren Code auch lesbarer und wartbarer, da sie einen klaren und einfachen Programmierstil bewerben. Darüber hinaus sind reine Funktionen sehr wiederverwendbar und komponierbar, sodass Sie komplexere Funktionen mit weniger Code erstellen können. Sie stellen auch einige Herausforderungen dar. Eine der Hauptherausforderungen besteht darin, dass JavaScript keine rein funktionale Sprache ist und Nebenwirkungen und veränderliche Daten ermöglicht. Dies bedeutet, dass Sie vorsichtig sein müssen, um nicht beabsichtigte Nebenwirkungen in Ihren Funktionen einzuführen. Darüber hinaus kann die Verwendung reiner Funktionen manchmal zu mehr ausführlicher Code führen, da Sie mutierende Daten vermeiden und stattdessen neue Daten zurückgeben müssen. ist besonders gut für Parallelität und Parallelität geeignet. Da reine Funktionen keine Nebenwirkungen haben, können sie parallel sicher ausgeführt werden, ohne sich über Rennbedingungen oder Datenversorgung zu sorgen. Dies macht die funktionelle Programmierung zu einem leistungsstarken Tool zur Entwicklung gleichzeitiger und paralleler Anwendungen, insbesondere in einer Multi-Core- und Distributed Computing-Umgebung.

Was ist Funktionszusammensetzung in der funktionalen Programmierung? Dazu gehören zwei oder mehr Funktionen, um eine neue Funktion zu erstellen. Das Ergebnis einer Funktion wird als Eingabe für die nächste Funktion verwendet. Auf diese Weise können Sie komplexe Funktionen aus einfachen Funktionen erstellen und die Wiederverwendbarkeit und Lesbarkeit von Code fördern. Dies bedeutet, dass eine Datenstruktur nicht geändert werden kann. Wenn Sie eine Datenstruktur ändern möchten, erstellen Sie stattdessen eine neue mit den gewünschten Änderungen. Dies vermeidet Nebenwirkungen und erleichtert Ihren Code sicherer und leichter zu argumentieren. Anstatt den Zustand zu ändern, verwendet die funktionale Programmierung häufig reine Funktionen, die einen neuen Zustand zurückgeben. Dies macht den Staat vorhersehbar und einfach zu verwalten. Einige funktionale Programmiersprachen bieten auch erweiterte Funktionen für das Staatsmanagement, wie z. B. Monaden in Haskell. . In Situationen, in denen Parallelität und Parallelität wichtig sind, ist es besonders nützlich, beispielsweise in Multi-Core- und Distributed Computing. Die funktionelle Programmierung wird auch häufig in der Datenverarbeitung und -analytik verwendet, wobei reine Funktionen und Unveränderlichkeit dazu beitragen können, die Datenintegrität zu gewährleisten. Darüber hinaus werden funktionelle Programmierkonzepte zunehmend in der Front-End-Entwicklung übernommen, wobei beliebte Frameworks wie React.js einen funktionalen Stil für die Komponentenentwicklung verwenden.

Das obige ist der detaillierte Inhalt vonEine Einführung in ein vernünftiges pures funktionelles Programmieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!