Scala til backendudvikling og funktionel programmering · Lektion

Funktioner som førsteklasses værdier

Lær at definere og videregive funktioner som argumenter, returnere dem fra andre funktioner og gemme dem i variabler.

Lektion 1 af 311 trin

Funktioner som førsteklasses værdier er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 1 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.

Funktioner som førsteklasses værdier

Velkommen til funktionel programmering! I Scala er funktioner ikke bare kommandoer; de er førsteklasses værdier.

Det betyder, at du kan behandle funktioner ligesom enhver anden datatype, f.eks. tal eller strenge. Det er et centralt begreb i funktionel programmering!

Tildeling af funktioner til variabler

Ligesom du kan tildele et tal til en val, kan du tildele en funktion til en. Her bliver greet en variabel, der indeholder vores funktion.

Prøv at køre dette enkle eksempel:

object Main {
  def main(args: Array[String]): Unit = {
    val greet = (name: String) => s"Hello, $name!"
    println(greet("Alice"))
  }
}

Anonyme funktioner (lambdaer)

Delen (name: String) => s"Hello, $name!" fra den foregående scene er en anonym funktion, også kaldet et lambdaudtryk.

Det er en funktion uden navn, som ofte defineres direkte dér, hvor der er brug for den. De er meget praktiske til hurtige, specifikke opgaver.

object Main {
  def main(args: Array[String]): Unit = {
    val add = (x: Int, y: Int) => x + y
    println(s"5 + 3 = ${add(5, 3)}")

    val subtract = (a: Int, b: Int) => a - b
    println(s"10 - 4 = ${subtract(10, 4)}")
  }
}

Funktioner som metodeargumenter

Et af de mest kraftfulde aspekter er at sende funktioner som argumenter til andre funktioner. De kaldes funktioner af højere orden.

Funktionen applyOperation nedenfor tager to tal og en anden funktion, op. op bruges derefter til at kombinere tallene.

object Main {
  def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
    op(x, y)
  }

  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val result = applyOperation(5, 3, add)
    println(s"Result of addition: $result")
  }
}

Forståelse af funktionstyper

Bemærk typesignaturen op: (Int, Int) => Int i den foregående scene.

(Int, Int): Det betyder, at funktionen tager to Int-argumenter.
=> Int: Det betyder, at funktionen returnerer en Int.

Alle funktioner har en type, der beskriver deres input og output. Det hjælper Scala med at sikre typesikkerhed!

Kortfattet overførsel af funktioner

Du behøver ikke altid først at definere en navngiven funktion. Du kan sende en anonym funktion direkte dér, hvor der forventes et funktionsargument.

Det gør din kode mere kompakt og læsbar, især ved enkle operationer.

object Main {
  def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
    op(x, y)
  }

  def main(args: Array[String]): Unit = {
    val result1 = applyOperation(10, 2, (a: Int, b: Int) => a * b)
    println(s"Multiplication: $result1")

    // Scala can often infer types, making it even shorter!
    val result2 = applyOperation(20, 4, (a, b) => a / b)
    println(s"Division: $result2")
  }
}

Funktioner som returværdier

Funktioner kan også returnere andre funktioner. Det lyder måske svært at forstå, men det er utroligt nyttigt, når du vil oprette fleksibel og konfigurerbar kode.

Her returnerer makeMultiplier en ny funktion, der multiplicerer sit input med en bestemt faktor.

object Main {
  def makeMultiplier(factor: Int): Int => Int = {
    (x: Int) => x * factor
  }

  def main(args: Array[String]): Unit = {
    val multiplyByTwo = makeMultiplier(2)
    val multiplyByFive = makeMultiplier(5)

    println(s"5 * 2 = ${multiplyByTwo(5)}")
    println(s"10 * 5 = ${multiplyByFive(10)}")
  }
}

Forståelse af lukninger

Når makeMultiplier returnerer en funktion, "husker" den returnerede funktion værdien af factor fra det tidspunkt, hvor den blev oprettet. Det kaldes en lukning.

Selv efter at makeMultiplier er færdig med at køre, "ved" funktionen multiplyByTwo stadig, at dens faktor er 2.

Fordele ved førsteklasses funktioner

Hvorfor er det så vigtigt at behandle funktioner som førsteklasses værdier?

Fleksibilitet: Du kan nemt udskifte adfærd ved at sende forskellige funktioner.
Genbrug: Byg generiske funktioner, der kan arbejde med enhver funktion, du giver dem.
Kortfattethed: Det giver kortere og mere udtryksfuld kode, især med anonyme funktioner.
Funktionel stil: Det er en hjørnesten i funktionel programmering og muliggør effektive mønstre.

Test din viden

Lad os tjekke din forståelse af funktioner som førsteklasses værdier.

object Main {
  def execute(x: Int, op: Int => Int): Int = op(x)

  def main(args: Array[String]): Unit = {
    val square = (n: Int) => n * n
    val result = execute(5, square)
    println(result)
  }
}

Besvar den i den interaktive lektion

Funktioner som værdier: Opsummering

Godt gået! Du har lært det grundlæggende begreb funktioner som førsteklasses værdier i Scala.

Funktioner kan tildeles variabler.
De kan sendes som argumenter til andre funktioner.
De kan returneres som resultater fra andre funktioner.
Det muliggør effektive mønstre som funktioner af højere orden og lukninger.

Denne mulighed er afgørende for at skrive fleksibel, genanvendelig og udtryksfuld funktionel Scala-kode. Nu dykker vi ned i mere avancerede funktioner af højere orden og currying!

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 “Funktioner som førsteklasses værdier” gratis?

Ja — hele teksten til “Funktioner som førsteklasses værdier” 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 “Funktioner som førsteklasses værdier”?

Lær at definere og videregive funktioner som argumenter, returnere dem fra andre funktioner og gemme dem i variabler. 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 1 af 3.

Hvor lang tid tager lektionen “Funktioner som førsteklasses værdier”?

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