0Pricing
Scala for Backend Engineering & Functional Programming · Lekcja

Funkcje jako wartości pierwszej klasy

Naucz się definiować funkcje i przekazywać je jako argumenty, zwracać je z innych funkcji oraz przechowywać w zmiennych.

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

Funkcje jako wartości pierwszej klasy

Witamy w module Podstawy programowania funkcyjnego! W języku Scala funkcje to nie tylko polecenia — są wartościami pierwszej klasy.

Oznacza to, że można traktować funkcje tak samo jak każdy inny typ danych, na przykład liczby lub napisy. To podstawowe pojęcie programowania funkcyjnego!

Przypisywanie funkcji do zmiennych

Tak jak można przypisać liczbę do val, można do niego przypisać także funkcję. W tym przykładzie greet staje się zmienną przechowującą naszą funkcję.

Spróbuj uruchomić ten prosty przykład:

object Main {
  def main(args: Array[String]): Unit = {
    val greet = (name: String) => s"Hello, $name!"
    println(greet("Alice"))
  }
}

Funkcje anonimowe (lambda)

Fragment (name: String) => s"Hello, $name!" z poprzedniej sceny to funkcja anonimowa, nazywana także wyrażeniem lambda.

Jest to funkcja bez nazwy, często definiowana bezpośrednio w miejscu, w którym jest potrzebna. Funkcje anonimowe są bardzo przydatne przy szybkich, konkretnych zadaniach.

object Main {
  def main(args: Array[String]): Unit = {
    val add = (x: Int, y: Int) => x + y
    println(s"5 + 3 = ${add(5, 3)}")

    val subtract = (a: Int, b: Int) => a - b
    println(s"10 - 4 = ${subtract(10, 4)}")
  }
}

Funkcje jako argumenty metod

Jedną z najpotężniejszych możliwości jest przekazywanie funkcji jako argumentów do innych funkcji. Nazywa się je funkcjami wyższego rzędu.

Poniższa funkcja applyOperation przyjmuje dwie liczby i inną funkcję op. Następnie używa op do połączenia tych liczb.

object Main {
  def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
    op(x, y)
  }

  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val result = applyOperation(5, 3, add)
    println(s"Result of addition: $result")
  }
}

Zrozumienie typów funkcji

Proszę zwrócić uwagę na sygnaturę typu op: (Int, Int) => Int z poprzedniej sceny.

  • (Int, Int): Oznacza, że funkcja przyjmuje dwa argumenty typu Int.
  • => Int: Oznacza, że funkcja zwraca wartość typu Int.

Każda funkcja ma typ opisujący jej dane wejściowe i wynik. Pomaga to Scali zapewniać bezpieczeństwo typów!

Zwięzłe przekazywanie funkcji

Nie zawsze trzeba najpierw definiować funkcję o nazwie. Można przekazać funkcję anonimową bezpośrednio tam, gdzie oczekiwany jest argument funkcyjny.

Dzięki temu kod jest krótszy i bardziej czytelny, szczególnie w przypadku prostych operacji.

object Main {
  def applyOperation(x: Int, y: Int, op: (Int, Int) => Int): Int = {
    op(x, y)
  }

  def main(args: Array[String]): Unit = {
    val result1 = applyOperation(10, 2, (a: Int, b: Int) => a * b)
    println(s"Multiplication: $result1")

    // Scala can often infer types, making it even shorter!
    val result2 = applyOperation(20, 4, (a, b) => a / b)
    println(s"Division: $result2")
  }
}

Funkcje jako wartości zwracane

Funkcje mogą także zwracać inne funkcje. Może się to wydawać zaskakujące, ale jest niezwykle przydatne przy tworzeniu elastycznego i konfigurowalnego kodu.

W tym przykładzie makeMultiplier zwraca nową funkcję, która mnoży dane wejściowe przez określony współczynnik.

object Main {
  def makeMultiplier(factor: Int): Int => Int = {
    (x: Int) => x * factor
  }

  def main(args: Array[String]): Unit = {
    val multiplyByTwo = makeMultiplier(2)
    val multiplyByFive = makeMultiplier(5)

    println(s"5 * 2 = ${multiplyByTwo(5)}")
    println(s"10 * 5 = ${multiplyByFive(10)}")
  }
}

Zrozumienie domknięć

Gdy makeMultiplier zwraca funkcję, zwrócona funkcja „pamięta” wartość factor z chwili utworzenia. Nazywa się to domknięciem.

Nawet po zakończeniu działania makeMultiplier funkcja multiplyByTwo nadal „wie”, że jej współczynnik wynosi 2.

Zalety funkcji pierwszej klasy

Dlaczego traktowanie funkcji jako wartości pierwszej klasy jest tak ważne?

  • Elastyczność: Można łatwo zmieniać zachowanie, przekazując różne funkcje.
  • Możliwość ponownego użycia: Można tworzyć uniwersalne funkcje działające na dowolnej przekazanej funkcji.
  • Zwięzłość: Prowadzi do krótszego i bardziej wyrazistego kodu, szczególnie w połączeniu z funkcjami anonimowymi.
  • Styl funkcyjny: Jest podstawą programowania funkcyjnego i umożliwia stosowanie zaawansowanych wzorców.

Sprawdź swoją wiedzę

Sprawdźmy, czy rozumieją Państwo funkcje jako wartości pierwszej klasy.

object Main {
  def execute(x: Int, op: Int => Int): Int = op(x)

  def main(args: Array[String]): Unit = {
    val square = (n: Int) => n * n
    val result = execute(5, square)
    println(result)
  }
}

Funkcje jako wartości: podsumowanie

Świetna praca! Poznali Państwo podstawowe pojęcie funkcji jako wartości pierwszej klasy w Scali.

  • Funkcje można przypisywać do zmiennych.
  • Można je przekazywać jako argumenty do innych funkcji.
  • Można je zwracać jako wyniki innych funkcji.
  • Umożliwia to stosowanie zaawansowanych wzorców, takich jak funkcje wyższego rzędu i domknięcia.

Ta możliwość jest kluczowa przy pisaniu elastycznego, wielokrotnego użytku i wyrazistego kodu funkcyjnego w Scali. W następnej kolejności omówimy bardziej zaawansowane funkcje wyższego rzędu i częściowe stosowanie funkcji!

Często zadawane pytania

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

Tak — pełny tekst „Funkcje jako wartości pierwszej klasy” 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 3 lekcji w sumie.

Co nauczysz się w „Funkcje jako wartości pierwszej klasy”?

Naucz się definiować funkcje i przekazywać je jako argumenty, zwracać je z innych funkcji oraz przechowywać w zmiennych. Ć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 3.

Ile czasu zajmuje lekcja „Funkcje jako wartości pierwszej klasy”?

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

  1. Funkcje jako wartości pierwszej klasy
  2. Funkcje wyższego rzędu i currying
  3. Niemutowalność i efekty uboczne
← Powrót do Scala for Backend Engineering & Functional Programming