Kontrollstrukturen in Swift

Swift hat die klassischen Kontrollstrukturen - aber switch ist besonders maechtig und if kann Optionals elegant behandeln.

if / else

let alter = 18

if alter >= 18 {
    print("Volljaehrig")
} else if alter >= 16 {
    print("Fast volljaehrig")
} else {
    print("Zu jung")
}

Regeln:

• Keine Klammern um die Bedingung
• Bloecke {} sind Pflicht, auch bei einer Zeile
• Bedingungen muessen Bool liefern

Ternaerer Operator

let text = alter >= 18 ? "volljaehrig" : "minderjaehrig"

Optional Binding in if

Eines der haeufigsten Muster in Swift:

let maybeName: String? = "Anna"

if let name = maybeName {
    print("Hallo, \(name)!")
}

// Mehrere auf einmal
if let name = maybeName, let alter = maybeAlter, alter >= 18 {
    print("\(name) ist volljaehrig")
}

guard

guard ist wie ein invertiertes if - speziell fuer frueh-Ausstiege:

func verarbeite(eingabe: String?) {
    guard let text = eingabe, !text.isEmpty else {
        print("Leere Eingabe")
        return
    }

    // Ab hier ist `text` ein nicht-leerer String
    print("Laenge: \(text.count)")
}

Der else-Block muss die aktuelle Funktion / den Scope verlassen (mit return, throw, continue, break oder fatalError).

switch - Swifts Superkraft

switch in Swift ist maechtiger als in C/Java. Es ist exhaustiv - der Compiler prueft, dass alle Faelle abgedeckt sind.

Einfacher Switch

let tag = "Dienstag"

switch tag {
case "Montag":
    print("Wochenstart")
case "Dienstag", "Mittwoch", "Donnerstag":
    print("Mitte der Woche")
case "Freitag":
    print("Bald Wochenende")
default:
    print("Wochenende")
}

Kein Fall-Through wie in C - jeder case endet automatisch.

Bereiche im Switch

let punkte = 85

switch punkte {
case 90...100:
    print("A")
case 80..<90:
    print("B")
case 70..<80:
    print("C")
case 0..<70:
    print("Durchgefallen")
default:
    print("Ungueltig")
}

• 90...100 ist inklusiv (ClosedRange)
• 80..<90 ist exklusiv rechts (Range)

Tuple-Matching

let punkt = (3, 0)

switch punkt {
case (0, 0):
    print("Ursprung")
case (_, 0):
    print("Auf X-Achse")
case (0, _):
    print("Auf Y-Achse")
case (-5...5, -5...5):
    print("Nahe am Ursprung")
default:
    print("Irgendwo")
}

Value Binding

switch punkt {
case (let x, 0):
    print("X-Achse bei \(x)")
case (0, let y):
    print("Y-Achse bei \(y)")
case let (x, y):
    print("Punkt bei (\(x), \(y))")
}

where-Klausel

Zusaetzliche Bedingungen:

switch (x, y) {
case let (x, y) where x == y:
    print("Auf Diagonale")
case let (x, y) where x == -y:
    print("Anti-Diagonale")
case let (x, y):
    print("Bei (\(x), \(y))")
}

for-in

Ueber eine Sammlung

let namen = ["Max", "Anna", "Leo"]

for name in namen {
    print(name)
}

Mit Index

for (i, name) in namen.enumerated() {
    print("\(i): \(name)")
}

Ueber Ranges

for i in 1...5 {
    print(i) // 1, 2, 3, 4, 5
}

for i in 0..<10 where i % 2 == 0 {
    print(i) // 0, 2, 4, 6, 8
}

Ueber ein Dictionary

let alter = ["Anna": 28, "Max": 34]

for (name, jahre) in alter {
    print("\(name): \(jahre)")
}

Reihenfolge ist nicht garantiert.

stride

Schleife mit Schrittweite:

for i in stride(from: 0, to: 20, by: 5) {
    print(i) // 0, 5, 10, 15
}

while und repeat-while

var n = 10
while n > 0 {
    print(n)
    n -= 1
}

// Laeuft mindestens einmal
repeat {
    print("Hallo")
} while false

break und continue

for i in 1...10 {
    if i % 2 == 0 { continue }
    if i > 7 { break }
    print(i) // 1, 3, 5, 7
}

Labels

aussen: for x in 0..<5 {
    for y in 0..<5 {
        if x + y == 4 {
            break aussen
        }
    }
}

fallthrough (falls doch noetig)

Wenn du explizit in den naechsten Case “durchfallen” willst:

switch n {
case 1:
    print("Eins")
    fallthrough
case 2:
    print("Zwei oder eins")
default:
    break
}

Selten gebraucht - meistens ist die Gruppierung mit , im Case (case 1, 2:) besser.

Zusammenfassung

• if / else mit Optional Binding
• guard let ... else { return } fuer frueh-Ausstiege
• switch ist exhaustiv, unterstuetzt Ranges, Tupel, Value Binding und where
• for in ueber Collections, Ranges, enumerated, Dictionaries
• Kein impliziter Fall-Through im Switch

Im naechsten Kapitel: Funktionen und Closures - Swifts ausdrucksstarke Sprachmittel fuer Logik.