Scala til backendudvikling og funktionel programmering · Lektion

Scala 3 given/using

Moderne syntaks

Lektion 2 af 413 trin

Scala 3 given/using er en gratis Scala til backendudvikling og funktionel programmering-lektion på CoddyKit. Dette er lektion 2 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.

Moderne implicitter i Scala 3

Scala 3 erstatter det overbelastede nøgleord implicit med tydeligere syntaks: given definerer en implicit værdi, og using erklærer en implicit parameter. Hensigten er langt lettere at læse.

object Main:
  given greeting: String = "Hello"
  def greet(name: String)(using g: String): String = s"$g, $name!"
  def main(args: Array[String]): Unit =
    println(greet("Ann"))

given erstatter implicit val

Hvor Scala 2 skrev implicit val x: T = ..., skriver Scala 3 given x: T = .... Det erklærer en værdi, der er tilgængelig for implicit opløsning.

object Main:
  given factor: Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))

using erstatter implicitte parametre

En using-klausul markerer en parameterliste som implicit. Compileren udfylder den med en matchende given i synlighedsområdet.

object Main:
  given unit: String = "kg"
  def label(n: Int)(using u: String): String = s"$n$u"
  def main(args: Array[String]): Unit =
    println(label(75))

Anonyme givens

Du kan udelade navnet på en given, når du aldrig refererer direkte til den. Compileren finder den stadig efter type.

object Main:
  given Int = 3
  def triple(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(triple(7))

Hentning med summon

Scala 3's summon[T] erstatter implicitly[T]. Den henter den givne værdi af typen T direkte.

object Main:
  given name: String = "Scala 3"
  def main(args: Array[String]): Unit =
    val n = summon[String]
    println(n)

Anonyme using-parametre

Hvis du kun har brug for at videresende en using-parameter, kan du lade den være unavngiven i klausulen: (using Int). Hent den inde i klausulen med summon.

object Main:
  given Int = 100
  def boosted(x: Int)(using Int): Int = x + summon[Int]
  def main(args: Array[String]): Unit =
    println(boosted(5))

given til typeklasser

Den mest idiomatiske brug af given/using er typeklasser. Definér et trait, angiv en given-instans, og kræv den med using.

trait Show[A]:
  def show(a: A): String

object Main:
  given Show[Int] with
    def show(a: Int): String = s"Int($a)"

  def display[A](a: A)(using s: Show[A]): String = s.show(a)

  def main(args: Array[String]): Unit =
    println(display(42))

Kontekstbindinger fungerer stadig

Kontekstbindinger [A: Show] er stadig tilgængelige og omskrives til en using-parameter. Kombinér dem med summon for at få adgang til instansen.

trait Show[A]:
  def show(a: A): String

object Main:
  given Show[String] with
    def show(a: String): String = s"Str($a)"

  def display[A: Show](a: A): String = summon[Show[A]].show(a)

  def main(args: Array[String]): Unit =
    println(display("hi"))

Eksplicit angivelse af using-argumenter

Du kan levere en using-parameter eksplicit med nøgleordet using ved kaldet og dermed tilsidesætte den givne værdi i synlighedsområdet.

object Main:
  given Int = 10
  def scale(x: Int)(using f: Int): Int = x * f
  def main(args: Array[String]): Unit =
    println(scale(5))
    println(scale(5)(using 2))

Imports af givens

Scala 3 har en særlig syntaks til at importere givens: import pkg.given eller import pkg.{given Show[Int]}. Det gør implicitte imports eksplicitte og bevidste.

object Instances:
  given Int = 5

object Main:
  import Instances.given
  def addBase(x: Int)(using b: Int): Int = x + b
  def main(args: Array[String]): Unit =
    println(addBase(10))

Hvorfor den nye syntaks

I Scala 2 betød det ene nøgleord implicit flere forskellige ting. Scala 3 opdeler begrebet: given = lever, using = kræver. Koden bliver tydeligere, og fejl er lettere at forstå.

object Main:
  given pi: Double = 3.14159
  def area(r: Double)(using p: Double): Double = p * r * r
  def main(args: Array[String]): Unit =
    println(area(2.0))

Hurtigt tjek

Hvilke nøgleord erstatter implicit i Scala 3, når værdier leveres og kræves?

Besvar den i den interaktive lektion

Opsummering

Du har lært om Scala 3's given/using:

given leverer en implicit værdi (erstatter implicit val)
using erklærer en implicit parameter
summon[T] erstatter implicitly[T]
Givens kan være anonyme og er ideelle til typeklasser
import pkg.given importerer dem eksplicit

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 “Scala 3 given/using” gratis?

Ja — hele teksten til “Scala 3 given/using” 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 “Scala 3 given/using”?

Moderne syntaks 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 4.

Hvor lang tid tager lektionen “Scala 3 given/using”?

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