Swift: Kontrollstrukturen

In diesem Abschnitt schauen wir uns die Kontrollstrukturen in Swift - Verzweigungen und Schleifen - an.

Im Anschluss können wir mit Ein- und Mehrfachverzweigungen umgehen, wobei wir bei Mehrfachverzweigungen auch von einem Fall in den Nachfolgenden fallen (fallthrough) können. Außerdem können wir mit den Schleifen umgehen und innerhalb diese bei Bedarf abbrechen (break) oder erneut starten (continue).

Einfachverzweigung - if

Die Einfachverzweigung if ermöglicht es uns in Abhängigkeit zu einem Wahrheitswert einen Anweisungsblock genau einmal auszuführen. Eine Einfachverzweigung in Swift hat hierbei stets eine Anweisungsblock in geschweiften Klammern zur Folge, während die Bedingung ohne Klammern auskommt.

if Bedingung {
 Wahr-Bedingung-Anweisungen
}

Die Nutzung von runden Klammern für die Bedingung ist hierbei optional möglich, wie auch die Angabe von Anweisungen für den Fall, dass unser Bedingung falsch ist.

if (Bedingung) {
  Wahr-Bedingung-Anweisungen
}
else {
  Falsch-Bedingung-Anweisungen
}

Mehfachverzweigung switch

Die Mehrfachverzweigung switch ermöglicht es uns auf verschiedene Inhalte einer zu prüfenden Variablen zu reagieren. In Swift wird hierbei nach Abarbeitung des Bedingungsblocks die Ausführung der Mehrfachverzweigung grundsätzlich abgebrochen. Die Mehrfachverzweigung verhält sich somit anders als in Java oder C vergleichbar wie in COBOL (evaluate). Andere Vergleichswerte müssen mit einem default ebenfalls Anweisungen Ausführen.

switch Prüfwert {
case Vergleichswert 0:
  Anweisungen zu Vergleichswert 0
case Vergleichswert 1:
  Anweisungen zu Vergleichswert 1
default:
  Anweisungen für andere Vergleichswerte
}

Sollen mehrere Vergleichswerte identische Anweisungen ausführen, so werden diese nacheinander aufgeführt.

switch Prüfwert {
case Vergleichswert 0:
  Anweisungen zu Vergleichswert 0
case Vergleichswert 1:
  Anweisungen zu Vergleichswert 1
case Vergleichswert 2:
case Vergleichswert 3:
  Anweisungen zu Vergleichswert 2 und 3
default:
  Anweisungen für andere Vergleichswerte
}

Swift unterstützt bei der Mehrfachverzweigung zusätzlich das springen in den nachfolgenden Anweisungsblock analog zu Java und C mit Hilfe des Schlüsselwortes fallthrough.

switch Prüfwert {
case Vergleichswert 0:
  Anweisungen zu Vergleichswert 0
case Vergleichswert 1:
  Anweisungen zu Vergleichswert 1
case Vergleichswert 2:
case Vergleichswert 3:
  Anweisungen zu Vergleichswert 2 und 3
  fallthrough
case Vergleichswert 4:
  Anweisungen zu Vergleichswert 4 und zu Vergleichswert 2 und 3
default:
  Anweisungen für andere Vergleichswerte
}

Wenn wir mehrere Vergleichswerte in einem Bereich haben helfen uns Bereichsangaben. Optional werden auch runde Klammern um den Prüfwert unterstützt.

switch (Prüfwert) {
case Vergleichswert 0:
  Anweisungen zu Vergleichswert 0
case Vergleichswert 1:
  Anweisungen zu Vergleichswert 1
case Vergleichswert 2:
case Vergleichswert 3:
  Anweisungen zu Vergleichswert 2 und 3
  fallthrough
case Vergleichswert 4:
  Anweisungen zu Vergleichswert 4 und zu Vergleichswert 2 und 3
case Vergleichswert 5..Vergleichswert 10:
  Anweisungen für die Vergleichswert 5..10
default:
  Anweisungen für andere Vergleichswerte
}

Benötigen wir für einen Vergleichswert keine Anweisungen steht uns das Schlüsselwort break zur Seite.

switch Prüfwert {
case Vergleichswert 0:
  Anweisungen zu Vergleichswert 0
case Vergleichswert 1:
  Anweisungen zu Vergleichswert 1
case Vergleichswert 2:
case Vergleichswert 3:
  Anweisungen zu Vergleichswert 2 und 3
  fallthrough
case Vergleichswert 4:
  Anweisungen zu Vergleichswert 4 und zu Vergleichswert 2 und 3
case Vergleichswert 5..Vergleichswert 10:
  Anweisungen für die Vergleichswert 5..10
default:
  break
}

Schleife mit Vorabprüfung - while

Die Schleife mit Bindungsprüfung vor Ausführung while ermöglicht es uns in Abhängigkeit zu einem Wahrheitswerte einen Anweisungsblock mehrmals auszuführen. Der Anweisungsblock ist auch hier stets in geschweiften Klammern aufzuführen, während die Bedingung ohne Klammer auskommt.

while Bedingung {
  Wahr-Bedingung-Anweisungen
}

Optional kann die Bedingung in runden Klammern aufgeführt werden.

while (Bedingung) {
  Wahr-Bedingung-Anweisungen
}

Schleife mit Prüfung im Nachgang - do

Die Schleife mit Bindungsprüfung nach Ausführung do ermöglicht es uns in Abhängigkeit zu einem Wahrheitswerte einen Anweisungsblock mehrmals auszuführen. Der Anweisungsblock ist auch hier stets in geschweiften Klammern aufzuführen, während die Bedingung ohne Klammer auskommt.

do {
  Wahr-Bedingung-Anweisungen
}
while Bedingung

Optional kann die Bedingung in runden Klammern aufgeführt werden.

do {
  Wahr-Bedingung-Anweisungen
}
while (Bedingung)

Mit Hilfe des Schlüsselwortes continue können wir die Abarbeitung der nachfolgenden Anweisungen in einer Schleife verhindern und wieder zum Schleifenkopf springen

var nr = 0
do {
  nr++
  if nr < 10 {
    continue
  }
  println ("Nr. \(nr)")
} while 20 > nr

Wiederholgungsschleife for

Mit Hilfe der for Schleife können wir Anweisungen in Swift öfter ausführen.

for als Zählschleife

Althergebracht wird die for Schleife als Zählschleife verwendet

for var index = 0; index < 6; index++ {
  println ("Index Nr. \(index)")
}

oder auch mit einer Variablen, welche außerhalb definiert wurde, wobei die runden Klammern optional sind

var index = 0
for (; index < 6; index++) {
  println ("Index Nr. \(index)")
}

Die Zählschleife besteht somit aus einer optionalen Initialisierung gefolgt von einer Abbruchbedingung beendet von einer Anweisung. Anm. Obwohl im Apple Handbuch von einem Inkrement die Rede ist, können wir an der dritten Stelle auch beliebige andere Aufgaben durchführen, z.B. einer anderen Variablen einen Wert zuweisen. Das "Inkrement" ist jedoch nicht optional! Entsprechend können wir die Zählvariable auch im Anweisungsblock erhöhen

var index = 0
for ; index < 6; 1 {
  println ("Index Nr. \(index)")
  index++
}

Mit Hilfe des Schlüsselwortes break können wir eine Schleife z.B. for auch direkt aus den Anweisungsblock verlassen, auch wenn dies dem Prinzipien der strukturierten Programmierung widerspricht

for ; ; 1 {
  println ("Index Nr. \(index)")
  index++
  if 6 == index {
    break
  }
}

for als Iterationsschleife

Mit Hilfe der for Iterationsschleife können wir für die Elemente einer Menge einen Anweisungsblock ausführen. Diese Menge kann eine Bereichsangabe, eine Collection oder auch eine Zeichenkette sein.

Um eine Bereichsangabe zu verwenden, können wir eine Konstante - hier wurzel innerhalb des Schleifenkopfes deklarieren und in unserem Anweisungsblock verwenden

for wurzel in 1...8 {
  println("Das Quardrat von \(wurzel) ist \(wurzel*wurzel)")
}

Benötigen wir den Wert der Bereichsangabe nicht, steht uns der Unterstrich als Platzhalter bereit.

let echo = "Echo"
for _ in 1...3 {
  println (echo)
}

Schleifen können wir generell beliebig verschachtelt. Um eine Collection zu durchlaufen können wir im Falle einer einfachen Liste/Array die gleiche Syntax wie für einen Bereich verwenden. So können wir z.B. innerhalb einer for Schleife für einen Bereich eine Schleife für ein Array durchlaufen.

let minutes = [0,10,20,30,40,50]
println ("Abfahrt U-Bahn Brandenburger Tor")
println("4: 50")
for hour in 4...23 {
  print ("\(hour):")
  for minute in minutes {
    print (" \(minute)")
  }
  println()
}
println("0: 0 10 20 30 40")

Wir können aber auch komplexere Collections wie ein Dictionary durchlaufen. Die runden Klammern sind hier jedoch zwingend für den Compiler!

let nummernschild = ["B": "Berlin", "HH": "Hamburg", "TF": "Toller Fahrer", "R": "Regensburg"]
for (buchstabe, ort) in nummernschild {
  println("\(buchstabe) bedeutet \(ort)")
}

Und Zeichenketten? Zeichenketten sind eine (An)Sammlung von Zeichen, die wir wie eine andere Collection durchlaufen können.

let umlaute = "äüößÄÖÜ"
for zeichen in umlaute {
  println ("\(zeichen) ist ein deutscher Umlaut")
}