JavaScript Academy · Lektion

Currying af funktioner

Transformér funktioner med flere argumenter til kæder.

Lektion 2 af 413 trin

Currying af funktioner er en gratis JavaScript Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i JavaScript Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. JavaScript Academy-kurset indeholder 4 lektioner i alt.

Hvad er currying

Currying omdanner en funktion, der tager mange argumenter, til en række funktioner, der hver tager ét argument.

I stedet for add(1, 2, 3) kalder du add(1)(2)(3). Hvert kald returnerer den næste funktion, indtil alle argumenter er indsamlet.

Currying i hånden

Den tydeligste måde at se currying på er at skrive indlejrede funktioner, der hver returnerer den næste og indfanger de tidligere argumenter.

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

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

Indlejrede pilefunktioner

Pilefunktioner gør definitioner med currying kortere. Hver => returnerer den næste pilefunktion, og den sidste udfører arbejdet.

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

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

Lukninger husker argumenter

Currying er afhængig af lukninger. Hver returneret funktion beholder en reference til variablerne fra dens ydre område, så tidligere argumenter forbliver tilgængelige, indtil det sidste kald udføres.

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

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

Kald trin for trin

Du behøver ikke anvende alle argumenter på én gang. Du kan stoppe undervejs og gemme det delvise resultat i en variabel, så det kan genbruges.

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

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

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

En generisk curry-hjælpefunktion

Det er besværligt at skrive indlejrede funktioner i hånden. En generisk curry-hjælpefunktion indsamler argumenter, indtil den har nok, og kalder derefter den oprindelige funktion.

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));

Fleksible kald med curry

En god curry-hjælpefunktion accepterer argumenter i enhver gruppering. fn.length fortæller den, hvor mange parametre den oprindelige funktion erklærede.

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 til specialisering

Currying gør specialisering naturlig: anvend det første argument, og genbrug den returnerede funktion i mange kald.

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

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

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

Currying med array-metoder

Curried funktioner passer perfekt ind i map og filter, fordi hver af dem producerer en funktion med ét argument, der er klar til at modtage hvert element.

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

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

Currying kontra partiel anvendelse

Partiel anvendelse fastlåser nogle argumenter og lader resten vente på ét senere kald. Currying opdeler altid en funktion i en kæde af kald med ét argument.

Currying er en specifik, fuldt dekomponeret form for partiel anvendelse.

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));

Hvorfor curry?

Currying opmuntrer til små, komponerbare og genanvendelige funktioner. Det passer naturligt sammen med funktionssammensætning, som du udforsker nu. Den centrale pointe er, at en curried funktion aldrig er 'ufuldstændig'; den returnerer blot en ny funktion, indtil den har fået nok argumenter.

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

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

Hurtigt tjek

Givet const add = a => b => c => a + b + c;, hvad evalueres add(1)(2) til?

Besvar den i den interaktive lektion

Opsummering: currying

Du har lært at dekomponere funktioner til kæder med ét argument:

Curried funktioner returnerer en ny funktion for hvert argument via lukninger.
Indlejrede pilefunktioner giver kompakte definitioner med currying.
En generisk curry-hjælpefunktion bruger fn.length til at vide, hvornår der er kommet nok argumenter.
Currying muliggør ren specialisering og sammensætning.

Gratis at komme i gang

Lær JavaScript med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 59
Lektioner: 200

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Currying af funktioner” gratis?

Ja — alle 3 lektioner i læringssporet JavaScript Academy, inklusive “Currying af funktioner”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. JavaScript Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Currying af funktioner”?

Transformér funktioner med flere argumenter til kæder. Du øver dig i JavaScript Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på JavaScript Academy?

Der kræves ingen tidligere erfaring. JavaScript Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Currying af funktioner”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne JavaScript Academy-lektion?

Ja. Alle JavaScript Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til JavaScript Academy