Wichtigste Erkenntnisse
JavaScript-Programme als Transformationen von Daten begreifen, nicht als Geflechte sich verändernder Objekte
Funktionen werden zu Bausteinen. Fogus beschreibt funktionale Programmierung als den Einsatz von Funktionen, um Werte in nützliche Abstraktionen zu verwandeln und diese Abstraktionen anschließend zu größeren Verhaltensweisen zusammenzufügen. Objektorientiertes Design organisiert ein System häufig um Dinge, die miteinander interagieren; funktionales Design stellt Operationen in den Mittelpunkt, die Daten transformieren. JavaScript eignet sich für beide Ansätze, weil Funktionen Werte sind. Seine flexiblen Standardeinstellungen machen jedoch auch unbeabsichtigte Zustandsänderungen leicht.
Veränderungen werden eingegrenzt, nicht geleugnet. Ein praktischer funktionaler Stil verlangt nicht, jede Mutation auszuschließen. Ziel ist es, Transformationen vorhersehbar zu machen und Änderungen auf kleine, kontrollierte Bereiche zu beschränken. Underscore bietet dafür praktische Werkzeuge, doch im Mittelpunkt stehen die Ideen, nicht die Übernahme einer bestimmten Bibliothek. Der Gewinn: Beim Ändern oder Testen einer wachsenden Anwendung muss weniger Zustand im Blick behalten werden.
Besonders überzeugend ist der Wechsel der Gestaltungseinheit: Statt zu fragen, welches Objekt für ein Verhalten zuständig ist, fragt man, welche Transformation die vorhandenen Daten in die benötigten Daten überführt. Diese Perspektive erinnert an die Trennung zwischen einer Datenbankabfrage und den gespeicherten Datensätzen, die sie liest. Die Abfrage lässt sich prüfen und neu kombinieren, ohne die Quelle zu verändern. Der Vergleich hat allerdings Grenzen: Echte Anwendungen müssen mit Browsern, Servern und Nutzern kommunizieren; Effekte lassen sich also nicht einfach beseitigen. Der sinnvolle Maßstab ist daher nicht überallige Reinheit, sondern eine klare Abgrenzung zwischen vorhersehbaren Transformationen und Aktionen, die die Außenwelt verändern.
Verhalten als Daten übergeben, damit eine Operation vielen Problemen dient
Funktionen lassen sich wie Werte weitergeben. Eine Funktion erster Klasse kann gespeichert, als Argument übergeben oder zurückgegeben werden – genau wie eine Zahl. Eine Funktion höherer Ordnung nimmt eine Funktion entgegen, gibt eine zurück oder tut beides. So kann eine allgemeine Operation viele konkrete Aufgaben erledigen: `map` wendet eine bereitgestellte Funktion auf jedes Element an, `filter` behält Elemente, die ein Prädikat erfüllen, und `reduce` führt Elemente zu einem Ergebnis zusammen.
Sammlungen werden zu einer gemeinsamen Sprache. Underscore wendet diese Operationen auf Arrays und Objekte an und fördert so die Wiederverwendung, statt für jede Datenform eigene Schleifen zu schreiben. Mit derselben Mapping-Operation lässt sich beispielsweise ein Feld aus jedem Datensatz auslesen oder jeder Wert umformen. Ein Prädikat kann festlegen, was als akzeptabler Datensatz gilt, während die Verarbeitung der Sammlung unverändert bleibt.
Hier werden Richtlinie und Mechanismus voneinander getrennt. Die Sammlungsfunktion stellt den Mechanismus bereit, der Callback die Richtlinie für die jeweilige Aufgabe. Dadurch lässt sich das Verhalten auch leichter isoliert testen: Ein Callback kann anhand einiger repräsentativer Eingaben geprüft werden, bevor er auf eine große Sammlung angewendet wird. Der Nachteil ist die zusätzliche Indirektion. Ein Programm mit vielen Callbacks kann schwerer zu verstehen sein, wenn Funktionen unklare Namen haben oder Nebenwirkungen verbergen. Wiederverwendung funktioniert am besten, wenn jede Funktion einen eng gefassten, klaren Vertrag hat.
Funktionen mit Closures konfigurieren, eingefangenen veränderlichen Zustand aber Zügel anlegen
Eine Funktion kann Kontext mit sich führen. Ein Abschluss (Closure) ist eine Funktion, die weiterhin auf Variablen aus dem Gültigkeitsbereich zugreifen kann, in dem sie erstellt wurde – auch nachdem die umgebende Funktion beendet ist. So kann eine Funktion etwa einen Skalierungsfaktor entgegennehmen und eine weitere Funktion zurückgeben, die jede Eingabe mit diesem Faktor multipliziert. Jede zurückgegebene Funktion behält ihren eigenen eingefangenen Wert. Dadurch sind Closures eine kompakte Möglichkeit, konfiguriertes Verhalten zu erzeugen und Implementierungsdetails zu verbergen.
Eingefangene Referenzen sind nicht eingefroren. Eine Closure, die eine Objektreferenz enthält, kann weiterhin Änderungen mitbekommen, die über eine andere Referenz auf dieses Objekt vorgenommen werden. Ein privater Zähler kann vor Zugriffen von außen geschützt sein, sein Ergebnis hängt aber dennoch davon ab, wie oft die Funktion aufgerufen wurde. JavaScripts `this` birgt eine eigene Gefahr: `call` und `apply` können seinen Wert ändern, während `bind` ihn festhalten kann.
Closures bieten einen nützlichen Mittelweg zwischen globalen Variablen und aufwendigen Objekthierarchien: Verhalten und seine Konfiguration lassen sich bündeln, ohne jedes Detail offenzulegen. Das ist besonders wertvoll für Ereignisbehandlungsfunktionen und kleine, wiederverwendbare Adapter. Der entscheidende Punkt ist, dass Privatsphäre nicht dasselbe ist wie Unveränderlichkeit. Eine verborgene Variable kann sich mit der Zeit trotzdem ändern, und ein eingefangenes Objekt kann an anderer Stelle gemeinsam genutzt werden. Bei gutem Closure-Design stellt man sich daher zwei Fragen: Was wurde eingefangen, und kann irgendein Aufrufer es indirekt verändern?
Kleine Funktionen komponieren und sie mit partieller Anwendung spezialisieren
Verhalten aus Verhalten zusammensetzen. Bei der Funktionskomposition werden Operationen so verknüpft, dass die Ausgabe der einen zur Eingabe der nächsten wird. Fogus zeigt das anhand eines Dispatchers, der nacheinander spezialisierte Funktionen ausprobiert – etwa eine für Arrays und eine weitere für Zeichenketten. Neues Verhalten lässt sich so aus vorhandenen Bausteinen zusammensetzen, statt es in einer großen Bedingungsabfrage aufzubauen.
Argumente festlegen, um Varianten zu erzeugen. Currying gibt eine Folge von Funktionen zurück, von denen jede auf ein weiteres Argument wartet; bei der partiellen Anwendung werden einige Argumente festgehalten und eine Funktion zurückgegeben, die mit den übrigen ausgeführt werden kann. Das Buch bevorzugt Currying von rechts nach links, während seine Beispiele zur partiellen Anwendung die führenden Argumente festlegen. Da JavaScript optionale und zusätzliche Argumente zulässt, kann Currying umständlich sein; die partielle Anwendung ist oft das natürlichere Mittel. Beide Techniken unterstützen auch wiederverwendbare Validatoren und konfigurierte Standardwerte.
Der tiefere Nutzen liegt nicht in kürzerem Code, sondern darin, Entscheidungen als wiederverwendbare Komponenten sichtbar zu machen. Ein aus benannten Prädikaten zusammengesetzter Validator erklärt seine Regeln klarer als eine dichte Bedingungsabfrage, und die einzelnen Regeln lassen sich unabhängig testen. Bei der Komposition kommt es zudem auf die Reihenfolge an: Ein früher Zweig des Dispatchers kann einen Fall abfangen, bevor spätere Zweige ihn sehen. Solche Designs brauchen klare Vereinbarungen für Fehler und Rückfälle – besonders dann, wenn undefined bedeutet, dass eine Funktion eine Eingabe nicht behandelt hat. Fehlen solche Konventionen, verteilt Modularität die Verwirrung womöglich nur auf mehrere Stellen.
Rekursion nur dann einsetzen, wenn die Datenstruktur sie nahelegt
Ein kleineres Problem lösen. Rekursion eignet sich für Probleme, deren Teile dieselbe Struktur wie das Ganze aufweisen. Um etwa ein Array zu zählen, gibt man für ein leeres Array null zurück; andernfalls zählt man den Rest und addiert eins. Ein solides rekursives Design bestimmt einen Abbruchfall, einen einzelnen Schritt und ein kleineres Problem. Das Buch nutzt diesen Ansatz, um verschachtelte Arrays zu durchlaufen und ein Netzwerk von Einflüssen zwischen Programmiersprachen zu durchsuchen. Dabei wird eine Aufzeichnung der bereits besuchten Knoten weitergereicht, um Zyklen zu vermeiden.
Die Grenzen des JavaScript-Aufrufstapels beachten. Tiefe rekursive Aufrufe können den Aufrufstapel überlasten, und die im Buch behandelten JavaScript-Engines optimieren Endrekursion nicht zuverlässig. Ein Trampolin (Trampoline) vermeidet verschachtelte Aufrufe, indem es die nächste auszuführende Funktion zurückgibt und solche Funktionen in einer Schleife aufruft. Rekursion ist jedoch nicht die Standardlösung: Vorhandene Sammlungsoperationen können viele Aufgaben einfacher ausdrücken.
Rekursion macht strukturelles Denken ungewöhnlich unmittelbar: Ein Baum wird verarbeitet, indem man einen Knoten behandelt und dieselbe Logik auf seine Kinder anwendet. Das eignet sich hervorragend für verschachtelte Daten, doch Eleganz auf dem Papier garantiert keine sichere Ausführungstiefe. Das Trampolin veranschaulicht einen wichtigen Unterschied zwischen einem Berechnungsmodell und der Laufzeitumgebung, die es ausführt. Eine rekursive Definition kann die klarste Spezifikation sein, während eine iterative Implementierung die sicherere Wahl für den Produktiveinsatz darstellt. Bei der Entscheidung sollten Eingabegröße, Stapelgrenzen und Lesbarkeit berücksichtigt werden.
Reine Funktionen zum testbaren Kern machen und unvermeidbare Effekte abschirmen
Reinheit macht Ergebnisse vorhersehbar. Eine reine Funktion hängt nur von ihren Argumenten ab, verändert keinen Zustand außerhalb ihrer selbst und liefert für dieselben Eingaben stets dasselbe Ergebnis. Dadurch sind gewöhnliche Ein- und Ausgabetests zuverlässig. Ein Zufallszeichenfolgengenerator kann kein einziges exaktes Ergebnis garantieren, da er von einer Zufallsquelle abhängt. Fogus trennt die vorhersehbare Arbeit, Zeichen zu einer Zeichenfolge zusammenzufügen, vom unvorhersehbaren Schritt der Zeichenerzeugung. So lässt sich der Kern mit einer festen Zeichenfunktion testen.
Mutation hinter Grenzen verbergen. JavaScript-Arrays und -Objekte können über gemeinsam genutzte Referenzen verändert werden. Eine Funktion, die sie entgegennimmt, muss daher darauf achten, sie nicht unerwartet zu ändern. Lokale Mutation kann dennoch sinnvoll sein, wenn die Funktion ein neues Ergebnis zurückgibt und die Änderungen intern hält. Defensive Kopien und sorgfältig kontrollierte Zustandscontainer verringern die Zahl der Stellen, an denen Änderungen auftreten können.
Reinheit ist wertvoll, weil sie die Zahl der Bedingungen verringert, die ein Test kontrollieren muss. Hängt ein Ergebnis nur von expliziten Eingaben ab, muss der Test weder eine bestimmte globale Umgebung noch eine Aufrufhistorie nachbilden. Dieselbe Eigenschaft erleichtert die Fehlersuche und macht Funktionen einfacher zwischenspeicherbar oder umstellbar. Nützliche Software braucht jedoch externe Effekte, und jede kleine Operation in Abstraktionen zu verpacken, hat seinen Preis. Das praktische Ziel ist ein unkomplizierter, deterministischer Kern, umgeben von klar gekennzeichneten Grenzen für Zufall, Protokollierung, Netzwerkzugriffe und Zustandsänderungen.
Für Werte Funktionspipelines wählen und bei störenden Effekten Aktionen explizit machen
Funktionspipelines machen den Datenfluss sichtbar. Eine Funktionspipeline leitet einen Anfangswert durch eine Folge von Funktionen, wobei jedes Ergebnis zur nächsten Eingabe wird. So kann eine Sammlung beispielsweise bereinigt, getrimmt und neu geordnet werden, ohne das Original zu verändern. Beim Methodenverkettung trägt man dagegen gewöhnlich dasselbe Objekt von einem Methodenaufruf zum nächsten weiter. Eine verzögerte Kette speichert Aufrufe zur späteren Ausführung; eine normale Pipeline berechnet ihre Transformationen beim Aufruf.
Effekte brauchen einen stabilen Vertrag. Eine Protokollierungsfunktion gibt möglicherweise nichts zurück und unterbricht damit eine Pipeline, die erwartet, dass der nächste Schritt einen brauchbaren Wert erhält. Die `actions`-Abstraktion des Buches löst das, indem sie eine einheitliche Aufzeichnung des aktuellen Zustands und der Antwort jeder Aktion mitführt. So lassen sich ansonsten inkompatible Schritte komponieren. Promises behandeln einen anderen Fall: die Koordination asynchroner Arbeit, deren Abschluss erst mit der Zeit eintritt.
Eine Funktionspipeline stellt den Datenfluss visuell dar, während eine Folge von Effekten eher einem kleinen Arbeitsablauf entspricht. Diese Vorstellungen auseinanderzuhalten hilft, einen häufigen Entwurfsfehler zu vermeiden: Protokollierung, Netzwerkanfragen und Werttransformationen als austauschbar zu behandeln, nur weil sie alle Funktionen sind. Das actions-Muster bietet Flexibilität, indem es die Rückgabe jedes Schritts vereinheitlicht; sein zusätzlicher Verwaltungsaufwand kann jedoch größer sein, als die Aufgabe rechtfertigt. Bei einfachen Programmen vermittelt eine explizite Abfolge die Absicht womöglich klarer als ein allgemeines Kompositionsframework.
Mit Arrays, Objekten und Funktionen beginnen, bevor eine Klassenhierarchie erfunden wird
Informationen einfach modellieren. Der datenorientierte Denkansatz (Data Thinking) des Buches bevorzugt JavaScripts eingebaute Arrays und Objekte, wenn sie das Problem gut abbilden. Eine Büchertabelle kann beispielsweise ein Array aus Datensätzen sein. Funktionen können Spalten auswählen, Felder umbenennen oder Zeilen filtern – ähnlich wie grundlegende Operationen in relationalen Datenbanken. So muss man nicht erst eigene Klassen für eine Tabelle, eine Zeile und jede Art von Datensatz schaffen, bevor diese Typen einen echten Nutzen bieten.
Die Darstellung austauschbar halten. Funktionen, die festlegen, wie auf Daten zugegriffen wird, können die zugrunde liegende Struktur vor anderen Teilen eines Programms verbergen. So lässt sich die Darstellung ändern, ohne jeden Verbraucher umzuschreiben. Der Autor sieht dennoch eine Rolle für objektorientiertes Design, insbesondere bei der Modellierung von Entitäten für Simulationen. Es geht darum, für die Informationsverarbeitung einfache Daten zu wählen und spezialisierte Typen den Verhaltensweisen vorzubehalten, die sie tatsächlich benötigen.
Dieser Rat erinnert an ein nützliches Prinzip des Datenbankdesigns: Gespeicherte Fakten sollten von den vielen Fragen getrennt bleiben, die man an sie richtet. Sind Datensätze gewöhnliche Daten, lassen sich Filterungen und Aggregationen über verschiedene Bereiche hinweg wiederverwenden, statt in den Methoden einer einzelnen Klasse eingeschlossen zu sein. Besonders gut funktioniert dieser Ansatz, wenn Daten hauptsächlich durch Transformationen weitergereicht werden. Weniger geeignet ist er, wenn eine Entität starke Invarianten, eine Identität oder einen Lebenszyklus hat, der gewährleistet werden muss. Entscheidend ist, ob ein Typ diese Einschränkungen verdeutlicht – nicht, ob ein vertrautes objektorientiertes Muster verfügbar ist.
Mixins für besondere Verhaltensweisen nutzen, Mutation und Geschwindigkeit aber bewusst abwägen
Verhaltensweisen kombinieren, ohne eine Taxonomie zu erzwingen. Ein Mixin ist ein Bündel von Methoden, das ein Typ übernehmen kann. Statt jede Fähigkeit in eine tiefe Vererbungshierarchie einzuordnen, kann ein Typ `Hole` Validierungs-, Benachrichtigungs- und Wertsetzungsverhalten kombinieren. Das Buch zeigt auch ein Compare-and-Swap-Verhalten: Ein gespeicherter Wert wird nur dann aktualisiert, wenn er noch dem erwarteten alten Wert entspricht. Mixins eignen sich für spezialisierte Typen; für gewöhnliche Daten sind einfache Arrays und Objekte weiterhin vorzuziehen.
Bei Implementierungsentscheidungen pragmatisch bleiben. Die Prototypen eingebauter Typen sollte man nicht verändern, denn das kann sich auf davon unabhängigen Code auswirken. Funktionale Hilfsfunktionen können im Vergleich zu einer direkten Schleife zusätzlichen Aufwand verursachen; das Buch rät jedoch davon ab, zu optimieren, bevor Korrektheit und Klarheit gewährleistet sind. Mutation innerhalb einer privaten Implementierung kann vertretbar sein, wenn Aufrufer ein vorhersehbares Ergebnis erhalten und die ursprünglichen Daten geschützt bleiben. Die Leistung sollte dort gemessen werden, wo sie wichtig ist; anschließend optimiert man die eng begrenzten Hotspots.
Mixins beheben eine echte Schwäche starrer Hierarchien: Neue Verhaltensweisen passen nicht immer in eine einzige Eltern-Kind-Klassifikation. Ihre Flexibilität birgt jedoch ein anderes Risiko. Methodennamen können kollidieren, die Reihenfolge der Erweiterungen kann bestimmen, welche Implementierung Vorrang hat, und implizite Protokolle können schwer aufzuspüren sein. Explizite Anforderungen für jedes Mixin machen solche Abhängigkeiten leichter nachvollziehbar. Auch der Rat zur Leistung ist ausgewogen: Abstraktionen kosten Laufzeit, beanspruchen aber auch die Aufmerksamkeit der Entwickler. Eine langsamere Hilfsfunktion kann ein guter Kompromiss sein, bis Messungen zeigen, dass sie an einer kritischen Stelle liegt.
Analyse
Fogus stellt funktionales JavaScript als praktische Disziplin für eine Sprache dar, die viele Stile zulässt, aber nur wenige Schutzvorkehrungen erzwingt. Der rote Faden ist nicht, dass Funktionen Objekten moralisch überlegen wären. Vielmehr können Funktionen, die mit einfachen Daten arbeiten, Transformationen leichter komponierbar, testbar und veränderbar machen und zugleich die verborgenen Abhängigkeiten verringern, die durch gemeinsam genutzten, veränderlichen Zustand entstehen. Underscore dient als praktischer Werkzeugkasten, nicht als Gegenstand der Argumentation.
Das Buch geht von den Grundlagen zur Architektur über. Funktionen erster Klasse und Sammlungsoperationen machen Verhalten wiederverwendbar. Gültigkeitsbereiche und Closures erklären, wie Funktionen ihre Konfiguration behalten und wo verborgener Zustand entstehen kann. Funktionen höherer Ordnung, Currying, partielle Anwendung und Komposition machen aus kleinen Operationen größere. Rekursion erschließt verschachtelte Daten, ist jedoch durch JavaScripts Aufrufstapel begrenzt. Reinheit und Unveränderlichkeit werden anschließend zu Gestaltungsrichtlinien, nicht zu absoluten Forderungen. Funktionspipelines verdeutlichen den Wertfluss, während Aktionen Schritte ermöglichen, deren Ergebnisse nicht von selbst zusammenpassen. Schließlich bieten datenorientiertes Design und Mixins Alternativen dazu, mit Klassen zu beginnen.
Der größte Beitrag des Buches liegt darin zu zeigen, dass sich der funktionale Stil auch im gewöhnlichen JavaScript nutzen lässt, ohne eine neue Sprache einzuführen oder die objektorientierte Programmierung vollständig abzulehnen. Auch seine praktische Skepsis ist wichtig: Mutation lässt sich sicher verbergen, imperative Schleifen können angemessen sein, und funktionale Hilfsfunktionen können Zeit kosten. Eine Einschränkung besteht darin, dass viele Beispiele kleine, saubere Daten und von Hand entwickelte Abstraktionen verwenden. Produktionsfragen wie Fehlerweitergabe, Typverträge und komplexe asynchrone Koordination erhalten daher weniger Aufmerksamkeit. Die bleibende Lehre ist eine Methode des Abwägens: Daten einfach halten, Transformationen explizit machen, Effekte isolieren und spezialisierte Mittel nur dann einführen, wenn das Problem sie rechtfertigt. Am überzeugendsten ist dieser Ansatz als Werkzeugkasten zur Bewältigung von Komplexität, nicht als universelle Programmierlehre.
Rezensionsübersicht
Functional JavaScript erhält überwiegend positive Bewertungen und eine durchschnittliche Bewertung von 4,07 von 5. Leser schätzen die klare Erklärung funktionaler Programmierkonzepte in JavaScript und loben den direkten Ansatz sowie die praktischen Beispiele. Viele finden das Buch aufschlussreich und hilfreich, um ihre Programmierkenntnisse zu verbessern. Einige Rezensenten merken an, dass es dicht geschrieben ist, und empfehlen es Programmierern mit mittleren bis fortgeschrittenen Kenntnissen. Zwar kritisieren einige die starke Abhängigkeit von Underscore.js und bezweifeln die Anwendbarkeit in der Praxis, doch die meisten sind sich einig, dass es eine solide Einführung in Techniken des funktionalen Programmierens in JavaScript ist.
Andere lasen auch
Glossar
Funktion erster Klasse
Funktion, die als Wert behandelt wirdEine Funktion ist von erster Klasse, wenn sie ähnlich wie andere Werte verwendet werden kann. In JavaScript kann sie einer Variablen zugewiesen, in einem Array oder Objekt gespeichert, an eine andere Funktion übergeben oder als Ergebnis zurückgegeben werden. Diese Freiheit ermöglicht es, Funktionen als wiederverwendbares Verhalten einzusetzen, das je nach Bedarf bereitgestellt oder zusammengesetzt werden kann.
Funktion höherer Ordnung
Funktion, die mit Funktionen arbeitetEine Funktion höherer Ordnung nimmt eine oder mehrere Funktionen als Argumente entgegen, gibt eine Funktion zurück oder tut beides. map nimmt beispielsweise eine Funktion entgegen, die auf jedes Element einer Sammlung angewendet wird. Auch eine Funktion, die ein konfiguriertes Prädikat zurückgibt, ist eine Funktion höherer Ordnung. Solche Operationen ermöglichen wiederverwendbares Verhalten, ohne jede Aufgabe fest zu codieren.
Abschluss (Closure)
Funktion mit erhaltenen BindungenEin Abschluss (Closure) ist eine Funktion, die auch nach der Rückkehr der umgebenden Funktion weiterhin auf Variablen aus dem Gültigkeitsbereich zugreifen kann, in dem sie erstellt wurde. Abschlüsse können eine Konfiguration wie einen Skalierungsfaktor bewahren oder private Daten verbergen. Erfasste Objekte bleiben veränderbar, wenn anderer Code eine Referenz auf sie besitzt.
applikatives Programmieren
Funktionen auf Sammlungen anwendenIn diesem Buch bezeichnet applikatives Programmieren, dass eine Funktion eine andere Funktion aufruft, die sie als Argument erhalten hat. Sammlungsoperationen wie map, reduce und filter veranschaulichen diesen Stil: Jede erhält einen Callback und wendet ihn auf Werte einer Sammlung an, um sie umzuwandeln, zusammenzuführen oder auszuwählen.
datenorientiertes Denken (Data Thinking)
Daten modellieren, bevor Typen hinzukommenDatenorientiertes Denken bedeutet, Informationen mit einfachen Strukturen wie Arrays und Objekten darzustellen und anschließend Funktionen zu definieren, die diese Strukturen umwandeln oder abfragen. Ein Array mit Buchdatensätzen ermöglicht Operationen, die dem Auswählen von Feldern, Umbenennen von Spalten und Filtern von Zeilen ähneln. Ziel ist es, unnötige Klassen zu vermeiden und gleichzeitig die Darstellungen austauschbar zu halten.
Currying
Argumente schrittweise übergebenBeim Currying wird eine Funktion, die mehrere logische Argumente entgegennimmt, in eine Folge von Funktionen umgewandelt, von denen jede ein Argument erhält und die nächste Funktion zurückgibt. In Fogus' Beispielen werden Argumente von rechts nach links festgelegt. So lassen sich spezialisierte Funktionen erzeugen, auch wenn die Konventionen für optionale und variable Argumente in JavaScript Currying weniger natürlich machen können.
partielle Anwendung
Funktionsargumente vorbelegenBei der partiellen Anwendung werden eine Funktion und einige ihrer Argumente entgegengenommen; anschließend wird eine neue Funktion zurückgegeben, die auf die übrigen Argumente wartet. Sie unterscheidet sich vom Currying dadurch, dass die zurückgegebene Funktion mehrere der verbleibenden Argumente auf einmal entgegennehmen kann. Das Buch nutzt sie, um wiederverwendbare Operationen zu konfigurieren und flüssige Funktionspipelines aufzubauen.
Referenzielle Transparenz
Aufrufe durch Ergebnisse ersetzenEine Funktion ist referenziell transparent, wenn ein Aufruf durch sein Ergebnis ersetzt werden kann, ohne das Programmverhalten zu ändern. Das ist am einfachsten, wenn die Funktion nur von ihren Argumenten abhängt und keine externen Auswirkungen hat. Eine Funktion, die einen verborgenen Zähler erhöht, ist nicht referenziell transparent, weil ihre Ausgabe von ihrer Aufrufhistorie abhängt.
Trampolin (Trampoline)
Rekursive Schritte in einer Schleife ausführenEin Trampolin ersetzt tief verschachtelte rekursive Aufrufe durch wiederholte Funktionsaufrufe innerhalb einer Schleife. Rekursive Schritte geben die nächste auszuführende Funktion zurück, statt sie sofort aufzurufen. So wird vermieden, bei jedem Schritt einen neuen Stack-Frame zu belegen. Das ist in JavaScript nützlich, wenn die Rekursionstiefe die Laufzeitgrenzen überschreiten könnte.
Thunk
Funktion für verzögerte BerechnungenEin Thunk ist eine Funktion, die eine Berechnung für die spätere Ausführung verpackt. Fogus verwendet Thunks in einer verzögerten Funktionskette: Methodenaufrufe werden gespeichert, statt sofort ausgeführt zu werden, und laufen dann der Reihe nach ab, wenn die Kette ausgewertet wird. Ein Thunk kann auch die Argumente oder das Ziel erfassen, die für die spätere Berechnung benötigt werden.
Funktionspipeline
Werte durch Funktionen leitenEine Funktionspipeline leitet einen Anfangswert durch eine Folge von Funktionen und übergibt jedes Ergebnis an die nächste Funktion. Dadurch werden Transformationen explizit; außerdem lassen sich Operationen mit unterschiedlichen Zwischendatentypen verbinden, sofern ihre Ein- und Ausgaben zusammenpassen. Pipelines funktionieren am unkompliziertesten, wenn ihre Schritte nützliche Werte zurückgeben und Nebenwirkungen vermeiden.
Mixin
Wiederverwendbares VerhaltensbündelEin Mixin ist eine Sammlung von Methoden, die mit einem Typ kombiniert werden kann, um ein bestimmtes Verhalten hinzuzufügen, ohne jede Fähigkeit in eine Vererbungshierarchie einzuordnen. Die Beispiele des Buches kombinieren Verhalten zur Validierung, Beobachtung und Wertzuweisung. Mixins benötigen klare Erweiterungsprotokolle, da sich Methodenkonflikte und die Reihenfolge auf das Ergebnis auswirken können.
FAQ
Worum geht es in Functional JavaScript?
- Schwerpunkt funktionales Programmieren: Functional JavaScript von Michael Fogus führt anhand von JavaScript in Konzepte des funktionalen Programmierens ein und legt besonderen Wert auf die Bibliothek Underscore.js.
- Grundprinzipien: Das Buch hebt hervor, wie wichtig es ist, Funktionen als Werte erster Klasse zu behandeln. Das ermöglicht modulareren und wartungsfreundlicheren Code.
- Praktische Anwendungen: Es behandelt Techniken wie Funktionen höherer Ordnung, Rekursion und Funktionskomposition und ist damit sowohl für Einsteiger als auch für erfahrene Entwickler nützlich.
Warum sollte ich Functional JavaScript lesen?
- JavaScript-Kenntnisse vertiefen: Das Buch vertieft Ihr Verständnis von JavaScript, indem es Paradigmen des funktionalen Programmierens untersucht, und trägt so zu saubererem und effizienterem Code bei.
- Beispiele aus der Praxis: Es enthält zahlreiche Beispiele und Übungen, die zeigen, wie sich Konzepte des funktionalen Programmierens in alltäglichen Programmiersituationen anwenden lassen.
- Programmierparadigmen erweitern: Mit diesem Buch können Sie Ihren Werkzeugkasten für die Programmierung erweitern und vielseitiger werden, sodass Sie komplexe Probleme bewältigen können.
Was sind die wichtigsten Erkenntnisse aus Functional JavaScript?
- Funktionen erster Klasse: Funktionen in JavaScript lassen sich wie andere Werte behandeln und ermöglichen dadurch leistungsfähige Programmiertechniken.
- Funktionen höherer Ordnung: Funktionen höherer Ordnung zu erstellen und zu verwenden ist entscheidend, denn sie können andere Funktionen als Argumente entgegennehmen oder zurückgeben.
- Rekursion und Abschlüsse: Das Buch behandelt Rekursion zur Problemlösung und Abschlüsse, um im Kontext des funktionalen Programmierens Zustand zu erhalten.
Was ist eine Funktion höherer Ordnung in Functional JavaScript?
- Definition: Eine Funktion höherer Ordnung nimmt eine oder mehrere Funktionen als Argumente entgegen oder gibt eine Funktion als Ergebnis zurück.
- Beispiele im Buch: Funktionen wie
_.map,_.filterund_.reducewerden als Funktionen höherer Ordnung vorgestellt, die auf Sammlungen arbeiten und Callback-Funktionen entgegennehmen. - Bedeutung: Funktionen höherer Ordnung ermöglichen abstrakteren und wiederverwendbareren Code und helfen Entwicklern, flexiblere und modularere Anwendungen zu erstellen.
Wie erklärt Functional JavaScript die Rekursion?
- Rekursive Definition: Rekursion wird als Vorgehensweise beschrieben, bei der eine Funktion sich selbst aufruft, um kleinere Fälle desselben Problems zu lösen, etwa die Länge eines Arrays zu berechnen.
- Beispielimplementierung: Als Beispiel dient die Funktion
myLength, die rekursiv die Länge eines Arrays ermittelt: Sie prüft, ob das Array leer ist, und addiert andernfalls für jedes Element eins hinzu. - Vorteile der Rekursion: Rekursion kann komplexe Probleme vereinfachen, indem sie diese in kleinere, überschaubarere Teile zerlegt. Dadurch wird der Code leichter lesbar und wartbar.
Was sind Abschlüsse, wie sie in Functional JavaScript beschrieben werden?
- Definition von Abschlüssen: Ein Abschluss ist eine Funktion, die den lexikalischen Gültigkeitsbereich erfasst, in dem sie definiert wurde. Dadurch kann sie auch nach dem Ende der äußeren Funktion auf Variablen aus diesem Bereich zugreifen.
- Praktische Anwendung: Das Buch veranschaulicht Abschlüsse anhand von Beispielen wie
makeAdder, das Funktionen erzeugt, die sich an erfasste Variablen erinnern und so zustandsbehaftetes Verhalten ermöglichen. - Bedeutung: Abschlüsse zu verstehen ist für die Beherrschung von JavaScript unerlässlich. Sie sind ein grundlegendes Konzept, das Datenkapselung und Funktionsfabriken ermöglicht.
Wie definiert Functional JavaScript Currying?
- Definition von Currying: Currying ist der Vorgang, eine Funktion, die mehrere Argumente entgegennimmt, in eine Folge von Funktionen umzuwandeln, von denen jede ein einzelnes Argument entgegennimmt.
- Beispiel im Buch: Das Buch enthält ein Beispiel für eine Funktion mit Currying, das eine partielle Anwendung von Argumenten ermöglicht und so das Erstellen spezialisierter Funktionen erleichtert.
- Vorteile von Currying: Currying verbessert die Wiederverwendbarkeit und Flexibilität von Code und ermöglicht Entwicklern, modularere und besser komponierbare Funktionen zu erstellen.
Welche Rolle spielt Underscore.js in Functional JavaScript?
- Hilfsbibliothek: Underscore.js wird im ganzen Buch als Hilfsbibliothek verwendet, die Unterstützung für funktionales Programmieren in JavaScript bietet und Funktionen wie
map,reduceundfilterbereitstellt. - Erleichtert das Lernen: Die Bibliothek vereinfacht die Umsetzung von Konzepten des funktionalen Programmierens, sodass Leser sich auf das Verständnis der Prinzipien konzentrieren können, statt sich in Implementierungsdetails auf niedriger Ebene zu verlieren.
- Integration mit JavaScript: Das Buch zeigt, wie sich Underscore.js nutzen lässt, um saubereren, stärker funktional ausgerichteten JavaScript-Code zu schreiben, und ist damit eine praktische Ressource für Entwickler.
Wie behandelt Functional JavaScript Unveränderlichkeit?
- Bedeutung der Unveränderlichkeit: Das Buch betont, dass Unveränderlichkeit ein zentrales Prinzip des funktionalen Programmierens ist. Indem Entwickler veränderbaren Zustand vermeiden, können sie vorhersagbareren und wartungsfreundlicheren Code erstellen.
- Techniken für Unveränderlichkeit: Fogus erläutert verschiedene Techniken, um Unveränderlichkeit in JavaScript zu erreichen, etwa
Object.freezeund das Erstellen tiefer Kopien von Objekten. - Unveränderlichkeit in der Praxis: Der Autor zeigt anhand von Beispielen, wie sich Unveränderlichkeit in realen Anwendungen umsetzen lässt, und veranschaulicht ihre Vorteile für Klarheit und Zuverlässigkeit des Codes.
Welche bewährten Vorgehensweisen werden in Functional JavaScript vorgestellt?
- Nebenwirkungen vermeiden: Das Buch betont, wie wichtig es ist, reine Funktionen zu schreiben, die keinen externen Zustand verändern. Das führt zu vorhersagbarerem und besser testbarem Code.
- Funktionen höherer Ordnung verwenden: Die Nutzung von Funktionen höherer Ordnung kann abstrakteren und wiederverwendbareren Code ermöglichen und so die Verwaltung von Komplexität erleichtern.
- Rekursion und Abschlüsse nutzen: Rekursion und Abschlüsse zu verstehen und wirksam einzusetzen, kann die Fähigkeit verbessern, funktionalen JavaScript-Code zu schreiben, und elegante Lösungen für komplexe Probleme ermöglichen.
Welche praktischen Beispiele gibt es in Functional JavaScript?
- Einen einfachen Validator erstellen: Das Buch enthält einen Abschnitt über das Erstellen einer einfachen Validierungsfunktion, die Eingabewerte prüft, und veranschaulicht damit, wie sich Prinzipien des funktionalen Programmierens auf reale Situationen anwenden lassen.
- Funktionen höherer Ordnung verwenden: Fogus zeigt Beispiele für Funktionen höherer Ordnung wie
mapundfilterund veranschaulicht, wie sich damit Datensammlungen wirksam bearbeiten lassen. - Eine verzögerte Funktionskette erstellen: Der Autor zeigt, wie sich eine verzögerte Kette von Funktionsaufrufen implementieren lässt, damit Operationen erst später ausgeführt werden. Das veranschaulicht die Flexibilität und Leistungsfähigkeit funktionaler Programmiertechniken.
Was sind die besten Zitate aus Functional JavaScript, und was bedeuten sie?
- „Funktionales Programmieren bedeutet, Funktionen zu verwenden, die Werte in Abstraktionseinheiten umwandeln, aus denen anschließend Softwaresysteme aufgebaut werden.“: Dieses Zitat bringt das Wesen des funktionalen Programmierens, wie es im Buch beschrieben wird, auf den Punkt.
- „Reinheit ist der Schlüssel zur Vorhersagbarkeit.“: Dies unterstreicht, wie wichtig es beim funktionalen Programmieren ist, reine Funktionen zu schreiben, die zu vorhersagbarem Verhalten führen.
- „Komposition ist das Wesen des funktionalen Programmierens.“: Dies hebt die Bedeutung der Funktionskomposition hervor, einer grundlegenden Technik, die Wiederverwendbarkeit und Klarheit des Codes verbessert.
PDF herunterladen
EPUB herunterladen
.epub eignet sich ideal zum Lesen auf Smartphones, Tablets und E-Readern.