Scala for Backend Engineering & Functional Programming · Lekcja

Strażnicy i wiązanie

Warunki w dopasowaniach

Strażnicy i wiązanie to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 3 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.

Czym jest warunek ochronny?

Warunek ochronny dodaje do przypadku warunek logiczny za pomocą if. Przypadek pasuje tylko wtedy, gdy wzorzec pasuje i warunek ochronny ma wartość true.

Warunki ochronne pozwalają podzielić jeden wzorzec na bardziej szczegółowe przypadki zależnie od wartości.

Dodawanie warunku if

Warunek ochronny zapisuje się po wzorcu: case n if n > 0 =>. Jeśli warunek jest fałszywy, dopasowywanie przechodzi do następnego przypadku.

object Main {
  def sign(n: Int): String = n match {
    case x if x > 0 => "positive"
    case x if x < 0 => "negative"
    case _          => "zero"
  }
  def main(args: Array[String]): Unit = {
    println(sign(5))
    println(sign(-3))
    println(sign(0))
  }
}

Przypisanie, a następnie warunek

Warunek ochronny może odwoływać się do nazwy przypisanej we wzorcu. W ten sposób sprawdza się właściwości dopasowanej wartości.

object Main {
  def fizz(n: Int): String = n match {
    case x if x % 15 == 0 => "FizzBuzz"
    case x if x % 3 == 0  => "Fizz"
    case x if x % 5 == 0  => "Buzz"
    case x                => x.toString
  }
  def main(args: Array[String]): Unit = {
    println(fizz(15))
    println(fizz(9))
    println(fizz(7))
  }
}

Warunki ochronne dla zakresów

Warunki ochronne świetnie nadają się do obsługi zakresów, których wzorce literałowe nie potrafią bezpośrednio wyrazić.

object Main {
  def band(score: Int): String = score match {
    case s if s >= 90 => "A"
    case s if s >= 80 => "B"
    case s if s >= 70 => "C"
    case _            => "F"
  }
  def main(args: Array[String]): Unit = {
    println(band(95))
    println(band(83))
    println(band(60))
  }
}

Przypisywanie we wzorcu za pomocą @

Symbol @ przypisuje całą dopasowaną wartość do nazwy, jednocześnie dopasowując jej strukturę.

W tym przypadku whole @ pattern oznacza: dopasuj pattern, a dopasowaną wartość nazwij także whole.

object Main {
  def main(args: Array[String]): Unit = {
    val x: Any = 7
    val msg = x match {
      case n @ (_: Int) => s"int value is $n"
      case _            => "other"
    }
    println(msg)
  }
}

Przypisywanie w kolekcjach

Przypisywanie za pomocą @ jest szczególnie przydatne w przypadku wzorców strukturalnych, na przykład gdy trzeba przechwycić całą listę i jednocześnie sprawdzić jej pierwszy element.

object Main {
  def describe(xs: List[Int]): String = xs match {
    case all @ (first :: _) => s"starts with $first, full = $all"
    case Nil                => "empty"
  }
  def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3)))
    println(describe(Nil))
  }
}

Łączenie wzorca typu i warunku ochronnego

Wzorzec typu można połączyć z warunkiem ochronnym. Najpierw sprawdzany jest typ, a następnie warunek logiczny.

object Main {
  def label(x: Any): String = x match {
    case s: String if s.length > 3 => "long string"
    case s: String                 => "short string"
    case _                         => "not a string"
  }
  def main(args: Array[String]): Unit = {
    println(label("hello"))
    println(label("hi"))
    println(label(42))
  }
}

Wiele warunków

Warunek ochronny jest po prostu wyrażeniem logicznym, dlatego można łączyć warunki za pomocą && i ||.

object Main {
  def category(age: Int): String = age match {
    case a if a >= 13 && a <= 19 => "teen"
    case a if a < 13             => "child"
    case _                       => "adult"
  }
  def main(args: Array[String]): Unit = {
    println(category(15))
    println(category(8))
    println(category(40))
  }
}

Warunki ochronne nie powodują przejścia do kolejnego warunku

Jeśli wzorzec pasuje, ale jego warunek ochronny jest fałszywy, Scala przechodzi do następnego przypadku, a nie do następnego warunku dla tego samego wzorca.

Upewnij się, że późniejszy przypadek może przechwycić wartości, które nie spełniają żadnego warunku ochronnego.

object Main {
  def test(n: Int): String = n match {
    case x if x > 100 => "big"
    case x            => s"not big: $x"
  }
  def main(args: Array[String]): Unit = {
    println(test(200))
    println(test(5))
  }
}

Dlaczego warunki i przypisywanie?

Połączenie warunków ochronnych i przypisań @ zwiększa wyrazistość dopasowywania wzorców:

warunki ochronne dodają ograniczenia, takie jak zakresy i podzielność
@ przechwytuje całą wartość podczas jej rozpakowywania
logika rozgałęzień pozostaje zwięzła i czytelna

Połączenie elementów

Ten przykład przypisuje wartość, sprawdza warunek ochronny i zapewnia przypadek awaryjny.

object Main {
  def temp(c: Int): String = c match {
    case t if t >= 30 => s"hot ($t)"
    case t if t >= 15 => s"mild ($t)"
    case t            => s"cold ($t)"
  }
  def main(args: Array[String]): Unit = {
    println(temp(35))
    println(temp(20))
    println(temp(5))
  }
}

Szybki test

Sprawdź swoją wiedzę o warunkach ochronnych i przypisywaniu.

Podsumowanie

Nauczyłeś się uszczegóławiać dopasowania:

warunek ochronny to warunek if występujący po wzorcu
jeśli warunek ochronny jest fałszywy, dopasowywanie przechodzi do następnego przypadku
operator @ przypisuje całą wartość podczas jej rozpakowywania
warunki ochronne można łączyć ze wzorcami typów i operatorami logicznymi

Często zadawane pytania

Czy lekcja „Strażnicy i wiązanie” jest bezpłatna?

Tak — pełny tekst „Strażnicy i wiązanie” 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 „Strażnicy i wiązanie”?

Warunki w dopasowaniach Ć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 3 z 4.

Ile czasu zajmuje lekcja „Strażnicy i wiązanie”?

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

← Powrót do Scala for Backend Engineering & Functional Programming