TypeScript Academy · Lektion

Funktionskomposition med typer

Komponera funktioner och bevara typsäkerheten.

Lektion 3 av 413 steg

Funktionskomposition med typer är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad är komposition?

Funktionskomposition kombinerar små funktioner till en större. compose(f, g) skapar en funktion som först tillämpar g och sedan skickar resultatet till f.

Den grundläggande definitionen

Matematiskt gäller compose(f, g)(x) = f(g(x)). Funktionerna körs från höger till vänster: funktionen längst till höger körs först.

const compose = (f: (n: number) => number, g: (n: number) => number) =>
  (x: number) => f(g(x));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
console.log(compose(inc, dbl)(5)); // 11 (5*2 then +1)

Ordning från höger till vänster

Ordningen spelar roll. compose(inc, dbl) dubblar först och ökar sedan, medan compose(dbl, inc) ökar först. Läs kompositionen inifrån och ut.

console.log(compose(dbl, inc)(5)); // 12 (5+1 then *2)

Att typa komposition med generiska typer

Generiska typer gör att indata- och utdatatypen kan skilja sig åt. g mappar A till B, f mappar B till C, och resultatet mappar A till C.

function compose<A, B, C>(f: (b: B) => C, g: (a: A) => B): (a: A) => C {
  return a => f(g(a));
}

Ändra typer längs vägen

Eftersom de generiska typerna bildar kedjan A -> B -> C kan komposition omvandla ett värde genom flera former, till exempel från sträng till tal till sträng.

const length = (s: string) => s.length;
const toStr = (n: number) => "len=" + n;
const describe = compose(toStr, length);
console.log(describe("hello")); // len=5

Typgränsen måste stämma

Resultatet från g måste matcha indata för f. Om de inte stämmer överens avvisar kompilatorn kompositionen och upptäcker felkopplingar tidigt.

// compose(length, toStr) would error:
// toStr returns string, length expects string -> ok here,
// but mismatched pairs are flagged by the compiler.

Komponera tre funktioner

Det går att nästla kompositioner eller skriva en variant med tre argument. Regeln från höger till vänster gäller fortfarande i alla fallen.

const compose3 = <A, B, C, D>(
  f: (c: C) => D, g: (b: B) => C, h: (a: A) => B
) => (a: A): D => f(g(h(a)));
const inc = (n: number) => n + 1;
const dbl = (n: number) => n * 2;
const neg = (n: number) => -n;
console.log(compose3(neg, dbl, inc)(3)); // -8

Komposition bygger pipelines

Genom att komponera små, rena funktioner kan komplexa omvandlingar sättas samman på ett deklarativt sätt. Varje del förblir testbar separat.

const trim = (s: string) => s.trim();
const upper = (s: string) => s.toUpperCase();
const clean = compose(upper, trim);
console.log(clean("  hi ")); // HI

Varför rena funktioner passar bäst för komposition

Komposition förutsätter att varje funktion endast beror på sina indata. Rena funktioner garanterar detta, så när de komponeras bildas ytterligare en förutsägbar, ren funktion.

compose kontra pipe

compose körs från höger till vänster och motsvarar matematisk notation. Många föredrar att läsa från vänster till höger, vilket pipe erbjuder och tas upp härnäst.

Håll delarna små

Komposition fungerar bäst när varje funktion gör en enda liten sak. Små, namngivna och rena steg gör den sammansatta pipelinen självdokumenterande och enkel att ändra ordning på.

Snabb kontroll

En snabb kontroll av den här lektionen.

Besvara frågan i den interaktiva lektionen

Sammanfattning

compose(f, g)(x) = f(g(x)) körs från höger till vänster. Generisk typning bildar kedjan A -> B -> C, så resultatet från g måste matcha indata för f. Därmed kan kompilatorn verifiera pipelinen av små, rena funktioner.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Funktionskomposition med typer” gratis?

Ja – hela texten till ”Funktionskomposition med typer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Funktionskomposition med typer”?

Komponera funktioner och bevara typsäkerheten. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Funktionskomposition med typer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy