Scala for Backend Engineering & Functional Programming · Lekcja

Znaczące wcięcia

Opcjonalne nawiasy klamrowe

Znaczące wcięcia 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.

Opcjonalne klamry

Scala 3 wprowadza znaczące wcięcia, nazywane także składnią opcjonalnych klamer. Zamiast obejmować bloki konstrukcją { }, można wyznaczać ich granice za pomocą wcięć.

Klamry nadal działają i są w pełni poprawne.
Kod oparty na wcięciach jest bardziej przejrzysty i przypomina kod Pythona.

object Main:
  def main(args: Array[String]): Unit =
    println("No braces needed")

Ciała metod oparte na wcięciach

Ciało metody następujące po = może być blokiem opartym na wcięciach. Każda instrukcja na tym samym poziomie wcięcia należy do tego ciała.

Ostatnie wyrażenie jest wartością zwracaną.

object Main:
  def square(x: Int): Int =
    val result = x * x
    result

  def main(args: Array[String]): Unit =
    println(square(5))

Wyrażenia if oparte na wcięciach

Struktury sterujące używają nowej, zwięzłej składni. Po if cond then należy wciąć gałąź, a else wyrównać z if.

W stylu bez klamer słowo then jest wymagane.
Nawiasy wokół warunku nie są potrzebne.

object Main:
  def main(args: Array[String]): Unit =
    val n = 7
    val label =
      if n % 2 == 0 then "even"
      else "odd"
    println(label)

Pętle for oparte na wcięciach

Pętla for używa do do wykonywania efektów ubocznych lub yield do tworzenia kolekcji; w obu przypadkach stosuje się wcięcia.

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 3 do
      println(s"line $i")

    val doubled =
      for i <- 1 to 3 yield i * 2
    println(doubled)

Pętle while oparte na wcięciach

Pętla while używa do, po którym w stylu z opcjonalnymi klamrami następuje blok oparty na wcięciach.

object Main:
  def main(args: Array[String]): Unit =
    var i = 0
    while i < 3 do
      println(s"i = $i")
      i += 1

Wyrażenia match oparte na wcięciach

Dopasowywanie wzorców naturalnie dobrze współpracuje z wcięciami. Klauzule case są wcięte pod match.

object Main:
  def describe(n: Int): String =
    n match
      case 0 => "zero"
      case 1 => "one"
      case _ => "many"

  def main(args: Array[String]): Unit =
    println(describe(1))
    println(describe(9))

Ciała klas i traitów

Klasy, traity i obiekty również mogą nie używać klamer. Dwukropek : po nagłówku otwiera ciało oparte na wcięciach.

class Point(x: Int, y: Int):
  def show: String = s"($x, $y)"

object Main:
  def main(args: Array[String]): Unit =
    println(Point(2, 3).show)

Znacznik end

W przypadku długich bloków opartych na wcięciach można dodać znacznik end, aby wyraźnie wskazać, gdzie kończy się definicja. Poprawia to czytelność dużych metod lub klas.

Forma: end <name> lub end if, end while itd.
Jest opcjonalny, a jego poprawność sprawdza kompilator.

object Main:
  def greet(name: String): String =
    val msg = s"Hello, $name"
    msg
  end greet

  def main(args: Array[String]): Unit =
    println(greet("Ada"))
  end main
end Main

Łączenie klamer i wcięć

Można swobodnie łączyć oba style. Niektóre zespoły zachowują klamry dla większej przejrzystości w zagnieżdżonych przypadkach. Reguły wcięć są wymuszane tylko tam, gdzie nie ma klamer.

object Main:
  def main(args: Array[String]): Unit = {
    val xs = List(1, 2, 3)
    val total =
      xs.foldLeft(0)((acc, x) => acc + x)
    println(total)
  }

Częste problemy z wcięciami

Wcięcia mają znaczenie, dlatego należy zachować konsekwencję.

Należy używać spacji, a nie mieszać tabulatorów ze spacjami.
Nieprawidłowo wyrównany wiersz może niepostrzeżenie znaleźć się poza blokiem.
Dwukropek : jest potrzebny dla ciał szablonów (klas/obiektów), ale nie dla ciał metod następujących po =.

object Main:
  def main(args: Array[String]): Unit =
    val items = List("a", "b")
    items.foreach: item =>
      println(item.toUpperCase)

Składnia argumentów z mniejszą liczbą klamer

Scala 3 pozwala również przekazać argument będący blokiem po dwukropku. items.foreach: x => otwiera ciało lambdy oparte na wcięciach, bez zagnieżdżonych nawiasów i klamer.

object Main:
  def main(args: Array[String]): Unit =
    val nums = List(1, 2, 3, 4)
    val evens = nums.filter: n =>
      n % 2 == 0
    println(evens)

Szybkie sprawdzenie

Sprawdź swoją znajomość znaczących wcięć.

Podsumowanie

Poznał(a) Pan(i) znaczące wcięcia w Scali 3.

Bloki mogą używać wcięć zamiast { }.
Struktury sterujące używają then, do i yield.
Ciała klas, obiektów i traitów otwierają się dwukropkiem :.
Znaczniki end ułatwiają orientację w długich blokach.
Oba style można łączyć; należy zachować spójność odstępów.

object Main:
  def main(args: Array[String]): Unit =
    for i <- 1 to 2 do
      if i == 1 then println("first")
      else println("second")
  end main
end Main

Często zadawane pytania

Czy lekcja „Znaczące wcięcia” jest bezpłatna?

Tak — pełny tekst „Znaczące wcięcia” 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 „Znaczące wcięcia”?

Opcjonalne nawiasy klamrowe Ć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 „Znaczące wcięcia”?

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