Scala för backendutveckling och funktionell programmering · Lektion

Matcha typer och värden

Typmönster.

Lektion 2 av 413 steg

Matcha typer och värden är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 2 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.

Typmönster

Utöver att matcha litterala värden kan match förgrena sig utifrån ett värdes typ. Detta kallas ett typmönster.

Ni skriver case x: Type =>, och grenen körs när värdet har den typen och binds då till x.

Matchning efter typ

När ett värde har en generell typ som Any kan ni ta reda på dess konkreta typ med ett typmönster.

Varje case x: T kontrollerar typen under körning.

object Main {
  def describe(x: Any): String = x match {
    case i: Int    => "an Int"
    case s: String => "a String"
    case _         => "something else"
  }
  def main(args: Array[String]): Unit = {
    println(describe(5))
    println(describe("hi"))
    println(describe(3.14))
  }
}

Använda det bundna värdet

Det bundna namnet har den matchade typen, så ni kan anropa dess metoder säkert i den grenen.

Ingen typomvandling behövs: kompilatorn känner till typen inuti fallet.

object Main {
  def shout(x: Any): String = x match {
    case s: String => s.toUpperCase
    case i: Int    => (i * 2).toString
    case _         => "?"
  }
  def main(args: Array[String]): Unit = {
    println(shout("hello"))
    println(shout(21))
  }
}

Typ och värde tillsammans

Ni kan blanda värdemönster och typmönster i samma match. Värdemönster är vanligtvis mer specifika, så placera dem först.

object Main {
  def check(x: Any): String = x match {
    case 0       => "zero int"
    case i: Int  => s"nonzero int $i"
    case _       => "not an int"
  }
  def main(args: Array[String]): Unit = {
    println(check(0))
    println(check(7))
    println(check("x"))
  }
}

Matchning av Double och Boolean

Typmönster fungerar för alla typer, inklusive Double, Boolean och Char.

object Main {
  def kind(x: Any): String = x match {
    case d: Double  => s"double $d"
    case b: Boolean => s"bool $b"
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(kind(2.5))
    println(kind(true))
  }
}

Matchning av samlingar efter typ

Ni kan även matcha behållartyper som List. Här skiljer vi en lista från andra värden.

object Main {
  def info(x: Any): String = x match {
    case l: List[_] => s"a list of size ${l.size}"
    case _          => "not a list"
  }
  def main(args: Array[String]): Unit = {
    println(info(List(1, 2, 3)))
    println(info("nope"))
  }
}

Ett vanligt användningsområde: hantera Any

Typmönster är särskilt användbara när en funktion tar emot Any och måste reagera olika beroende på typ, till exempel vid loggning eller serialisering.

object Main {
  def render(x: Any): String = x match {
    case i: Int    => s"int=$i"
    case d: Double => s"dbl=$d"
    case s: String => s"str=$s"
    case _         => "unknown"
  }
  def main(args: Array[String]): Unit = {
    List(1, 2.0, "three").foreach(v => println(render(v)))
  }
}

Ordningen spelar fortfarande roll

Precis som vid all matchning kontrolleras typmönster uppifrån och ned. En bredare typ som placeras först kan dölja en snävare typ längre ned.

Ordna alltid från mest specifik till mest generell.

object Main {
  def label(x: Any): String = x match {
    case s: String => "string first"
    case _: Any    => "anything"
  }
  def main(args: Array[String]): Unit = {
    println(label("hi"))
    println(label(99))
  }
}

Förbehåll om typradering

Under körning är generiska typparametrar raderade. Därför ser List[Int] och List[String] likadana ut. Matchning mot List[Int] kontrollerar endast att det är en List.

Använd List[_] för att vara tydlig och undvika varningar.

Varför typmönster?

Typmönster låter er:

Förfina en generell typ på ett säkert sätt utan typomvandling
Hantera heterogena värden på ett tydligt sätt
Kombinera dem med värdemönster och villkor

De är ett steg på vägen mot matchning av case-klasser och ADT:er.

Sätt ihop delarna

Kombinera värde- och typmönster för att klassificera blandade indata.

object Main {
  def classify(x: Any): String = x match {
    case 0          => "zero"
    case i: Int     => "int"
    case s: String  => "text of length " + s.length
    case _          => "other"
  }
  def main(args: Array[String]): Unit = {
    println(classify(0))
    println(classify(5))
    println(classify("hey"))
  }
}

Snabbtest

Testa era kunskaper om typmönster.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er att matcha typer:

case x: Type matchar efter typ under körning och binder x
Det bundna värdet har den matchade typen, så ingen typomvandling behövs
Blanda värde- och typmönster, med de mest specifika först
Generiska parametrar raderas, så använd List[_]

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 ”Matcha typer och värden” gratis?

Ja – hela texten till ”Matcha typer och 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 ”Matcha typer och värden”?

Typmönster. 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 2 av 4.

Hur lång tid tar lektionen ”Matcha typer och 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

← Tillbaka till Scala för backendutveckling och funktionell programmering