Currying ist ein leistungsstarkes Konzept in der funktionalen Programmierung, das eine Funktion mit mehreren Argumenten in eine Folge von Funktionen umwandelt, die jeweils ein einzelnes Argument annehmen. Diese Technik ermöglicht einen modulareren und wiederverwendbareren Code. In JavaScript kann Currying auf verschiedene Arten implementiert werden. In diesem Blog wird Currying untersucht, Beispiele bereitgestellt und verschiedene Methoden zur Erzielung eines argumentativen Curryings erörtert.

Was ist Curry?

Currying ist der Prozess der Konvertierung einer Funktion, die mehrere Argumente annimmt, in eine Reihe von Funktionen, die jeweils ein einzelnes Argument annehmen. Beispielsweise kann eine Funktion f(a, b, c) in f(a)(b)(c) umgewandelt werden.

Warum Curry verwenden?

• Teilweise Anwendung: Mit Currying können Sie einige Argumente einer Funktion korrigieren und eine neue Funktion erstellen.
• Funktionen höherer Ordnung: Es erleichtert die Verwendung von Funktionen höherer Ordnung, die andere Funktionen als Argumente annehmen oder zurückgeben.
• Code-Wiederverwendbarkeit: Curry-Funktionen sind besser wiederverwendbar und zusammensetzbar.
• Funktionale Komposition: Currying ermöglicht eine bessere funktionale Komposition, bei der komplexe Funktionen durch die Kombination einfacherer Funktionen erstellt werden, was zu saubererem und besser wartbarem Code führt.

Einfaches Curry-Beispiel

Beginnen wir mit einem einfachen Beispiel, um zu verstehen, wie Curry funktioniert.

Uncurried-Funktion

Hier ist eine einfache Funktion, die drei Zahlen hinzufügt:

function add(a, b, c) {
  return a   b   c;
}

console.log(add(1, 2, 3)); // Output: 6

Erklärung: Diese Funktion add nimmt drei Argumente a, b und c und gibt deren Summe zurück. Wenn wir add(1, 2, 3) aufrufen, wird 6 zurückgegeben.

Curry-Funktion

Jetzt wandeln wir diese Funktion in eine Curry-Version um:

function curryAdd(a) {
  return function(b) {
    return function(c) {
      return a   b   c;
    };
  };
}

console.log(curryAdd(1)(2)(3)); // Output: 6

Erläuterung: Die curryAdd-Funktion akzeptiert ein Argument a und gibt eine Funktion zurück, die ein Argument b akzeptiert, die wiederum eine Funktion zurückgibt, die ein Argument c akzeptiert. Die letzte Funktion gibt die Summe von a, b und c zurück. Wenn wir curryAdd(1)(2)(3) aufrufen, übergibt es nacheinander die Argumente 1, 2 und 3 durch die verschachtelten Funktionen, was zu 6 führt.

Currying mit Pfeilfunktionen

Die Pfeilfunktionen von JavaScript bieten eine übersichtliche Möglichkeit, Curry-Funktionen zu erstellen.

const curryAddArrow = a => b => c => a   b   c;

console.log(curryAddArrow(1)(2)(3)); // Output: 6

Erklärung: Die curryAddArrow-Funktion ist eine Pfeilfunktion, die ein Argument a annimmt und eine andere Pfeilfunktion zurückgibt, die b annimmt, die wiederum eine weitere Pfeilfunktion zurückgibt, die c annimmt. Die letzte Pfeilfunktion gibt die Summe von a, b und c zurück. Wenn wir curryAddArrow(1)(2)(3) aufrufen, werden die Argumente 1, 2 und 3 nacheinander durch die verschachtelten Pfeilfunktionen übergeben, was zu 6 führt.

Anwendungsfall

1.Konfigurationsfunktionen

Ein häufiger Anwendungsfall für Currying sind Konfigurationsfunktionen. Stellen Sie sich zum Beispiel vor, Sie erstellen ein Protokollierungsdienstprogramm, bei dem Sie die Protokollierungsebene und das Nachrichtenformat separat konfigurieren möchten.

function logger(level) {
  return function (message) {
    console.log(`[${level}] ${message}`);
  };
}

const infoLogger = logger('INFO');
const errorLogger = logger('ERROR');

infoLogger('This is an info message');
errorLogger('This is an error message');

2. String-Formatierer

Betrachten wir ein praktisches Beispiel, bei dem Currying zum Erstellen eines String-Formatierers verwendet werden kann. Mit diesem Formatierer können Sie Präfix und Suffix separat konfigurieren.

function formatter(prefix) {
  return function (suffix) {
    return function (str) {
      return `${prefix}${str}${suffix}`;
    };
  };
}

const htmlFormatter = formatter('')('');
console.log(htmlFormatter('Hello')); // Hello

const parensFormatter = formatter('(')(')');
console.log(parensFormatter('123')); // (123)

Currying in modernen JavaScript-Bibliotheken

Currying wird häufig in modernen JavaScript-Bibliotheken wie Lodash und Ramda verwendet. In Lodash können Sie beispielsweise die Methode _.curry verwenden, um Curry-Funktionen einfach zu erstellen.

const _ = require('lodash');

function multiply(a, b, c) {
  return a * b * c;
}

const curriedMultiply = _.curry(multiply);

console.log(curriedMultiply(2)(3)(4)); // 24
console.log(curriedMultiply(2, 3)(4)); // 24

Currying mit N Argumenten

Sehen wir uns das folgende Beispiel für Currying mit einer rekursiven Funktion an, die n Argumente hinzufügt. Wir werden Currying verwenden, um eine Funktion zu erstellen, die eine beliebige Anzahl von Argumenten einzeln akzeptieren und diese addieren kann.

function curryAddition(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    } else {
      return function(...nextArgs) {
        return curried(...args, ...nextArgs);
      };
    }
  };
}

// This function sums an array of numbers
function add(...nums) {
  return nums.reduce((acc, num) => acc   num, 0);
}

// Creating a curried version of the addition function
const curriedAdd = curryAddition(add);

// Function to handle n arguments
function curriedAddN(...initialArgs) {
  function adder(...args) {
    if (args.length === 0) {
      return curriedAdd(...initialArgs);
    }
    initialArgs.push(...args);
    return adder;
  }
  return adder;
}

// Examples
const addFiveNumbers = curriedAddN();
console.log(addFiveNumbers(1)(2)(3)(4)(5)()); // 15

const addThreeNumbers = curriedAddN(1)(2)(3);
console.log(addThreeNumbers()); // 6

const addNumbersInSteps = curriedAddN(1, 2)(3)(4, 5);
console.log(addNumbersInSteps()); // 15

Abschluss

Currying ist eine leistungsstarke Technik in der funktionalen Programmierung, die die Modularität und Wiederverwendbarkeit von Code verbessert. Durch die Umwandlung von Funktionen in Ketten von Einzelargumentfunktionen ermöglicht Currying eine teilweise Anwendung und eine flexible Funktionskomposition. Ob für Konfiguration, String-Formatierung oder komplexe Berechnungen, Currying kann Ihren Code ausdrucksvoller und anpassungsfähiger machen.