Swift-Tutorial Teil 4: Die vier Grundrechenarten

Swifts Operatoren

Ein Operator ist ein spezielles Symbol oder eine Kombination von speziellen Symbolen, die du dazu nutzen kannst, Werte zu prüfen, zu ändern oder zu kombinieren. Zum Beispiel addiert der Operator + zwei Zahlen miteinander, wie in let i = 1 + 2, wo i der Wert 3 zugewiesen wird.

Im Folgenden werden die wichtigsten Operatoren beschrieben.

Zuweisungsoperator

Der Zuweisungsoperator = weist einer Konstanten oder Variablen einen Wert zu. Betrachte dazu das nächste Beispiel:

let b = 10
var a = 5

print("a ist gleich \(a)")

a = b

print("a ist gleich \(a)")

Nach den ersten zwei Zeilen hat die Variable a den Wert 5 und die Konstante b den Wert 10. Mit der Zuweisung a = b wird der Variablen a der Wert der Variablen b zugewiesen, so dass a fortan den Wert 10 besitzt.

Während auf der linken Seite einer Zuweisung nur eine Variable oder eine Konstante stehen darf, kann die rechte Seite jeden Ausdruck enthalten, der einen Wert zurück liefert, der der links stehenden Variable oder Konstanten zugewiesen werden darf. Hier ein paar Beispiele:

var name = "Peter Pan"
var abstand = berechneAbstand(x: 10, y: 332)
var groesse = 35 - 3 - 5 

Da die hier gezeigten Variablen mit keinem expliziten Typ definiert worden sind, haben sie automatisch den Typ, des zugewiesenen Wertes. name ist somit vom Typ String, abstand vom Typ Int (wir nehmen hier einfach an, dass die Funktion berechneAbstand ein Int zurückliefert) und groesse ebenfalls Int.

Arithmetische Operatoren

Swift unterstützt die vier wichtigsten arithmetische Operatoren Addition (+), Subtraktion (-), Multiplikation (*) und Division (/) für alle Zahlentypen. Hier ein Beispiel:

let c : Int    = 13 + 14
let d : Int    = 36 - 9
let e : Double = 13.5 * 2
let f : Double = 54.0 / 3.0

Der Additionsoperator + kann zusätzlich dazu benutzt werden, um Zeichenketten aneinanderzuhängen, wie im folgendem Beispiel:

let gruss = "Hallo" + ", " + "Peter!"

Vergleichsoperatoren

Vergleichsoperatoren sind Operatoren, die Werte miteinander vergleichen und als Ergebnis wahr (true) oder falsch (false) zurückliefern. Wie im ersten Blog beschrieben, ist in Swift Bool der Typ, der boolsche Werte repräsentiert. Betrachte folgenden Sourcecode, in dem alle existierenden Vergleichsoperatoren beschrieben sind.

var a = 1
var b = 2

var isEqual          : Bool = a == b
var isNotEqual       : Bool = a != b
var isGreater        : Bool = a > b
var isLess           : Bool = a < b
var isGreaterOrEqual : Bool = a >= b
var isLessOrEqual    : Bool = a <= b

print(isEqual)
print(isNotEqual)
print(isGreater)
print(isLess)
print(isGreaterOrEqual)
print(isLessOrEqual)

Flow Control

Swift bietet eine Vielzahl von Kontrollfluss-Anweisungen an. Dazu gehören while-Schleifen, um eine Aufgabe mehrmals auszuführen; if-, guard- und switch-Anweisungen, um verschiedene Zweige des Codes in Abhängigkeit bestimmter Bedingungen auszuführen; und Anweisungen wie break und continue, um die Ausführung des Sourcecodes auf eine andere Stelle im Sourcecode springen zu lassen. In diesem Blog werden wir die klassische if-Anweisung kennenlernen, aber auch eine besondere Erweiterung daraus, die sich Optional Binding nennt.

Die if-Anweisung

Es ist oft sinnvoll, Teile des Sourceodes unter bestimmten Bedingungen auszuführen. Möglicherweise möchtest du einen speziellen Sourcecode nur dann ausführen, wenn ein Fehler auftritt, oder eine Meldung anzeigen, wenn ein Wert zu hoch oder zu niedrig wird. Um dies zu erreichen, kannst Du die Ausführung von Sourcecode mithilfe der if-Anweisung an eine Bedingung knüpfen. Betrachte folgendes Beispiel:

var temperatur = 25

if (temperatur <= 30) {
    print("Hey, es ist zu kalt!")
}

In dieser simplen if-Anweisung wird überprüft, ob der Wert der Variablen gleich oder kleiner als 30 ist. Wenn das der Fall ist (und hier ist es ja so), soll der Sourcecode zwischen den geschweiften Klammern ausgeführt werden. In diesem Fall wird der Satz “Hey, es ist zu kalt!” ausgegeben. Wenn jedoch der Wert der Variablen größer als 30 ist, wird das Programm hinter der schließenden Klammer fortgeführt.

Die erweiterte Form einer if-Anweisung bietet die Möglichkeit, auch für denn Fall, dass die Bedingung nicht erfüllt wird, einen speziellen Sourcecode auszuführen.

var temperatur = 25

if (temperatur == 30) {
    print("Hey, es ist zu kalt!")
} else {
    print("Endlich gutes Wetter!")
}

Hier wird in dem Fall, dass die Bedingung nicht erfüllt ist, der Sourcecode ausgeführt, der hinter dem else zwischen den geschweiften Klammern enthalten ist. 

Optionals

Hin und wieder gibt es die Situation, dass eine Funktion nicht in jedem Fall einen Wert zurückliefern kann. Ein Beispiel für solch einen Fall ist der Initilizer Double(String). Zur Erinnerung: Double(String) ist eine spezielle Funktion (Initializer), die ein Double mit dem Wert des übergebenen Strings als Zahl zurückliefert. Das bedeutet, dass Double(“1”) für uns die Verwandlung des übergebenen Strings in ein Double durchführt. In Blog 3 hatten wir diesen Initializer kennengelernt.

Wenn ich nun fälschlicherweise eine Zeichenkette übergebe, die keine Zahl darstellt, sagen wir “Kaninchenstall”, kann mir die Funktion Double(“Kaninchenstall”) natürlich keine Zahl zurückliefern. Was tut man in solchen Fällen? Wäre es nicht schön, wenn eine Funktion in solchen Fällen schlicht und einfach keinen Wert zurückliefert? Wie würde die Rückgabe dann konkret aussehen?

Nun, Swift kennt das Konzept eines sogenannten Optionals, das anstelle des eigentlich erwarteten Wertes zurückgeliefert wird. Betrachte folgendes Beispiel:

let zahl : Double = Double("1")

Wenn du den obigen Sourcecode eingibst, wird Xcode dir folgenden Fehler anzeigen: Value of optional type ‚Double?‘ not unwrapped; did you mean to use '!' or '?'?

Um diese Fehlermeldung zu verstehen, muss du zunächst genau wissen, was ein Optional ist. Da der Initializer Double(string) möglicherweise fehlschlägt, gibt er ein optionales Double zurück, anstatt ein Double. Ein optionales Double wird als Double? geschrieben, nicht Double. Das Fragezeichen zeigt an, dass der darin enthaltene Wert optional ist, d. h. dass er einen Double-Wert oder gar keinen Wert enthalten kann.

Im obigen Beispiel ist die Konstante zahl explizit als Double deklariert. Der Initializer liefert aber ein optionales Double, also ein Double? zurück. Und da Swift eine typsichere Programmiersprache ist, führt dies zu einem Fehler.

Um diesen Fehler zu korrigieren, gibt es zwei Lösungswege. Die erste Möglichkeit, den Fehler los zu werden, besteht darin, den Typ der Konstante von Double auf Double? zu verändern, sodass der Typ deklariert wird, der auch vom Initializer zurückgeliefert wird. Das obere Beispiel kannst Du folgendermaßen ändern:

let zahl : Double? = Double("1")

Diese Art der Deklaration und Definition führt dazu, dass die Konstante zahl den Wert 1 erhält. Und was passiert, wenn wir nicht “1” übergeben, sondern “Kaninchenstall”?

let zahl : Double? = Double("Kaninchenstall")

Auch hier gibt es keinen Kompilierfehler. Dafür hat die Konstante zahl jetzt den Wert nil. nil ist ein Wert der typlos ist und die Abwesenheit eines validen Wertes repräsentiert. Du kannst nil nicht mit nicht-optionalen Konstanten und Variablen verwenden. Wenn eine Konstante oder Variable in deinem Sourcecode unter bestimmten Bedingungen mit dem Fehlen eines Wertes arbeiten muss, deklariere ihn immer als optionalen Wert des entsprechenden Typs.

Doch nun zum zweiten Lösungsweg, um den Kompilierfehler zu beseitigen. Du musst dir darüber im Klaren sein (falls nicht schon geschehen), dass ein Optional nicht den erwartete Wert darstellt, sondern so etwas ist, wie einen Briefumschlag, in dem der eigentliche Wert enthalten ist.

Das bedeutet im Umkehrschluss, dass du immer den Wert aus dem Optional herausnehmen musst, bevor du den Wert verwendest. Betrachte dazu folgendes Beispiel:

let zahl1 : Double? = Double("1")
let zahl2 : Double? = Double("2")

print(zahl1 + zahl2)

Der Compiler wir dir hier einen Fehler anzeigen: Binary operator '+' cannot be applied to two 'Double?' operands. Dieser Fehler sagt aus, dass der Operator + nicht auf Optionals angewendet werden darf, denn genau das enthalten die zwei Konstanten zahl1 und zahl2. Eigentlich logisch, zudem wollen wir ja nicht zwei Optionals addieren, sondern zwei Zahlen. Um an den eigentlichen Wert heran zu kommen, muss man das Zeichen ! nutzen. Das geschieht dann folgendermaßen:

print(zahl1! + zahl2!)

Das Ausrufezeichen, gesetzt hinter einer bereits initialisierten Variablen oder Konstanten, bewirkt das Auspacken (unwrapping) des Wertes. Man kann aber auch einen Wert, der zugewiesen wird, kurz vorher auspacken, wie im nächsten Beispiel:

let zahl1 : Double = Double("1")!
let zahl2 : Double = Double("2")!

print(zahl1 + zahl2)

Hier wird der zurückgelieferte Wert von Double(“1”) zuerst ausgepackt und dann der Variablen zahl1 zugewiesen. Deswegen muss hier auch der Typ Double sein und nicht Double?.

So weit, so gut! Wir wissen jetzt, was ein Optional ist und wie es verwendet werden kann. Doch beachte noch eins: Der Versuch, mit ! auf einen nicht vorhandenen optionalen Wert zuzugreifen, löst einen Laufzeitfehler aus. Stelle bitte immer sicher, dass ein optionaler Wert einen Wert enthält, bevor Du ! verwenden, um seinen Wert auszupacken.

Als letztes werde ich dir erklären, wie man eine Funktion programmiert, die einen optionalen Wert zurückliefert.

Angenommen wir möchten eine Funktion implementieren, die eine Zeichenkette in eine Zahl umwandelt, und nennen diese Funktion kurzerhand convertToInt(value : String). Die Implementierung dieser Funktion ist zwar trivial, da wir bereits wissen, dass der Initializer Int(String) genau diese Umwandlung durchführt, aber es geht ja nur darum, zu zeigen, wie ein Optional als Rückgabewert deklariert wird. Betrachte folgenden Sourcecode:

func convertToInt(value : String) -> Int? {
    return Int(value)
}

Wie du siehst, wird einfach als Rückgabewert nicht Int, sondern Int? deklariert. Und da der Initializer genau das zurückliefert, sind wir fein raus.

Optional Binding

Mit Hilfe des Optional Bindings kannst du herausfinden, ob ein Optional einen Wert enthält, und wenn ja, diesen Wert als temporäre Konstante oder Variable zur Verfügung stellen. Ein Optional Binding kann mit if-Anweisungen verwendet werden. Am Besten wir schauen uns ein Beispiel an:

func convertToInt(value : String) -> Int? {
    return Int(value)
}

Wie du sehen kannst, wird direkt hinter dem if das Schlüsselwort let geschrieben, womit die Konstante a deklariert und mit Int(zahl) initialisiert wird. Anders gesagt, zuerst wird der Konstanten a ein Wert zugewiesen und danach wird überprüft, ob der übergebene Wert nil ist oder nicht. Wenn a einen gültigen Wert bekommt, ist automatisch die Konstante a innerhalb der geschweiften Klammern vor dem else definiert. Im oberen Beispiel wird daher der Text “Die Zahl ist 1” ausgegeben.

Du kannst gerne den der Variable zahl zugewiesenen Wert auf “Hallo” ändern. In diesem Falle wir der else Zweig ausgeführt.