Scala for Backend Engineering & Functional Programming · Lektion

Signifikante Einrückung

Optionale geschweifte Klammern

Lektion 1 von 413 Schritte

Signifikante Einrückung ist eine kostenlose Scala for Backend Engineering & Functional Programming-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Scala for Backend Engineering & Functional Programming-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Optionale geschweifte Klammern

Scala 3 führt signifikante Einrückung ein, auch Syntax mit optionalen geschweiften Klammern genannt. Statt Blöcke mit { } zu umschließen, können Sie sie durch Einrückung begrenzen.

Geschweifte Klammern funktionieren weiterhin und sind vollständig gültig.
Code auf Basis von Einrückung ist übersichtlicher und ähnelt Python.

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

Eingerückte Methodenkörper

Ein auf = folgender Methodenkörper kann ein eingerückter Block sein. Jede Anweisung auf derselben Einrückungsebene gehört zu diesem Körper.

Der letzte Ausdruck ist der Rückgabewert.

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

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

Eingerückte if-Ausdrücke

Steuerstrukturen verwenden die neue Syntax ohne geschweifte Klammern. Nach if cond then rücken Sie den Zweig ein, und else steht auf derselben Ebene wie if.

then ist in der Schreibweise ohne geschweifte Klammern erforderlich.
Die Bedingung muss nicht in Klammern stehen.

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

Eingerückte for-Schleifen

Die for-Schleife verwendet do für Seiteneffekte oder yield zum Erstellen von Collections, jeweils mit Einrückung.

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)

Eingerückte while-Schleifen

Die while-Schleife verwendet do, gefolgt von einem eingerückten Block in der Schreibweise mit optionalen geschweiften Klammern.

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

Eingerückte match-Ausdrücke

Pattern Matching eignet sich von Natur aus gut für Einrückung. Die case-Klauseln werden unter match eingerückt.

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))

Klassen- und Trait-Körper

Auch Klassen, Traits und Objekte können auf geschweifte Klammern verzichten. Ein Doppelpunkt : nach dem Header eröffnet den eingerückten Körper.

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)

Die end-Markierung

Bei langen eingerückten Blöcken können Sie eine end-Markierung hinzufügen, um zu verdeutlichen, wo eine Definition endet. Das verbessert die Lesbarkeit großer Methoden oder Klassen.

Form: end <name> oder end if, end while usw.
Sie ist optional und wird vom Compiler überprüft.

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

Geschweifte Klammern und Einrückung kombinieren

Sie können beide Schreibweisen frei kombinieren. Manche Teams verwenden bei verschachtelten Konstruktionen zur besseren Übersicht weiterhin geschweifte Klammern. Einrückungsregeln gelten nur dort, wo keine geschweiften Klammern vorhanden sind.

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)
  }

Häufige Probleme mit Einrückung

Einrückung ist bedeutungstragend, bleiben Sie daher konsistent.

Verwenden Sie Leerzeichen und mischen Sie keine Tabs mit Leerzeichen.
Eine falsch ausgerichtete Zeile kann unbemerkt aus einem Block herausfallen.
Der Doppelpunkt : wird für Template-Körper (Klassen/Objekte) benötigt, aber nicht für Methodenkörper nach =.

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

Argument-Syntax mit weniger geschweiften Klammern

Scala 3 erlaubt außerdem, ein Blockargument nach einem Doppelpunkt zu übergeben. items.foreach: x => eröffnet den eingerückten Lambda-Körper und vermeidet verschachtelte Klammern und geschweifte Klammern.

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)

Kurzer Check

Testen Sie Ihr Verständnis der signifikanten Einrückung.

Beantworte es in der interaktiven Lektion

Zusammenfassung

Sie haben die signifikante Einrückung in Scala 3 kennengelernt.

Blöcke können statt { } Einrückung verwenden.
Steuerstrukturen verwenden then, do und yield.
Klassen-, Objekt- und Trait-Körper werden mit einem Doppelpunkt : eröffnet.
end-Markierungen verdeutlichen das Ende langer Blöcke.
Beide Schreibweisen können kombiniert werden; achten Sie auf konsistente Abstände.

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

Kostenlos starten

Lerne Scala mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 39
Lektionen: 143

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Signifikante Einrückung“ kostenlos?

Ja — der vollständige Text von „Signifikante Einrückung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Scala for Backend Engineering & Functional Programming-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Scala for Backend Engineering & Functional Programming-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Signifikante Einrückung“?

Optionale geschweifte Klammern Du übst Scala for Backend Engineering & Functional Programming mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Scala for Backend Engineering & Functional Programming zu starten?

Keine Vorkenntnisse erforderlich. Scala for Backend Engineering & Functional Programming auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Signifikante Einrückung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Scala for Backend Engineering & Functional Programming-Lektion Code schreiben und ausführen?

Ja. Jede Scala for Backend Engineering & Functional Programming-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Scala for Backend Engineering & Functional Programming