Scala for Backend Engineering & Functional Programming · Lekcja

Funkcje jako wartości

Funkcje pierwszej klasy

Funkcje jako wartości to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 1 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.

Funkcje są wartościami

W Scali funkcje są wartościami pierwszej klasy. Można przechowywać je w zmiennych, przekazywać jako argumenty i zwracać z innych funkcji, podobnie jak liczby czy napisy.

object Main {
  def main(args: Array[String]): Unit = {
    val increment: Int => Int = x => x + 1
    println(increment(5))
  }
}

Składnia typu funkcji

Typ Int => String oznacza funkcję przyjmującą Int i zwracającą String. W przypadku wielu parametrów używa się nawiasów: (Int, Int) => Int.

object Main {
  def main(args: Array[String]): Unit = {
    val add: (Int, Int) => Int = (a, b) => a + b
    val label: Int => String = n => s"value=$n"
    println(add(3, 4))
    println(label(7))
  }
}

Składnia lambdy (funkcji anonimowej)

Funkcję anonimową, czyli lambdę, zapisuje się jako (params) => body. Nie ma ona nazwy i często jest przekazywana bezpośrednio do innej funkcji.

object Main {
  def main(args: Array[String]): Unit = {
    val square = (x: Int) => x * x
    println(square(6))
  }
}

Funkcje wyższego rzędu

Funkcja wyższego rzędu to funkcja, która przyjmuje funkcję jako parametr lub zwraca funkcję. Klasycznymi przykładami są map i filter.

object Main {
  def applyTwice(f: Int => Int, x: Int): Int = f(f(x))
  def main(args: Array[String]): Unit = {
    println(applyTwice(_ + 3, 10))
  }
}

Przekazywanie funkcji do metod

Metody kolekcji przyjmują funkcje. Można przekazać lambdę bezpośrednio lub przekazać nazwany obiekt funkcyjny.

object Main {
  def main(args: Array[String]): Unit = {
    val triple = (x: Int) => x * 3
    println(List(1, 2, 3).map(triple))
    println(List(1, 2, 3).map(x => x * 3))
  }
}

Zwracanie funkcji

Funkcja może zwracać inną funkcję. W tym przykładzie multiplier zwraca funkcję mnożącą przez ustalony współczynnik, pełniąc rolę niewielkiej fabryki funkcji.

object Main {
  def multiplier(factor: Int): Int => Int = x => x * factor
  def main(args: Array[String]): Unit = {
    val timesTen = multiplier(10)
    println(timesTen(5))
  }
}

Metody a funkcje

def definiuje metodę. Metodę można przekształcić w wartość funkcyjną za pomocą podkreślenia w eta-ekspansji: methodName _, albo po prostu użyć jej w miejscu, w którym oczekiwana jest funkcja.

object Main {
  def doubleIt(x: Int): Int = x * 2
  def main(args: Array[String]): Unit = {
    val f: Int => Int = doubleIt
    println(f(8))
    println(List(1, 2, 3).map(doubleIt))
  }
}

Funkcje bez parametrów

Funkcja może nie przyjmować żadnych argumentów. Jej typ zapisuje się jako () => T. Jest to przydatne do odraczania obliczeń.

object Main {
  def main(args: Array[String]): Unit = {
    val greeting: () => String = () => "Hello!"
    println(greeting())
  }
}

Przechowywanie funkcji w kolekcjach

Ponieważ funkcje są wartościami, można przechowywać je na listach lub w mapach i wyszukiwać dynamicznie, tworząc niewielki mechanizm rozdzielania poleceń.

object Main {
  def main(args: Array[String]): Unit = {
    val ops: Map[String, (Int, Int) => Int] = Map(
      "add" -> (_ + _),
      "mul" -> (_ * _)
    )
    println(ops("add")(3, 4))
    println(ops("mul")(3, 4))
  }
}

Funkcje jako konfiguracja

Przekazanie funkcji pozwala wywołującemu dostosować działanie. W tym przykładzie ogólna funkcja transformAll stosuje dowolną funkcję do wszystkich elementów listy.

object Main {
  def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
  def main(args: Array[String]): Unit = {
    println(transformAll(List(1, 2, 3), _ + 100))
    println(transformAll(List(1, 2, 3), _ * 10))
  }
}

Czytelniejszy przykład dostosowywania

Oto ten sam pomysł zapisany w czytelniejszy sposób: wywołujący dostarcza transformację, dzięki czemu funkcja pomocnicza pozostaje ogólna i wielokrotnego użytku.

object Main {
  def transformAll(xs: List[Int], f: Int => Int): List[Int] = xs.map(f)
  def main(args: Array[String]): Unit = {
    println(transformAll(List(1, 2, 3), x => x + 100))
    println(transformAll(List(1, 2, 3), x => x * x))
  }
}

Szybkie sprawdzenie

Czym jest funkcja wyższego rzędu?

Podsumowanie

Opanował(a) Pan/Pani zasadę, że funkcje są wartościami pierwszej klasy:

Przechowywanie funkcji w obiektach val, na listach i w mapach
Typy funkcji, takie jak Int => String
Lambdy: (x) => body oraz skrót z użyciem _
Funkcje wyższego rzędu przyjmują funkcje lub je zwracają
Metody stają się wartościami funkcyjnymi dzięki eta-ekspansji

Często zadawane pytania

Czy lekcja „Funkcje jako wartości” jest bezpłatna?

Tak — pełny tekst „Funkcje jako 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 „Funkcje jako wartości”?

Funkcje pierwszej klasy Ć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 1 z 4.

Ile czasu zajmuje lekcja „Funkcje jako 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

Funkcje jako wartości
Curryfikacja
Kompozycja
Domknięcia

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