Ein Anfängerhandbuch zum Currying im funktionalen JavaScript

Currying oder teilweise Anwendung ist eine der funktionalen Techniken, die für Menschen, die mit traditionelleren Arten zum Schreiben von JavaScript vertraut sind, verwirrend klingen können. Wenn Sie jedoch ordnungsgemäß angewendet werden, kann es Ihr funktionales JavaScript tatsächlich lesbarer machen.

Key Takeaways

• Currying ist eine funktionale Programmierungstechnik, die die teilweise Anwendung der Argumente einer Funktion ermöglicht. Dies bedeutet, dass Sie alle oder eine Teilmenge der Argumente übergeben können, die eine Funktion erwartet. Wenn eine Untergruppe übergeben wird, wird eine Funktion zurückgegeben, die auf die verbleibenden Argumente wartet.
• Currying kann JavaScript -Code lesbarer und flexibler machen. Es ermöglicht die Erstellung einer Bibliothek kleiner, leicht konfigurierter Funktionen, die sich konsequent verhalten, schnell zu verwenden sind und beim Lesen Ihres Codes verstanden werden können.
• Die Reihenfolge der Argumente ist wichtig beim Currying. Das Argument, das am wahrscheinlichsten durch eine Variation zu einer anderen ersetzt wird, sollte das letzte Argument sein, das an die ursprüngliche Funktion übergeben wird.
• Einige funktionale JavaScript -Bibliotheken wie RAMDA bieten flexible Currying -Funktionen an, die die für eine Funktion erforderlichen Parameter ausbrechen und es Ihnen ermöglichen, sie einzeln oder in Gruppen zu übergeben, um benutzerdefinierte Curry -Variationen zu erstellen. Wenn Sie vorhaben, das Currying ausgiebig zu verwenden, wird die Verwendung solcher Bibliotheken empfohlen.

lesbarer und flexibler

Einer der Vorteile, die für funktionales JavaScript angepriesen werden, ist kürzerer, engerer Code, der in den wenigsten Zeilen und weniger Wiederholung auf den Punkt gerecht wird. Manchmal kann dies auf Kosten der Lesbarkeit erfolgen; Bis Sie mit der Art und Weise vertraut sind, wie die funktionale Programmierung funktioniert, kann der Code auf diese Weise schwieriger zu lesen und zu verstehen sein.

Wenn Sie zuvor auf den Begriff Currying gestoßen sind, aber nie wussten, was es bedeutete, können Sie es als eine exotische, würzige Technik vergeben, die Sie sich nicht darum kümmern mussten. Aber Currying ist eigentlich ein sehr einfaches Konzept und behandelt einige bekannte Probleme beim Umgang mit Funktionsargumenten und wird eine Reihe flexibler Optionen für den Entwickler eröffnet.

Was ist Currying?

Kurz gesagt, Currying ist eine Möglichkeit, Funktionen zu konstruieren, die die teilweise Anwendung der Argumente einer Funktion ermöglicht. Dies bedeutet, dass Sie alle Argumente übergeben können, die eine Funktion erwartet und das Ergebnis erzielen oder eine Untergruppe dieser Argumente übergeben und eine Funktion zurückbekommen, die auf den Rest der Argumente wartet. Es ist wirklich so einfach.

Currying ist in Sprachen wie Haskell und Scala elementar, die auf funktionalen Konzepten basieren. JavaScript verfügt über funktionale Funktionen, aber das Currying wird standardmäßig nicht integriert (zumindest nicht in aktuellen Versionen der Sprache). Aber wir kennen bereits einige funktionale Tricks und können auch in JavaScript Currying für uns funktionieren.

Um Ihnen ein Gefühl dafür zu geben, wie dies funktionieren könnte, erstellen wir unsere erste Curry -Funktion in JavaScript, wobei die bekannte Syntax die gewünschte Currying -Funktionalität aufbaut. Stellen wir uns beispielsweise eine Funktion vor, die jemanden mit Namen begrüßt. Wir alle wissen, wie man eine einfache Grußfunktion erstellt, die einen Namen und einen Gruß annimmt, und protokolliert den Begrüßung mit dem Namen in die Konsole:

var greet = function(greeting, name) {
  console.log(greeting + ", " + name);
};
greet("Hello", "Heidi"); //"Hello, Heidi"

Diese Funktion erfordert, dass sowohl der Name als auch der Gruß als Argumente übergeben werden, um ordnungsgemäß zu arbeiten. Aber wir könnten diese Funktion mit einem einfachen verschachtelten Currying umschreiben, damit die Grundfunktion nur eine Begrüßung erfordert, und sie gibt eine andere Funktion zurück, die den Namen der Person nimmt, die wir begrüßen möchten.

Unser erstes Curry

var greetCurried = function(greeting) {
  return function(name) {
    console.log(greeting + ", " + name);
  };
};

Diese winzige Anpassung an die Art und Weise, wie wir die Funktion geschrieben haben

var greetHello = greetCurried("Hello");
greetHello("Heidi"); //"Hello, Heidi"
greetHello("Eddie"); //"Hello, Eddie"

wir können auch die ursprüngliche Curry -Funktion direkt aufrufen

Warum probieren Sie dies nicht in Ihrem Browser aus?

greetCurried("Hi there")("Howard"); //"Hi there, Howard"

Curry alle Dinge!

Das Coole ist, jetzt, da wir gelernt haben, wie wir unsere traditionelle Funktion ändern können, um diesen Ansatz für den Umgang mit Argumenten zu verwenden, können wir dies mit so vielen Argumenten tun, wie wir es wollen:

Wir haben die gleiche Flexibilität mit vier Argumenten wie mit zwei. Unabhängig davon, wie weit das Verschachteln geht, können wir neue benutzerdefinierte Funktionen erstellen, um so viele Menschen zu begrüßen, wie wir uns auf so viele Arten entscheiden wie zu unseren Absichten:

var greetDeeplyCurried = function(greeting) {
  return function(separator) {
    return function(emphasis) {
      return function(name) {
        console.log(greeting + separator + name + emphasis);
      };
    };
  };
};

Darüber hinaus können wir so viele Parameter übergeben, wie wir es mögen, wenn wir benutzerdefinierte Variationen in unserer ursprünglichen Curry -Funktion erstellen und neue Funktionen erstellen, die die entsprechende Anzahl zusätzlicher Parameter aufnehmen können, die jeweils in einem eigenen Satz von Klammern getrennt übergeben werden:

var greetAwkwardly = greetDeeplyCurried("Hello")("...")("?");
greetAwkwardly("Heidi"); //"Hello...Heidi?"
greetAwkwardly("Eddie"); //"Hello...Eddie?"

Und wir können untergeordnete Variationen genauso leicht definieren:

var sayHello = greetDeeplyCurried("Hello")(", ");
sayHello(".")("Heidi"); //"Hello, Heidi."
sayHello(".")("Eddie"); //"Hello, Eddie."

Currying traditionelle Funktionen

var askHello = sayHello("?");
askHello("Heidi"); //"Hello, Heidi?"
askHello("Eddie"); //"Hello, Eddie?"

Sie können sehen, wie mächtig dieser Ansatz ist, insbesondere wenn Sie viele sehr detaillierte benutzerdefinierte Funktionen erstellen müssen. Das einzige Problem ist die Syntax. Während Sie diese Curry -Funktionen aufbauen, müssen Sie die zurückgegebenen Funktionen weiter nisten und sie mit neuen Funktionen aufrufen, die mehrere Sätze von Klammern erfordern, die jeweils ein eigenes isoliertes Argument enthalten. Es kann chaotisch werden.

Um dieses Problem anzugehen, besteht ein Ansatz darin, eine schnelle und schmutzige Currying -Funktion zu erstellen, die den Namen einer vorhandenen Funktion nimmt, die ohne alle verschachtelten Renditen geschrieben wurde. Eine Currying -Funktion müsste die Liste der Argumente für diese Funktion herausziehen und diese verwenden, um eine Curry -Version der ursprünglichen Funktion zurückzugeben:

var greet = function(greeting, name) {
  console.log(greeting + ", " + name);
};
greet("Hello", "Heidi"); //"Hello, Heidi"

Um dies zu verwenden, übergeben wir ihm den Namen einer Funktion, die eine beliebige Anzahl von Argumenten enthält, zusammen mit so vielen Argumenten, wie wir uns vorentwickeln möchten. Was wir zurückbekommen, ist eine Funktion, die auf die verbleibenden Argumente wartet:

var greetCurried = function(greeting) {
  return function(name) {
    console.log(greeting + ", " + name);
  };
};

Und wie zuvor sind wir in Bezug auf die Anzahl der Argumente, die wir bei der Erstellung der Ableitungsfunktionen aus unserer ursprünglichen Funktion von Curry verwenden, nicht eingeschränkt:

:

var greetHello = greetCurried("Hello");
greetHello("Heidi"); //"Hello, Heidi"
greetHello("Eddie"); //"Hello, Eddie"

ernsthaft mit Currying

ernst werden

Unsere kleine Currying -Funktion kann möglicherweise nicht alle Randfälle wie fehlende oder optionale Parameter verarbeiten, aber sie leistet eine vernünftige Arbeit, solange wir die Syntax für das Übergeben von Argumenten streng bleiben.

Einige funktionale JavaScript -Bibliotheken wie RAMDA verfügen über flexiblere Currying -Funktionen, die die für eine Funktion erforderlichen Parameter ausbrechen und es Ihnen ermöglichen, sie einzeln oder in Gruppen zu übergeben, um benutzerdefinierte Curry -Variationen zu erstellen. Wenn Sie Currying ausgiebig verwenden möchten, ist dies wahrscheinlich der richtige Weg.

unabhängig davon, wie Sie Ihre Programmierung Currying hinzufügen möchten, unabhängig davon lesbarer. Jede abgeleitete Variation einer Funktion sollte einen Namen haben, der deutlich macht, wie sie sich verhält und welche Argumente es erwartet.

Argumentreihenfolge

Eine Sache, die beim Currying wichtig ist, ist die Reihenfolge der Argumente. Mit dem von uns beschriebenen Ansatz möchten Sie offensichtlich das Argument, dass Sie am wahrscheinlichsten von einer Variation zum nächsten das letzte Argument ersetzen, das an die ursprüngliche Funktion übergeben wird.

Nachdenken über die Argumentationsreihenfolge erleichtert es, das Currying zu planen und sie auf Ihre Arbeit anzuwenden. Und wenn man die Reihenfolge Ihrer Argumente in Bezug auf die Wahrscheinlichkeit, dass sie am wahrscheinlichsten zu ändert

Schlussfolgerung

Currying ist eine unglaublich nützliche Technik aus funktionalem JavaScript. Sie können eine Bibliothek kleiner, leicht konfigurierter Funktionen generieren, die sich konsequent verhalten, schnell zu verwenden, und die beim Lesen Ihres Codes verstanden werden können. Das Hinzufügen von Currying zu Ihrer Codierungspraxis fördert die Verwendung teilweise angewandter Funktionen im gesamten Code, vermeidet eine Menge potenzieller Wiederholung und kann dazu beitragen, dass Sie in bessere Gewohnheiten über die Benennung und den Umgang mit Funktionsargumenten führen.

Wenn Sie es genossen haben, mögen Sie diesen Beitrag möglicherweise auch einige der anderen aus der Serie:

• Eine Einführung in den funktionalen JavaScript
• Funktionen höherer Ordnung in JavaScript
• Rekursion im funktionalen JavaScript

häufig gestellte Fragen (FAQs) zum Currying im funktionalen JavaScript

Was ist der Hauptunterschied zwischen Currying und teilweise Anwendung in JavaScript? Sie unterscheiden sich jedoch in ihrer Umsetzung und Verwendung. Currying ist ein Prozess in der funktionalen Programmierung, bei dem eine Funktion mit mehreren Argumenten in eine Abfolge von Funktionen umgewandelt wird, die jeweils ein einzelnes Argument haben. Andererseits bezieht sich eine teilweise Anwendung auf den Prozess der Festlegung einer Reihe von Argumenten auf eine Funktion und erzeugt eine weitere Funktion kleinerer Arität. Während das Currying immer verschachtelte Unarm (1-Arity-) Funktionen erzeugt, kann teilweise Anwendung Funktionen einer Arität erzeugen. Lesbarkeit und Wartbarkeit in JavaScript. Durch das Aufschlachen komplexer Funktionen in einfachere, unartige Funktionen macht Currying den Code lesbarer und einfacher zu verstehen. Es fördert auch sauberere und modularere Code, da jede Funktion eine einzelne Aufgabe ausführt. Diese Modularität erleichtert den Code leichter zu warten und zu debuggen, da Probleme auf bestimmte Funktionen isoliert werden können. Eine Funktion, die drei Zahlen hinzufügt. Ohne Currying könnte die Funktion so aussehen:

Funktion add (a, b, c) {

zurück A B C;

}

console.log (add (1, 2, 3 )); // Ausgänge: 6

Mit Currying würde dieselbe Funktion wie folgt geschrieben:

Funktion hinzufügen (a) {

Rückgabefunktion (b) {
Rückgabefunktion (C) ) {
return a b c;
}
}
}
console.log (1) (2) (3)); // Ausgänge: 6

Was sind die Einschränkungen oder Nachteile der Verwendung von Currying in JavaScript? Einer der Hauptnachteile ist, dass der Code für diejenigen, die mit dem Konzept nicht vertraut sind, schwieriger zu verstehen können, insbesondere wenn es sich um Funktionen mit einer großen Anzahl von Argumenten befasst. Es kann auch zu einer Leistungsaufwand aufgrund der Schaffung zusätzlicher Schließungen führen. Darüber hinaus kann es Funktionen für Funktionsberichte machen, da jedes Argument in einem separaten Satz von Klammern übergeben werden muss. im Zusammenhang mit dem Konzept der Funktionen höherer Ordnung in JavaScript. Eine Funktion höherer Ordnung ist eine Funktion, die eine oder mehrere Funktionen als Argumente nimmt, eine Funktion als Ergebnis oder beides zurückgibt. Da Currying eine Funktion in eine Folge von Funktionsaufrufen umwandelt, beinhaltet es von Natur aus die Verwendung von Funktionen höherer Ordnung.

Kann Currying mit Pfeilfunktionen in JavaScript verwendet werden? Tatsächlich macht die Syntax der Pfeilfunktionen sie besonders gut für das Currying geeignet. So kann die vorherige Funktion mit Pfeilfunktionen geschrieben werden:

const add = a => b => c => a b c;
console.log (add (1) (2) (3) ); // Ausgänge: 6

Wird Currying in beliebten JavaScript -Bibliotheken oder Frameworks verwendet? Zum Beispiel ist es ein grundlegendes Konzept in Bibliotheken wie Ramda und Lodash, die Dienstprogrammfunktionen für die funktionale Programmierung in JavaScript bereitstellen. Es wird auch in Redux verwendet, einer beliebten staatlichen Verwaltungsbibliothek für Reaktionen. Funktionszusammensetzung ist der Prozess der Kombination von zwei oder mehr Funktionen, um eine neue Funktion zu erstellen. Da Currying es Ihnen ermöglicht, unäre Funktionen zu erstellen, vereinfacht es die Funktionszusammensetzung, indem sichergestellt wird, dass jede Funktion genau einen Eingang und einen Ausgang hat. Funktion mit zwei oder mehr Argumenten kann gestrichen werden. In der Praxis ist es jedoch möglicherweise nicht immer praktisch oder vorteilhaft, eine Funktion zu curry. Zum Beispiel ist das Currying möglicherweise nicht nützlich für Funktionen, die zu unterschiedlichen Zeiten mit unterschiedlichen Argumenten aufgerufen werden müssen. Ihr Code lesbarer und modularer, er kann auch einen leichten Einfluss auf die Leistung haben. Dies liegt daran, dass Sie jedes Mal, wenn Sie eine Funktion curry, neue Verschlüsse erstellen. In den meisten Fällen ist die Auswirkungen auf die Leistung jedoch vernachlässigbar und überwogen durch die Vorteile einer verbesserten Code -Lesbarkeit und -wartbarkeit.

Das obige ist der detaillierte Inhalt vonEin Anfängerhandbuch zum Currying im funktionalen JavaScript. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!