JavaScript Academy · Lektion

Funktionen curryen

Transformieren Sie Funktionen mit mehreren Argumenten in Verkettungen.

Funktionen curryen ist eine kostenlose JavaScript Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des JavaScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der JavaScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Currying

Currying wandelt eine Funktion, die viele Argumente entgegennimmt, in eine Folge von Funktionen um, die jeweils ein Argument entgegennehmen.

Statt add(1, 2, 3) rufen Sie add(1)(2)(3) auf. Jeder Aufruf gibt die nächste Funktion zurück, bis alle Argumente gesammelt sind.

Currying von Hand

Am klarsten lässt sich Currying verstehen, indem Sie verschachtelte Funktionen schreiben, von denen jede die nächste zurückgibt und die zuvor übergebenen Argumente einschließt.

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

console.log(add(1)(2)(3));

Verschachtelte Rückgaben mit Pfeilfunktionen

Pfeilfunktionen machen Definitionen mit Currying kürzer. Jeder => gibt den nächsten Pfeil zurück, und der letzte führt die eigentliche Arbeit aus.

const add = a => b => c => a + b + c;

console.log(add(1)(2)(3));
console.log(add(10)(20)(30));

Closures merken sich Argumente

Currying basiert auf Closures. Jede zurückgegebene Funktion behält einen Verweis auf die Variablen aus ihrem äußeren Gültigkeitsbereich. Dadurch bleiben frühere Argumente verfügbar, bis der letzte Aufruf ausgeführt wird.

const greet = greeting => name => greeting + ', ' + name + '!';

const sayHi = greet('Hi');
console.log(sayHi('Ada'));
console.log(sayHi('Grace'));

Schrittweise aufrufen

Sie müssen nicht alle Argumente auf einmal anwenden. Sie können zwischendurch aufhören und das Teilergebnis zur Wiederverwendung in einer Variablen speichern.

const add = a => b => c => a + b + c;

const addOne = add(1);
const addOneAndTwo = addOne(2);

console.log(addOneAndTwo(3));
console.log(addOneAndTwo(100));

Eine generische curry-Hilfsfunktion

Verschachtelte Funktionen von Hand zu schreiben ist mühsam. Eine generische curry-Hilfsfunktion sammelt Argumente, bis sie genug hat, und ruft dann die ursprüngliche Funktion auf.

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...more) => curried(...args, ...more);
  };
}

const add = curry((a, b, c) => a + b + c);
console.log(add(1)(2)(3));

Flexibles Aufrufen mit curry

Ein guter curry-Helfer akzeptiert Argumente in beliebiger Gruppierung. fn.length gibt an, wie viele Parameter die ursprüngliche Funktion deklariert hat.

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn(...args);
    }
    return (...more) => curried(...args, ...more);
  };
}

const add = curry((a, b, c) => a + b + c);
console.log(add(1, 2, 3));
console.log(add(1, 2)(3));
console.log(add(1)(2, 3));

Currying zur Spezialisierung

Currying macht Spezialisierung ganz natürlich: Wenden Sie das erste Argument an und verwenden Sie die zurückgegebene Funktion für viele Aufrufe wieder.

const multiply = a => b => a * b;

const double = multiply(2);
const triple = multiply(3);

console.log(double(5));
console.log(triple(5));

Currying mit Array-Methoden

Curried Functions lassen sich perfekt in map und filter einsetzen, weil jede eine Funktion mit einem Argument erzeugt, die bereit ist, jeweils ein Element zu empfangen.

const greaterThan = min => value => value > min;

const over10 = greaterThan(10);
console.log([5, 12, 8, 20].filter(over10));

Currying vs. partielle Anwendung

Partielle Anwendung legt einige Argumente fest und lässt die übrigen für einen späteren Aufruf offen. Currying zerlegt eine Funktion immer in eine Kette von Aufrufen mit jeweils einem Argument.

Currying ist eine bestimmte, vollständig zerlegte Form der partiellen Anwendung.

const partial = (a, b) => c => a + b + c;
const curried = a => b => c => a + b + c;

console.log(partial(1, 2)(3));
console.log(curried(1)(2)(3));

Warum Currying?

Currying fördert kleine, kombinierbare und wiederverwendbare Funktionen. Es passt besonders gut zur Funktionskomposition, die Sie als Nächstes erkunden werden. Die wichtigste Erkenntnis: Eine curried Function ist nie „unvollständig“, sondern gibt einfach so lange eine weitere Funktion zurück, bis alle Argumente vorliegen.

const tag = name => content => '<' + name + '>' + content + '</' + name + '>';

const bold = tag('b');
console.log(bold('important'));
console.log(tag('i')('slanted'));

Kurzer Test

Was ergibt add(1)(2) bei const add = a => b => c => a + b + c;?

Zusammenfassung: Currying

Sie haben gelernt, Funktionen in Ketten aus Aufrufen mit jeweils einem Argument zu zerlegen:

Curried Functions geben über Closures für jedes Argument eine neue Funktion zurück.
Verschachtelte Pfeilfunktionen ermöglichen kompakte Curried-Definitionen.
Ein allgemeiner curry-Helfer verwendet fn.length, um zu erkennen, wann genügend Argumente eingetroffen sind.
Currying ermöglicht saubere Spezialisierung und Komposition.

Häufig gestellte Fragen

Ist die Lektion „Funktionen curryen“ kostenlos?

Ja — der vollständige Text von „Funktionen curryen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des JavaScript Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der JavaScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Funktionen curryen“?

Transformieren Sie Funktionen mit mehreren Argumenten in Verkettungen. Du übst JavaScript Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um JavaScript Academy zu starten?

Keine Vorkenntnisse erforderlich. JavaScript Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Funktionen curryen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser JavaScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede JavaScript Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu JavaScript Academy