Scala för backendutveckling och funktionell programmering · Lektion

Funktioner som värden

Förstaklassfunktioner.

Lektion 1 av 413 steg

Funktioner som värden är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 1 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 Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Funktioner är värden

I Scala är funktioner förstaklassvärden. Du kan lagra dem i variabler, skicka dem som argument och returnera dem från andra funktioner, precis som tal eller strängar.

object Main {
  def main(args: Array[String]): Unit = {
    val increment: Int => Int = x => x + 1
    println(increment(5))
  }
}

Syntax för funktionstyper

Typen Int => String betyder en funktion som tar en Int och returnerar en String. Flera parametrar skrivs inom parenteser: (Int, Int) => Int.

object Main {
  def main(args: Array[String]): Unit = {
    val add: (Int, Int) => Int = (a, b) => a + b
    val label: Int => String = n => s"value=$n"
    println(add(3, 4))
    println(label(7))
  }
}

Syntax för lambda (anonym funktion)

En anonym funktion, eller lambda, skrivs (params) => body. Den saknar namn och skickas ofta direkt till en annan funktion.

object Main {
  def main(args: Array[String]): Unit = {
    val square = (x: Int) => x * x
    println(square(6))
  }
}

Högre ordningens funktioner

En högre ordningens funktion är en funktion som tar en funktion som parameter eller returnerar en funktion. map och filter är klassiska exempel.

object Main {
  def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
  def main(args: Array[String]): Unit = {
    println(applyTwice(_ + 3, 10))
  }
}

Skicka funktioner till metoder

Metoder för samlingar accepterar funktioner. Du kan skicka en lambda inline eller skicka ett namngivet funktionsvärde.

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

Returnera funktioner

En funktion kan returnera en annan funktion. Här returnerar multiplier en funktion som multiplicerar med en fast faktor, alltså en liten funktionsfabrik.

object Main {
  def multiplier(factor: Int): Int => Int = x => x * factor
  def main(args: Array[String]): Unit = {
    val timesTen = multiplier(10)
    println(timesTen(5))
  }
}

Metoder kontra funktioner

En def definierar en metod. Du kan omvandla en metod till ett funktionsvärde med eta-expansionens understreck: methodName _, eller helt enkelt använda den där en funktion förväntas.

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

Funktioner utan parametrar

En funktion kan ta emot inga argument. Dess typ skrivs () => T. Detta är användbart för att skjuta upp beräkningen.

object Main {
  def main(args: Array[String]): Unit = {
    val greeting: () => String = () => "Hello!"
    println(greeting())
  }
}

Lagra funktioner i samlingar

Eftersom funktioner är värden kan du lagra dem i listor eller mappar och slå upp dem dynamiskt, vilket gör det möjligt att skapa en liten kommandodispatcher.

object Main {
  def main(args: Array[String]): Unit = {
    val ops: Map[String, (Int, Int) => Int] = Map(
      "add" -> (_ + _),
      "mul" -> (_ * _)
    )
    println(ops("add")(3, 4))
    println(ops("mul")(3, 4))
  }
}

Funktioner som konfiguration

Genom att skicka en funktion kan anropare anpassa beteendet. Här tillämpar en generell transformAll valfri funktion på en lista.

object Main {
  def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
  def main(args: Array[String]): Unit = {
    println(transformAll(List(1, 2, 3), _ + 100))
    println(transformAll(List(1, 2, 3), _ * 10))
  }
}

Ett renare exempel på anpassning

Här är samma idé skriven på ett renare sätt: anroparna tillhandahåller transformeringen, vilket håller hjälpfunktionen generell och återanvändbar.

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

Snabb kontroll

Vad är en högre ordningens funktion?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig att funktioner är förstaklassvärden:

Lagra funktioner i val, listor och mappar
Funktionstyper som Int => String
Lambdor: (x) => body och kortformen _
Högre ordningens funktioner tar emot eller returnerar funktioner
Metoder blir funktionsvärden via eta-expansion

Gratis att börja

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

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Funktioner som värden” gratis?

Ja – hela texten till ”Funktioner som värden” 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 Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Funktioner som värden”?

Förstaklassfunktioner. Ni övar på Scala för backendutveckling och funktionell programmering 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 Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering 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 1 av 4.

Hur lång tid tar lektionen ”Funktioner som värden”?

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 Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-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

Funktioner som värden
Currying
Komposition
Closures

← Tillbaka till Scala för backendutveckling och funktionell programmering