Swift: Operatoren

In diesem Abschnitt befassen wir uns mit Operatoren. Swift bietet neben den Standardoperatoren noch weitere, welche wir uns natürlich auch ansehen werden.

Der Zuweisungsoperator

Der wichtigste Operator ist der Zuweisungsoperator. Mit ihm weist man der linken Seite den Wert der rechten Seite zu.

let a = 5 // a hat den Wert 5
var b = 10 // b hat den Wert 10
b = a // b hat nun den Wert 5

Die arithmetischen Operatoren

Swift bietet, wie andere Programmiersprachen auch, einen Satz an arithmetischen Operatoren, welche für Integer- wie auch Float-Typen gleich sind.

let a = 2 + 3 // a = 5
let b = 5 - 10 // b = -5
let c = 5 * 9 // c = 45
let d = 7 / 3 // d = 2, da das Ergebnis von zwei Integer auch ein Integer ist
let e = 9.0 / 5.0 // e = 1.8, da jetzt das Ergebnis von zwei Double auch ein Double ist
let f = 9.0 / 5 // f = 1.8, hier nimmt Swift den Datentyp, der den geringsten Verlust bringt (Double)
let g = 9 / 5.0 // g = 1.8, genau das Gleiche wie zuvor

Eine Besonderheit stellt allerdings das Pluszeichen dar. Bei Strings und Chars verkettet das Pluszeichen den ersten Wert mit dem zweiten Wert (Konkatinieren).

let ab = "Hello" + " " + "World" // Hello World

let chr1: Char = 'A';
let chr2: Char = 'B'
let ausgabe1 = chr1 + chr2 // String "AB"
let space = ' '
let ausgabe2 = "Hello" + space + "World" // Hello World

Zudem gibt es noch den Rest-Operator (remainder). Dieser gibt, nur bei Integer und Long Zahlen, den Restwert zurück.

let x = 11 % 3 // 2
let y = 19.5 % 3 // 1.5

Für Ganzzahlen gibt es zusätzlich noch den Increment und Decrement Operator. Sie erhöhen oder erniedrigen den Wert einer Variablen um eins. Jenachdem, ob der Operator vor oder hinter der Variablen ist, erhöht sich der Wert vor oder nach dem Arbeiten mit der Variablen.

var a = 5 // a ist 5
let b = a++ // b ist auch 5
let c = a // c ist 6
let d = ++a // d ist 7

Wie man sieht, wird b erst der Wert von a zugewiesen (die 5) und erst dann wird a um eins erhöht. Bei d stehen die Pluszeichen vor a, weshalb a erst um eins erhöht, und dann d zugewiesen wird. Gleiches passiert natürlich auch mit zwei Minuszeichen, nur das der Wert um eins erniedrigt wird.

Vergleichsoperatoren

Natürlich müssen wir auch einmal verschiedenste Werte vergleichen. Dazu bedient man sich den Vergleichsoperatoren.

• == Ist gleich
• != Nicht gleich
• < Kleiner als
• > Größer als
• <= Kleiner gleich
• >= Größer gleich

Hier ein paar Beispiele:

let a = 1
let b = 1
let c = 2

a == b // 1 ist gleich 1 (true)
a == c // 1 ist gleich 2 (false)
a != b // 1 nicht gleich 1 (false)
a != c // 1 nicht gleich 2 (true)
a < b // 1 kleiner als 1 (false)
a < c // 1 kleiner als 2 (true)
a > b // 1 größer als 1 (false)
c > a // 2 größer als 1 (true)
a <= b // 1 ist kleiner oder gleich 1 (true)
c <= a // 2 ist kleiner oder gleich 1 (false)
a >= b // 1 ist größer oder gleich 1 (true)
c >= a // 2 ist größer oder gleich 1 (true)

Logische Operatoren

Logische Operatoren verknüpfen Wahrheitsbedingungen. Dabei sei gesagt, das Swift "short circuit" arbeitet. Das bedeutet, dass nur die nötigsten Bedingungen geprüft werden.

let a = true
let b = false
let c = a && b // false
let d = a || b // true

Bitoperatoren

Bitoperatoren vergleichen einzelne Bits (Nullen oder Einsen). Hierzu sollte man sich mit dem dualen Zahlensystem vertraut machen.