Scala til backendudvikling og funktionel programmering · Lektion

Komposition

andThen og compose

Lektion 3 af 413 trin

Komposition er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Scala til backendudvikling og funktionel programmering, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Scala til backendudvikling og funktionel programmering-kurset indeholder 4 lektioner i alt.

Kombinering af funktioner

Funktionssammensætning betyder, at du opbygger en ny funktion ved at forbinde to eksisterende funktioner, så outputtet fra den ene bliver inputtet til den næste. Scala stiller andThen og compose til rådighed til dette.

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val double = (x: Int) => x * 2
    val both = addOne andThen double
    println(both(5))
  }
}

andThen: fra venstre mod højre

f andThen g kører først f og derefter g. Læsning fra venstre mod højre svarer til udførelsesrækkefølgen, hvilket mange finder intuitivt.

(f andThen g)(x) == g(f(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne andThen triple
    println(pipeline(4))  // (4 + 1) * 3
  }
}

compose: fra højre mod venstre

f compose g kører først g og derefter f, altså den matematiske rækkefølge f(g(x)).

(f compose g)(x) == f(g(x))

object Main {
  def main(args: Array[String]): Unit = {
    val addOne = (x: Int) => x + 1
    val triple = (x: Int) => x * 3
    val pipeline = addOne compose triple
    println(pipeline(4))  // (4 * 3) + 1
  }
}

andThen kontra compose

De to er spejlbilleder:

f andThen g = g compose f
f compose g = g andThen f

Vælg den, der læses mest naturligt i din situation.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x + 10
    val g = (x: Int) => x * 2
    println((f andThen g)(3))
    println((g compose f)(3))
  }
}

Kædning af flere funktioner

Du kan kæde mange funktioner sammen med gentagne andThen for at opbygge en længere behandlingskæde, der flyder fra top til bund.

object Main {
  def main(args: Array[String]): Unit = {
    val clean = (s: String) => s.trim
    val lower = (s: String) => s.toLowerCase
    val bang  = (s: String) => s + "!"
    val process = clean andThen lower andThen bang
    println(process("  HELLO  "))
  }
}

Sammensætning ændrer typer

De sammensatte funktioner skal have kompatible typer: Outputtypen fra den første skal svare til inputtypen for den anden. Behandlingskæden kan ændre typer undervejs.

object Main {
  def main(args: Array[String]): Unit = {
    val length = (s: String) => s.length
    val isLong = (n: Int) => n > 5
    val check = length andThen isLong
    println(check("scala"))
    println(check("functional"))
  }
}

Identitetsfunktionen

identity returnerer sit input uændret. Det er det neutrale element i sammensætning: f andThen identity == f. Nyttigt som standardværdi i foldninger og betingelser.

object Main {
  def main(args: Array[String]): Unit = {
    val f = (x: Int) => x * 2
    val same = f andThen identity[Int]
    println(same(7))
  }
}

Sammensætning med reduce

Da funktioner er værdier, kan du gemme flere i en liste og sammensætte dem alle ved hjælp af reduce med andThen.

object Main {
  def main(args: Array[String]): Unit = {
    val steps: List[Int => Int] = List(_ + 1, _ * 2, _ - 3)
    val pipeline = steps.reduce(_ andThen _)
    println(pipeline(5))  // ((5+1)*2)-3
  }
}

Opbygning af genanvendelige behandlingskæder

Sammensætning fremmer små funktioner med ét formål, som du samler til større funktionalitet – en central idé i funktionel programmering.

object Main {
  def main(args: Array[String]): Unit = {
    val sanitize = (s: String) => s.trim.toLowerCase
    val capitalize = (s: String) => s.capitalize
    val format = sanitize andThen capitalize
    println(format("  aLiCe "))
  }
}

Sammensætning med map

En sammensat funktion er bare en funktion, så du kan give den direkte til map for at anvende hele behandlingskæden på en samling.

object Main {
  def main(args: Array[String]): Unit = {
    val transform = ((x: Int) => x + 1) andThen ((x: Int) => x * x)
    println(List(1, 2, 3).map(transform))
  }
}

Læs rækkefølgen i sammensætningen omhyggeligt

En almindelig fejl er at forveksle andThen og compose. Husk altid: andThen = først denne, derefter hin; compose = omvendt.

object Main {
  def main(args: Array[String]): Unit = {
    val inc = (x: Int) => x + 1
    val sqr = (x: Int) => x * x
    println((inc andThen sqr)(2))  // (2+1)^2 = 9
    println((inc compose sqr)(2))  // (2^2)+1 = 5
  }
}

Hurtigt tjek

Givet f og g, hvad beregner (f andThen g)(x)?

Besvar den i den interaktive lektion

Opsummering

Du har lært om funktionssammensætning:

f andThen g → g(f(x)) (fra venstre mod højre)
f compose g → f(g(x)) (fra højre mod venstre)
De er spejlbilleder af hinanden
identity er det neutrale element
Sammensæt lister af funktioner med reduce(_ andThen _)

Gratis at komme i gang

Lær Scala 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: 39
Lektioner: 143

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Komposition” gratis?

Ja — hele teksten til “Komposition” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Scala til backendudvikling og funktionel programmering-kurset, skal du opgradere til CoddyKit PRO. Scala til backendudvikling og funktionel programmering-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Komposition”?

andThen og compose Du øver dig i Scala til backendudvikling og funktionel programmering 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å Scala til backendudvikling og funktionel programmering?

Der kræves ingen tidligere erfaring. Scala til backendudvikling og funktionel programmering 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 3 af 4.

Hvor lang tid tager lektionen “Komposition”?

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 Scala til backendudvikling og funktionel programmering-lektion?

Ja. Alle Scala til backendudvikling og funktionel programmering-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 Scala til backendudvikling og funktionel programmering