Variablen und Typen in Swift

let und var

Mit let legst du eine Konstante an: Der Wert wird einmal festgelegt und ändert sich nie. Mit var legst du eine Variable an, die du später neu belegen darfst.

let sprache = "Swift"        // Konstante: wird nie wieder geändert
var lektionen = 3            // Variable: darf sich ändern

lektionen += 1
print("\(sprache): \(lektionen) Lektionen geschafft")

let pi: Double = 3.14159     // Typ ausdrücklich angegeben
let radius = 2.0             // Typ abgeleitet: Double
print("Kreisfläche:", pi * radius * radius)

Swift: 4 Lektionen geschafft
Kreisfläche: 12.56636

Die Faustregel: Nimm immer let. Wechsle zu var erst, wenn du den Wert wirklich ändern musst. Code mit vielen Konstanten ist leichter zu lesen, denn du musst beim Lesen nicht verfolgen, wo sich ein Wert noch ändern könnte. Der Compiler hilft dabei: Wenn du in einer Funktion var schreibst, die Variable aber nie änderst, schlägt er dir mit einer Warnung let vor:

func begruessung() -> String {
    var text = "Moin"
    return text
}

var-nie-geaendert.swift:2:9: warning: variable 'text' was never mutated; consider changing to 'let' constant [#VariableNeverMutated]
1 | func begruessung() -> String {
2 |     var text = "Moin"
  |         `- warning: variable 'text' was never mutated; consider changing to 'let' constant [#VariableNeverMutated]
3 |     return text
4 | }

[#VariableNeverMutated]: <https://docs.swift.org/compiler/documentation/diagnostics/variable-never-mutated>

Wer versucht, eine Konstante zu ändern, bekommt keinen Laufzeitfehler, sondern das Programm wird gar nicht erst übersetzt:

let kapitel = 1
kapitel = 2

let-aendern.swift:2:1: error: cannot assign to value: 'kapitel' is a 'let' constant
1 | let kapitel = 1
  | `- note: change 'let' to 'var' to make it mutable
2 | kapitel = 2
  | `- error: cannot assign to value: 'kapitel' is a 'let' constant
3 |

Die Meldung nennt die Zeile, den Namen und gleich die Lösung im note: aus let ein var machen. So sehen fast alle Swift-Fehlermeldungen aus: eine error-Zeile mit dem Problem und darunter note-Zeilen mit Hinweisen.

Typen und Typableitung

Jeder Wert in Swift hat genau einen Typ. Die wichtigsten Grundtypen:

Meist musst du den Typ nicht hinschreiben. Aus let radius = 2.0 leitet der Compiler Double ab, aus let anzahl = 7 wird Int. Eine ausdrückliche Typangabe mit Doppelpunkt brauchst du, wenn der Compiler den Typ nicht ableiten kann oder wenn du einen anderen willst als den naheliegenden, zum Beispiel let pi: Double = 3 statt eines Int.

let anzahl: Int = 7
let preis: Double = 4.5
let bezahlt: Bool = false
let gruss: String = "Moin"
let initial: Character = "S"

// Swift wandelt Zahlen nie stillschweigend um. Du entscheidest:
let gesamt = Double(anzahl) * preis
print("Gesamt: \(gesamt)")

// Aus Text wird nur vielleicht eine Zahl, daher ein Optional (Int?)
let eingabe = "42"
let zahl = Int(eingabe)
print(zahl ?? 0)

print(type(of: anzahl), type(of: preis), type(of: bezahlt), type(of: gruss), type(of: initial))
print(Int.max)

Gesamt: 31.5
42
Int Double Bool String Character
9223372036854775807

type(of:) zeigt dir den Typ eines Werts. Das ist beim Lernen praktisch, wenn du unsicher bist, was der Compiler abgeleitet hat.

Statische Typisierung

Swift ist statisch typisiert: Der Typ jedes Werts steht schon beim Übersetzen fest und wird geprüft, bevor das Programm läuft. Sprachen wie Python oder JavaScript prüfen Typen dagegen erst zur Laufzeit. Der praktische Unterschied: In Swift findest du viele Fehler, bevor dein Programm überhaupt startet.

Dazu gehört, dass Swift Zahlen nie stillschweigend umwandelt. Eine ganze Zahl mal eine Kommazahl ergibt in vielen Sprachen einfach eine Kommazahl. In Swift ist es ein Fehler:

let stueck = 3
let preis = 2.5
let summe = stueck * preis

typen-mischen.swift:3:20: error: binary operator '*' cannot be applied to operands of type 'Int' and 'Double'
1 | let stueck = 3
2 | let preis = 2.5
3 | let summe = stueck * preis
  |                    |- error: binary operator '*' cannot be applied to operands of type 'Int' and 'Double'
  |                    `- note: overloads for '*' exist with these partially matching parameter lists: (Double, Double), (Duration, Double), (Int, Int)
4 |

Die note erklärt die Ursache: Es gibt den Operator * für zwei Double oder für zwei Int, aber nicht für eine Mischung. Du entscheidest selbst, was gemeint ist, und schreibst es hin: Double(stueck) * preis. Das wirkt am Anfang umständlich. Es verhindert aber Fehler wie das unbemerkte Abschneiden von Nachkommastellen, die in Sprachen mit automatischer Umwandlung schwer zu finden sind.

Die Umwandlung in die andere Richtung, von Text in eine Zahl, kann scheitern: Int("sieben") hat kein sinnvolles Ergebnis. Deshalb liefert Int(_:) keinen Int, sondern einen Int?, ein Optional. Im Beispiel oben sorgt ?? 0 dafür, dass bei einem Fehlschlag 0 herauskommt. Optionals bekommen später eine eigene Lektion; merk dir hier nur, dass das Fragezeichen „vielleicht kein Wert“ bedeutet.

Zahlen haben Grenzen

Ein Int ist auf heutigen 64-Bit-Systemen 64 Bit groß; das Beispiel oben zeigt mit Int.max den größten Wert. Kleinere Typen wie Int8 reichen nur von −128 bis 127. Was passiert, wenn eine Rechnung diese Grenze überschreitet?

var punkte: Int8 = 120
for _ in 1...10 {
    punkte += 1
}
print(punkte)

*** Swift runtime failure: arithmetic overflow ***

Swift bricht das Programm ab, statt mit einem falschen Wert weiterzurechnen. Das ist Absicht: Ein Überlauf ist fast immer ein Fehler im Programm, und ein Abbruch an der richtigen Stelle ist leichter zu finden als eine falsche Zahl, die sich durch das Programm zieht. Wenn du einen Überlauf ausdrücklich willst, etwa für Prüfsummen, gibt es eigene Operatoren wie &+ (siehe Advanced Operators).

Häufige Fehler

cannot assign to value: '…' is a 'let' constant. Du änderst eine Konstante. Prüfe, ob die Änderung wirklich nötig ist; wenn ja, mach aus let ein var.

binary operator '*' cannot be applied to operands of type 'Int' and 'Double'. Zwei Typen gemischt. Wandle einen der Werte ausdrücklich um.

cannot convert value of type 'String' to specified type 'Int'. Du weist einen Text einer Zahl zu. Text wird mit Int(text) zur Zahl und liefert dabei ein Optional.

Alle Meldungen mit Erklärung findest du unter Swift-Fehlermeldungen verstehen.

Übungen

1. Lege eine Konstante für einen Nettopreis in Cent (Int) und eine für den Steuersatz (Double, zum Beispiel 0.19) an. Berechne den Bruttopreis in Euro als Double und gib ihn aus.
2. Was gibt print(7 / 2) aus, und was print(7.0 / 2)? Überlege zuerst, dann probiere es aus.

let nettoInCent = 2_490
let steuersatz = 0.19
let brutto = Double(nettoInCent) / 100 * (1 + steuersatz)
print("Brutto: \(brutto) €")

Brutto: 29.630999999999997 €

print(7 / 2)
print(7.0 / 2)
print(7 % 2)

3
3.5
1