Konstanten, Variablen und Typen

Das Problem: Werte merken

Stell dir vor, du schreibst ein kleines Programm, das deinen Kontostand ausgibt, dann eine Ausgabe abzieht und wieder den Kontostand ausgibt:

print(1250)
print(1250 - 80)

Das funktioniert, hat aber zwei Schwächen. Erstens: Was bedeutet 1250? Ohne Erklärung weiß das niemand. Zweitens: Ändert sich der Kontostand, musst du die Zahl an jeder Stelle einzeln anpassen und darfst keine vergessen.

Was wir brauchen, ist eine Möglichkeit, sich einen Wert unter einem Namen zu merken.

Schachteln mit Namen

Stell dir eine beschriftete Schachtel vor. Auf dem Etikett steht ein Name, zum Beispiel kontostand. In der Schachtel liegt ein Wert, zum Beispiel 1250. Immer wenn du den Namen benutzt, holt Swift den Wert aus der Schachtel.

In Swift gibt es zwei Sorten von Schachteln:

• let: eine Konstante. Einmal befüllt, bleibt der Inhalt für immer gleich.
• var: eine Variable. Der Inhalt darf später ausgetauscht werden.

let geburtsjahr = 1990
var kontostand = 1250

print(kontostand)        // 1250
kontostand = kontostand - 80
print(kontostand)        // 1170

Lies kontostand = kontostand - 80 so: „Nimm den aktuellen Kontostand, zieh 80 ab und leg das Ergebnis wieder in die Schachtel kontostand.“ Das = bedeutet in Swift also nicht „ist gleich“ wie in Mathe, sondern „bekommt den Wert“.

let oder var?

Versuch einmal, eine Konstante zu ändern:

let geburtsjahr = 1990
geburtsjahr = 1991

Xcode verhindert die Änderung, und das ist gewollt. Dein Geburtsjahr ändert sich nie. Wenn es sich im Code doch ändert, ist das ein Fehler, und Swift fängt ihn für dich ab.

Warum dieser Aufwand? Weil Code mit vielen Konstanten leichter zu verstehen ist. Siehst du let, weißt du sofort: Dieser Wert bleibt so. Du musst nicht den ganzen Code durchsuchen, ob er irgendwo verändert wird.

Gute Namen

Namen in Swift folgen ein paar Regeln:

• Sie beginnen mit einem Kleinbuchstaben.
• Besteht ein Name aus mehreren Wörtern, beginnt jedes weitere Wort mit einem Großbuchstaben: kontostandAktuell, anzahlNutzer. Diese Schreibweise heißt camelCase, weil die Großbuchstaben wie Kamelhöcker herausragen.
• Leerzeichen und Bindestriche sind nicht erlaubt.
• Groß- und Kleinschreibung zählt: name und Name sind zwei verschiedene Dinge.

Ein guter Name beschreibt, was in der Schachtel steckt: userAge ist besser als a, x oder zahl1.

Typen: Was steckt in der Schachtel?

Jeder Wert in Swift hat einen Typ. Der Typ sagt, um welche Art von Wert es sich handelt. Die vier wichtigsten:

let age = 34              // Int
let price = 19.99         // Double
let name = "Anna"         // String
let isLoggedIn = true     // Bool

Typableitung: Swift denkt mit

Im Beispiel oben hast du nirgends geschrieben, welcher Typ gemeint ist. Swift erkennt ihn selbst am Wert:

• 34 sieht aus wie eine ganze Zahl → Int
• 19.99 hat einen Punkt → Double
• "Anna" steht in Anführungszeichen → String
• true → Bool

Das nennt man Typableitung (englisch type inference). Du kannst den Typ aber auch ausdrücklich angeben, mit einem Doppelpunkt nach dem Namen:

let age: Int = 34
let price: Double = 19.99
let name: String = "Anna"
let isLoggedIn: Bool = true

Lies let age: Int = 34 als: „Eine Konstante age vom Typ Int mit dem Wert 34.“

Wann schreibt man den Typ dazu?

• Meistens nicht, denn Swift erkennt ihn ja.
• Wenn Swift sonst etwas anderes erraten würde: let temperature: Double = 20 macht aus der 20 eine Kommazahl.
• Wenn du den Wert erst später festlegst:

let greeting: String
greeting = "Guten Morgen"

Swift ist streng, und das ist gut so

Eine Schachtel hat für immer denselben Typ. In eine Int-Schachtel passt kein Text:

var score = 10
score = "zehn"

Auch Int und Double lassen sich nicht einfach mischen:

let apples = 3
let pricePerApple = 0.5
let total = apples * pricePerApple

Du musst Swift ausdrücklich sagen, dass die ganze Zahl als Kommazahl behandelt werden soll:

let total = Double(apples) * pricePerApple   // 1.5

Double(apples) erzeugt aus der 3 die Kommazahl 3.0. Das nennt man Typumwandlung.

Das wirkt am Anfang pingelig. In anderen Sprachen „klappt es einfach“. Aber genau dort entstehen dann Fehler, die erst auffallen, wenn die App schon bei Nutzern läuft. Swift findet solche Fehler, bevor dein Programm überhaupt startet. Das ist einer der größten Vorteile der Sprache.

Typische Fehler

Konstante ändern

Du willst einen Wert ändern, der mit let angelegt wurde. Wenn er sich wirklich ändern soll: var daraus machen.

Name doppelt vergeben

var score = 10
var score = 20

var und let legen eine neue Schachtel an. Willst du nur den Wert ändern, lass das var beim zweiten Mal weg: score = 20.

Variable benutzen, bevor sie existiert

print(total)
let total = 100

Code läuft von oben nach unten. In der ersten Zeile gibt es total noch nicht.

Warnung: Variable wird nie verändert

Keine Katastrophe, aber ein Hinweis: Mach aus var ein let.

FAQ

Übungen

var balance = 500.0

balance = balance - 12.5
print(balance)   // 487.5

balance = balance - 49.99
print(balance)   // 437.51

balance = balance - 100
print(balance)   // 337.51

let a = 7
let b = 9
let c = 8
let d = 10

let sum = a + b + c + d
let average = Double(sum) / 4.0
print(average)   // 8.5

Zusammenfassung

• let legt eine Konstante an, var eine Variable. Nimm immer zuerst let.
• = bedeutet „bekommt den Wert“.
• Namen in camelCase, aussagekräftig, auf Englisch.
• Die wichtigsten Typen: Int, Double, String, Bool.
• Swift leitet den Typ ab, du kannst ihn aber mit : Typ angeben.
• Ein Wert behält immer seinen Typ. Umwandeln geht mit z. B. Double(zahl).

Spickzettel

let name = "Anna"          // Konstante, Typ String
var score = 0              // Variable, Typ Int
score = 10                 // neuer Wert
let price: Double = 20     // Typ ausdrücklich angeben
let total = Double(3) * 0.5 // Typumwandlung
let isActive = true        // Bool