Dopasowywanie typów i wartości
Wzorce typów
Dopasowywanie typów i wartości to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Wzorce typów
Oprócz dopasowywania wartości literałowych match może rozgałęziać działanie na podstawie typu wartości. Nazywa się to wzorcem typu.
Zapisuje się case x: Type =>. Gałąź zostanie wykonana, gdy wartość będzie tego typu, a sama wartość zostanie przypisana do x.
Dopasowywanie według typu
Gdy wartość ma ogólny typ, taki jak Any, można określić jej konkretny typ za pomocą wzorca typu.
Każdy element case x: T sprawdza typ w czasie wykonywania.
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))
}
}Używanie przypisanej wartości
Przypisana nazwa ma dopasowany typ, więc w tej gałęzi można bezpiecznie wywoływać jej metody.
Rzutowanie nie jest potrzebne — kompilator zna typ wewnątrz przypadku.
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 i wartość razem
W tym samym match można łączyć wzorce wartości i wzorce typów. Wzorce wartości są zwykle bardziej szczegółowe, dlatego należy umieszczać je wcześniej.
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"))
}
}Dopasowywanie Double i Boolean
Wzorce typów działają dla dowolnych typów, w tym Double, Boolean i 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))
}
}Dopasowywanie kolekcji według typu
Można także dopasowywać typy kontenerów, takie jak List. W tym przykładzie odróżniamy listę od innych wartości.
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"))
}
}Typowe zastosowanie: obsługa Any
Wzorce typów są szczególnie przydatne, gdy funkcja otrzymuje Any i musi reagować inaczej na poszczególne typy, na przykład podczas rejestrowania lub serializacji.
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)))
}
}Kolejność nadal ma znaczenie
Jak w każdym dopasowaniu, wzorce typów są sprawdzane od góry do dołu. Szerszy typ umieszczony wcześniej może ukryć znajdujący się niżej typ węższy.
Zawsze układaj wzorce od najbardziej szczegółowych do najbardziej ogólnych.
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))
}
}Ograniczenie związane z wymazywaniem typów
W czasie wykonywania parametry typów generycznych są wymazywane. Dlatego List[Int] i List[String] wyglądają tak samo. Dopasowanie do List[Int] sprawdza tylko, czy wartość jest typu List.
Używaj List[_], aby wyrazić to jawnie i uniknąć ostrzeżeń.
Dlaczego wzorce typów?
Wzorce typów pozwalają:
- bezpiecznie zawężać ogólny typ bez rzutowania
- przejrzyście obsługiwać wartości różnych typów
- łączyć wzorce typów ze wzorcami wartości i warunkami ochronnymi
Są one pierwszym krokiem do dopasowywania klas case i ADT.
Połączenie elementów
Połącz wzorce wartości i typów, aby sklasyfikować dane wejściowe różnych typów.
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"))
}
}Szybki test
Sprawdź swoją wiedzę o wzorcach typów.
Podsumowanie
Nauczyłeś się dopasowywać typy:
case x: Typedopasowuje według typu w czasie wykonywania i przypisuje wartość dox- przypisana wartość ma dopasowany typ, więc rzutowanie nie jest potrzebne
- łącz wzorce wartości i typów, zaczynając od najbardziej szczegółowych
- parametry generyczne są wymazywane, dlatego używaj
List[_]
Ucz się Scala dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 39
- Lekcje
- 143
Często zadawane pytania
Czy lekcja „Dopasowywanie typów i wartości” jest bezpłatna?
Tak — pełny tekst „Dopasowywanie typów i wartości” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.
Co nauczysz się w „Dopasowywanie typów i wartości”?
Wzorce typów Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?
Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.
Ile czasu zajmuje lekcja „Dopasowywanie typów i wartości”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?
Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Wyrażenia match
- Dopasowywanie typów i wartości
- Strażnicy i wiązanie
- Dekonstrukcja