EMZETT.
Login

Emzett Wiki

Scala: Typen, Kontrollfluss und Funktionen

Properties1
tagsprogrammiersprachen, scala

5 Min. Lesezeit

Kurz: Scala ist statisch typisiert mit starker Typinferenz. Alles ist ein Objekt, auch Zahlen.

Teil des Kurses Scala

Kapitel 2 von 8 im Kurs Scala. Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Typen

Scala ist statisch typisiert mit starker Typinferenz. Alles ist ein Objekt, auch Zahlen.

@main def main(): Unit =
  val i = 42
  val d = 3.14
  val s = "Text"
  val c = 'x'
  val b = true
  val l = 3_000_000_000L
  println(s"${i.getClass.getSimpleName} ${d.getClass.getSimpleName} ${s.getClass.getSimpleName} ${c.getClass.getSimpleName}")
  println(s"${7 / 2} ${7 % 3} ${7 / 2.0} ${math.pow(2, 10)} ${math.sqrt(144)} ${math.abs(-5)} ${math.max(3, 9)}")
  println(s"${i.toDouble} ${d.toInt} ${i.toString + "!"} ${"123".toInt + 1} ${"2.5".toDouble} ${"x".toIntOption} ${"7".toIntOption}")
  println(s"${5.max(3)} ${5.min(3)} ${10.toBinaryString} ${255.toHexString} ${i.isValidInt} ${1 to 5} ${(1 to 5).toList}")
 
  val text = "Hallo Welt"
  println(s"${text.length} ${text.toUpperCase} ${text.substring(0, 5)} ${text.contains("Welt")} ${text.indexOf("W")}")
  println(s"${text.split(" ").toList} ${text.replace("l", "L")} ${text.reverse} ${text.take(3)} ${text.drop(6)} ${"ab" * 3}")
  println(s"${text.charAt(0)} ${text(1)} ${text.startsWith("Hal")} ${"  trim ".trim} ${text.toList.take(3)} ${text.count(_ == 'l')}")
  println("Mehrzeilig:\n" + """Zeile 1
    |Zeile 2 mit "Anführungszeichen"
    |""".stripMargin)

Ausgabe:

int double String char
3 1 3.5 1024.0 12.0 5 9
42.0 3 42! 124 2.5 None Some(7)
5 3 1010 ff true Range 1 to 5 List(1, 2, 3, 4, 5)
10 HALLO WELT Hallo true 6
List(Hallo, Welt) HaLLo WeLt tleW ollaH Hal Welt ababab
H a true trim List(H, a, l) 3
Mehrzeilig:
Zeile 1
Zeile 2 mit "Anführungszeichen"

Optionen statt null

Scala vermeidet null: Ein möglicher fehlender Wert ist eine Option[T] (Some(x) oder None).

def finde(liste: List[Int], ziel: Int): Option[Int] =
  val idx = liste.indexOf(ziel)
  if idx >= 0 then Some(idx) else None
 
@main def main(): Unit =
  val liste = List(5, 8, 13, 21)
  val a = finde(liste, 13)
  val b = finde(liste, 99)
  println(s"$a $b")
  println(s"${a.getOrElse(-1)} ${b.getOrElse(-1)}")
  println(a.map(_ * 10))
  println(b.map(_ * 10))
  println(s"${a.isDefined} ${b.isEmpty}")
  a match
    case Some(i) => println(s"gefunden an $i")
    case None    => println("nicht gefunden")
  println(s"${liste.headOption} ${List.empty[Int].headOption}")
  println(Option("text").filter(_.length > 10))
  println(for x <- a; y <- Some(2) yield x * y)

Ausgabe:

Some(2) None
2 -1
Some(20)
None
true true
gefunden an 2
Some(5) None
None
Some(4)

Kontrollfluss

@main def main(): Unit =
  val punkte = 78
  if punkte >= 90 then println("sehr gut")
  else if punkte >= 75 then println("gut")
  else println("weiter üben")
 
  val note = punkte match                       // match ist ein mächtiges switch
    case p if p >= 90 => "A"
    case p if p >= 75 => "B"
    case _ => "C"
  println(note)
 
  val tag = 3
  tag match
    case 1 => println("Montag")
    case 2 | 3 | 4 => println("Mitte der Woche")
    case n if n >= 5 && n <= 7 => println("Ende der Woche")
    case _ => println("anderes")
 
  for i <- 1 to 3 do print(s"$i ")
  println()
  for i <- 10 to 1 by -4 do print(s"$i ")
  println()
  for i <- 0 until 3 do print(s"$i ")
  println()
  for (name, idx) <- List("rot", "grün", "blau").zipWithIndex do print(s"$idx:$name ")
  println()
  for x <- 1 to 10 if x % 3 == 0 do print(s"$x ")       // Filter in der Schleife
  println()
  var n = 3
  while n > 0 do
    print(s"$n ")
    n -= 1
  println()
  println(for x <- 1 to 5 yield x * x)                  // yield erzeugt eine Collection

Ausgabe:

gut
B
Mitte der Woche
1 2 3
10 6 2
0 1 2
0:rot 1:grün 2:blau
3 6 9
3 2 1
Vector(1, 4, 9, 16, 25)

Funktionen

def addiere(a: Int, b: Int): Int = a + b
def quadrat(x: Int) = x * x                                  // Rückgabetyp wird erschlossen
def gruss(name: String, anrede: String = "Hallo"): String = s"$anrede, $name!"
def summe(zahlen: Int*): Int = zahlen.sum                    // variable Argumente
def fakultaet(n: BigInt): BigInt = if n <= 1 then 1 else n * fakultaet(n - 1)
 
@scala.annotation.tailrec
def ggT(a: Int, b: Int): Int = if b == 0 then a else ggT(b, a % b)       // Endrekursion
 
def minMax(l: List[Int]): (Int, Int) = (l.min, l.max)         // Tupel als Rückgabe
 
val verdopple: Int => Int = x => x * 2                        // Funktion als Wert
def wendeAn(f: Int => Int, x: Int): Int = f(x)
def addierer(n: Int): Int => Int = x => x + n                 // Funktion als Rückgabe
 
@main def main(): Unit =
  println(s"${addiere(2, 3)} ${quadrat(7)} ${gruss("Mia")} ${gruss("Tom", "Hi")} ${gruss(anrede = "Servus", name = "Zoe")}")
  println(s"${summe(1, 2, 3, 4)} ${fakultaet(25)} ${ggT(48, 18)} ${minMax(List(4, 9, 1))}")
  println(s"${verdopple(21)} ${wendeAn(_ + 1, 41)} ${addierer(5)(10)}")
  val (lo, hi) = minMax(List(4, 9, 1, 7))
  println(s"$lo $hi")

Ausgabe:

5 49 Hallo, Mia! Hi, Tom! Servus, Zoe!
10 15511210043330985984000000 6 (1,9)
42 42 15
1 9

Merke

  • Statisch typisiert mit Inferenz; alles ist ein Objekt
  • Option[T] mit Some/None statt null
  • if/match sind Ausdrücke; for ... yield; Bereiche 1 to 5, until
  • Funktionen: def, Standardwerte, Int*, Funktionen als Werte, @tailrec

Übungsaufgabe

Schreibe FizzBuzz für 1 bis 30 mit match.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Einführung und erstes Programm

Weiter: Collections und Pattern Matching

Alle Kapitel: Scala im Überblick

Graphansicht

Backlinks