Scala til backendudvikling og funktionel programmering · Lektion

Funktionelle operationer på collections

Bliv fortrolig med almindelige funktionelle operationer som map, filter, fold og reduce til datatransformation.

Lektion 2 af 311 trin

Funktionelle operationer på collections er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 2 af 3. 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 3 lektioner i alt.

Funktionelle handlinger: Hvorfor bruge dem?

Funktionelle operationer på samlinger hjælper dig med at transformere og kombinere data uden at ændre den oprindelige samling. Denne tilgang fremmer uforanderlighed og gør din kode lettere at læse og teste.

Vi gennemgår centrale operationer som map, filter, reduce og fold.

Transformér med `map`

Operationen map anvender en funktion på hvert element i en samling og returnerer en ny samling med de transformerede resultater. Den oprindelige samling forbliver uændret.

Prøv at køre dette eksempel:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val doubled = numbers.map(n => n * 2)
    println(s"Original: $numbers")
    println(s"Doubled: $doubled")
  }
}

`map` med forskellige typer

map er meget fleksibel! Du kan transformere elementer til en helt anden type. Her konverterer vi tal til strenge eller henter længden af strenge.

Bemærk, at resultatet er en List[Int], selvom inputtet var List[String].

object Main {
  def main(args: Array[String]): Unit = {
    val names = List("Alice", "Bob", "Charlie")
    val lengths = names.map(name => name.length)
    println(s"Names: $names")
    println(s"Lengths: $lengths")
  }
}

Udvælg med `filter`

Operationen filter opretter en ny samling, der kun indeholder de elementer, som opfylder en given betingelse (en prædikatsfunktion). Den "filtrerer" uønskede elementer fra.

Lad os finde de lige tal:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4, 5, 6)
    val evens = numbers.filter(n => n % 2 == 0)
    println(s"Original: $numbers")
    println(s"Evens: $evens")
  }
}

Flere eksempler med `filter`

Du kan bruge ethvert boolsk udtryk som din filterbetingelse. Lad os filtrere en liste med ord, så kun ord med mere end 4 tegn bevares.

object Main {
  def main(args: Array[String]): Unit = {
    val words = List("apple", "cat", "banana", "dog", "elephant")
    val longWords = words.filter(w => w.length > 4)
    println(s"Words: $words")
    println(s"Long words: $longWords")
  }
}

Kombinér med `reduce`

Operationen reduce kombinerer alle elementer i en samling til ét enkelt resultat. Den tager en binær operation (en funktion, der tager to argumenter og returnerer ét) og anvender den kumulativt.

Her lægger vi alle elementerne sammen:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3, 4)
    val sum = numbers.reduce((a, b) => a + b)
    println(s"Numbers: $numbers")
    println(s"Sum: $sum")
  }
}

`reduce` til produkt og maksimum

reduce kan udføre forskellige aggregeringer. Vi kan beregne produktet af tal eller finde den største værdi.

Bemærk: reduce kaster en fejl på en tom samling.

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 5, 2, 8)
    val product = numbers.reduce((a, b) => a * b)
    val maxNum = numbers.reduce((a, b) => if (a > b) a else b)
    println(s"Numbers: $numbers")
    println(s"Product: $product")
    println(s"Max: $maxNum")
  }
}

`fold`: Den indledende værdi gør forskellen

fold minder om reduce, men har en vigtig forskel: Den tager en indledende værdi (også kaldet en "akkumulator"). Det gør den sikker for tomme samlinger og gør det muligt at bruge forskellige resultatyper.

Lad os lægge tal sammen med udgangspunkt i 10:

object Main {
  def main(args: Array[String]): Unit = {
    val numbers = List(1, 2, 3)
    // foldLeft(initialValue)(operation)
    val sumWithInitial = numbers.foldLeft(10)((acc, n) => acc + n)
    println(s"Numbers: $numbers")
    println(s"Sum (starting from 10): $sumWithInitial")
  }
}

Retning: `foldLeft` vs. `foldRight`

Scala tilbyder foldLeft og foldRight. De adskiller sig i rækkefølgen, elementerne behandles i, og hvordan akkumulatoren videregives.

foldLeft(initial)(op): Behandler fra venstre mod højre.
foldRight(initial)(op): Behandler fra højre mod venstre.

For operationer som sammenkædning af strenge er retningen vigtig!

object Main {
  def main(args: Array[String]): Unit = {
    val chars = List('a', 'b', 'c')
    val leftFold = chars.foldLeft("")((acc, c) => acc + c)
    val rightFold = chars.foldRight("")((c, acc) => acc + c)
    println(s"Chars: $chars")
    println(s"foldLeft: $leftFold") // Output: abc
    println(s"foldRight: $rightFold") // Output: abc (due to string append order)

    // Example where order matters: (acc, char) => char + acc
    val rightFoldReversed = chars.foldRight("")((c, acc) => c + acc)
    println(s"foldRight (char + acc): $rightFoldReversed") // Output: abc

    // A common example where order matters is for operations like subtraction or division, but string concatenation also shows it.
  }
}

Kontrol af funktionelle operationer

Se på følgende Scala-kodestykke:

val data = List(10, 20, 30, 40)
val result1 = data.map(x => x / 10)
val result2 = data.filter(x => x > 25)
val result3 = data.reduce((a, b) => a + b)

Hvilke af følgende udsagn er SANDE om resultaterne?

Besvar den i den interaktive lektion

Opsummering: Styrken ved funktionelle operationer

Du har nu styr på de vigtigste funktionelle operationer!

map transformerer hvert element.
filter udvælger elementer baseret på en betingelse.
reduce kombinerer elementer til ét enkelt resultat (kræver en ikke-tom samling).
fold kombinerer elementer med en indledende værdi (sikker for tomme samlinger).

Disse operationer er afgørende for at skrive kortfattet, uforanderlig og kraftfuld Scala-kode. Nu gennemgår vi robust fejlhåndtering med Option, Try og Either.

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 “Funktionelle operationer på collections” gratis?

Ja — hele teksten til “Funktionelle operationer på collections” 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 3 lektioner i alt.

Hvad lærer jeg i “Funktionelle operationer på collections”?

Bliv fortrolig med almindelige funktionelle operationer som map, filter, fold og reduce til datatransformation. 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 2 af 3.

Hvor lang tid tager lektionen “Funktionelle operationer på collections”?

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