Scala for Backend Engineering & Functional Programming · Lekcja

Metody rozszerzające

Dodawanie metod do typów

Metody rozszerzające to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 4 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.

Dodawanie metod do istniejących typów

Metody rozszerzające pozwalają dodawać nowe metody do typu, którego nie są Państwo właścicielem, takiego jak Int lub String, bez modyfikowania jego kodu źródłowego. Scala 3 oferuje przejrzystą składnię do tego celu.

object Main:
  extension (x: Int)
    def squared: Int = x * x
  def main(args: Array[String]): Unit =
    println(5.squared)

Składnia rozszerzeń

Należy napisać extension (param: Type), a następnie jedną lub więcej definicji metod. Wewnątrz każdej metody parametr oznacza wartość, na której wywoływana jest metoda.

object Main:
  extension (s: String)
    def shout: String = s.toUpperCase + "!"
  def main(args: Array[String]): Unit =
    println("hello".shout)

Wiele metod w jednym bloku

Pojedyncza klauzula extension może definiować kilka metod, które działają na tym samym typie odbiorcy.

object Main:
  extension (x: Int)
    def squared: Int = x * x
    def cubed: Int = x * x * x
    def isEven: Boolean = x % 2 == 0
  def main(args: Array[String]): Unit =
    println(4.squared)
    println(3.cubed)
    println(6.isEven)

Metody rozszerzające z parametrami

Metody rozszerzające mogą przyjmować własne parametry, niezależnie od parametru odbiorcy.

object Main:
  extension (x: Int)
    def times(s: String): String = s * x
  def main(args: Array[String]): Unit =
    println(3.times("ab"))

Generyczne metody rozszerzające

Rozszerzenia mogą być generyczne, dodając metody do całej rodziny typów, takiej jak List[A].

object Main:
  extension [A](xs: List[A])
    def second: A = xs(1)
  def main(args: Array[String]): Unit =
    println(List(10, 20, 30).second)
    println(List("a", "b").second)

Dlaczego rozszerzenia są lepsze od konwersji niejawnych

Metody rozszerzające realizują dawny cel „pimp-my-library” w bezpieczniejszy sposób: dodają wyłącznie nazwane metody, bez ryzyka niejawnych konwersji typów w innych miejscach.

object Main:
  extension (d: Double)
    def percentOf(total: Double): Double = d / total * 100
  def main(args: Array[String]): Unit =
    println(25.0.percentOf(200.0))

Rozszerzenia i klasy typów

Metody rozszerzające świetnie współpracują z klasami typów: należy zdefiniować zachowanie za pomocą instancji given i udostępnić je jako metodę przy użyciu using.

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

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

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

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

Definiowanie operatorów

Ponieważ operatory są po prostu metodami, rozszerzenia mogą również dodawać symboliczne operatory do istniejących typów.

object Main:
  extension (x: Int)
    def **(exp: Int): Int = math.pow(x, exp).toInt
  def main(args: Array[String]): Unit =
    println(2 ** 10)

Zakres i importy

Metody rozszerzające są dostępne tylko tam, gdzie znajdują się w zakresie. Należy zdefiniować je w obiekcie i zaimportować ten obiekt, aby z nich korzystać, zachowując kontrolę nad ich zasięgiem.

object StringOps:
  extension (s: String)
    def reversedWords: String = s.split(" ").reverse.mkString(" ")

object Main:
  import StringOps._
  def main(args: Array[String]): Unit =
    println("hello there world".reversedWords)

Łączenie metod rozszerzających

Metody rozszerzające zwracają zwykłe wartości, dlatego można łączyć je z wbudowanymi metodami, tworząc płynne potoki operacji.

object Main:
  extension (s: String)
    def emphasize: String = s"*$s*"
  def main(args: Array[String]): Unit =
    println("scala".toUpperCase.emphasize)

Praktyczny pomocnik

Metody rozszerzające doskonale nadają się do małych pomocniczych metod domenowych, dzięki którym kod wywołujący czyta się naturalnie.

object Main:
  extension (n: Int)
    def isPrime: Boolean =
      n > 1 && (2 until n).forall(d => n % d != 0)
  def main(args: Array[String]): Unit =
    println((2 to 12).filter(_.isPrime).toList)

Szybkie sprawdzenie

Jaka jest główna zaleta metod rozszerzających Scali 3 w porównaniu z konwersjami niejawnymi przy dodawaniu metod?

Podsumowanie

Opanował(a) Pan/Pani metody rozszerzające:

extension (x: Type) def ... dodaje metody do istniejących typów
Jeden blok może definiować wiele metod, w tym operatory
Mogą być generyczne i przyjmować parametry
Naturalnie współpracują z klasami typów za pośrednictwem using
Są bezpieczniejsze od konwersji niejawnych i muszą zostać zaimportowane do zakresu

Często zadawane pytania

Czy lekcja „Metody rozszerzające” jest bezpłatna?

Tak — pełny tekst „Metody rozszerzające” 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 „Metody rozszerzające”?

Dodawanie metod do 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 4 z 4.

Ile czasu zajmuje lekcja „Metody rozszerzające”?

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