TypeScript Academy · Lektion

Currying und partielle Anwendung

Transformieren Sie Funktionen mit mehreren Argumenten in Curry-Formen.

Currying und partielle Anwendung ist eine kostenlose TypeScript 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 TypeScript Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der TypeScript Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Currying?

Currying wandelt eine Funktion mit mehreren Argumenten in eine Kette von Funktionen mit jeweils einem Argument um. Statt f(a, b) rufen Sie f(a)(b) auf.

Das klassische Beispiel

Hier nimmt add eine Zahl entgegen und gibt eine Funktion zurück, die auf die nächste wartet. TypeScript leitet die verschachtelten Funktionstypen automatisch ab.

const add = (a: number) => (b: number) => a + b;
console.log(add(2)(3)); // 5

Eine Curry-Funktion typisieren

Der explizite Typ macht die Kette deutlich: eine Funktion, die eine Funktion zurückgibt. Jeder Pfeil entspricht einem Argument.

type Add = (a: number) => (b: number) => number;
const add: Add = a => b => a + b;
console.log(add(10)(5)); // 15

Partielle Anwendung

Bei der partiellen Anwendung legen Sie einige Argumente jetzt fest und übergeben den Rest später. Bei einer Curry-Funktion bedeutet das einfach, sie mit weniger Schritten aufzurufen.

const add = (a: number) => (b: number) => a + b;
const add10 = add(10); // partially applied
console.log(add10(1), add10(2)); // 11 12

Warum partielle Anwendung hilft

Sie können aus allgemeinen Funktionen spezialisierte Funktionen erstellen. add10 ist ein wiederverwendbares, benanntes Werkzeug, das aus dem generischen add abgeleitet wurde, und verbessert Lesbarkeit und Wiederverwendung.

Currying mit drei Argumenten

Das Muster lässt sich auf beliebige Stelligkeiten erweitern. Jede Ebene erfasst ein Argument in einer Closure, bis der endgültige Wert erzeugt wird.

const clamp = (min: number) => (max: number) => (x: number) =>
  Math.min(Math.max(x, min), max);
const toByte = clamp(0)(255);
console.log(toByte(300), toByte(-5)); // 255 0

Ideal für map und filter

Curry-Funktionen lassen sich nahtlos in Array-Methoden einsetzen, da map eine Funktion mit einem Argument erwartet. Partielle Anwendung erzeugt genau eine solche Funktion.

const mul = (a: number) => (b: number) => a * b;
const triple = mul(3);
console.log([1, 2, 3].map(triple)); // [3, 6, 9]

Ein generischer Curry-Helfer

Sie können einen typisierten Helfer schreiben, der eine Funktion mit zwei Argumenten in eine Curry-Funktion umwandelt. Generics halten die Parameter- und Rückgabetypen präzise.

function curry2<A, B, R>(f: (a: A, b: B) => R) {
  return (a: A) => (b: B) => f(a, b);
}
const join = curry2((a: string, b: string) => a + b);
console.log(join("foo")("bar")); // foobar

Closures erfassen Argumente

Currying funktioniert, weil jede zurückgegebene Funktion die früheren Argumente einfängt. Diese Werte bleiben erhalten, bis der letzte Aufruf sie verwendet.

const greet = (greeting: string) => (name: string) =>
  greeting + ", " + name;
const hi = greet("Hi");
console.log(hi("Sam")); // Hi, Sam

Wann Sie kein Currying verwenden sollten

Jede Funktion zu curryen kann die Lesbarkeit beeinträchtigen. Verwenden Sie Currying, wenn partielle Anwendung wirklich nützlich ist, etwa zum Konfigurieren wiederverwendbarer Helfer oder zum Zusammensetzen von Pipelines.

Currying vs. Standardargumente

Standardparameter liefern Standardwerte, aber keine schrittweise Anwendung. Currying ermöglicht echte partielle Anwendung: Es gibt eine echte Funktion zurück, die Sie weitergeben und wiederverwenden können.

Kurztest

Kurzer Test zu dieser Lektion.

Zusammenfassung

Currying wandelt f(a, b) in f(a)(b) um, also in eine Kette von Funktionen mit einem Argument, die als verschachtelte Pfeiltypen typisiert sind. Bei der partiellen Anwendung werden anschließend führende Argumente festgelegt, um mithilfe von Closures wiederverwendbare spezialisierte Funktionen zu erstellen.

Häufig gestellte Fragen

Ist die Lektion „Currying und partielle Anwendung“ kostenlos?

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

Was lerne ich in „Currying und partielle Anwendung“?

Transformieren Sie Funktionen mit mehreren Argumenten in Curry-Formen. Du übst TypeScript 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 TypeScript Academy zu starten?

Keine Vorkenntnisse erforderlich. TypeScript 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 „Currying und partielle Anwendung“?

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 TypeScript Academy-Lektion Code schreiben und ausführen?

Ja. Jede TypeScript 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 TypeScript Academy