Variablen, Konstanten & Optionals

Swifts Typ-System ist streng, aber ausdrucksstark. Der Fokus liegt auf Sicherheit - besonders durch Optionals.

let und var

let name = "Anna"        // Konstante
var alter = 28           // Variable

alter = 29               // OK
name = "Max"             // FEHLER - name ist Konstante

Faustregel: Nimm let, bis der Compiler dir sagt, dass du var brauchst.

Typ-Inferenz vs. explizite Typen

Swift leitet Typen aus dem Wert ab:

let name = "Anna"        // String
let alter = 28           // Int
let pi = 3.14            // Double
let aktiv = true         // Bool

Oder explizit:

let name: String = "Anna"
let alter: Int = 28
let pi: Double = 3.14

Explizite Typen sind hilfreich, wenn die Inferenz nicht eindeutig ist (oder du einen spezifischen Typ willst):

let kleineZahl: Int32 = 42
let preis: Float = 19.99

Primitive Typen

Typ	Beschreibung
Int	Ganzzahl (systemabhaengig, meist 64-Bit)
Double	64-Bit Fliesskomma (Standard)
Float	32-Bit Fliesskomma
Bool	true / false
String	Unicode-String
Character	Ein einzelnes Zeichen

Zahlen

let ganz: Int = 42
let dezimal: Double = 3.14

// Mit Unterstrichen zur Lesbarkeit
let million = 1_000_000
let budget = 5_000.50

Strings

let name = "Anna"
let mehrzeilig = """
    Zeile 1
    Zeile 2
    Zeile 3
    """

// Interpolation
let gruss = "Hallo, \(name)!"

// Methoden
name.count              // 4
name.uppercased()       // "ANNA"
name.contains("n")      // true
name.isEmpty            // false

Character

let buchstabe: Character = "A"
let emoji: Character = "🍎"

Tupel

Mehrere Werte gebuendelt:

let person = (name: "Anna", alter: 28)
print(person.name)       // "Anna"
print(person.0)          // "Anna" - Index-Zugriff

let (name, alter) = person  // Destrukturierung

Typkonvertierung

Swift ist streng - keine impliziten Konvertierungen:

let i = 5
let d = 3.14

// let ergebnis = i + d        // FEHLER
let ergebnis = Double(i) + d    // OK

let text = "42"
let zahl = Int(text)            // Int? (Optional, weil Konvertierung scheitern kann)

Optionals - das Herzstueck

Optionals sind Swifts Antwort auf null-Pointer-Fehler. Ein Wert ist entweder da (some(T)) oder nicht (nil).

Optional deklarieren

var name: String? = "Anna"   // kann Wert oder nil sein
name = nil                   // OK

String? ist die Kurzform fuer Optional<String>.

Warum Optionals?

var alter: Int? = nil

// alter + 10                  // FEHLER - Compiler zwingt dich, nil zu behandeln

Swift macht “koennte nil sein” im Typ sichtbar. Du kannst nicht einfach darauf zugreifen - du musst entpacken.

Unwrapping - die verschiedenen Wege

1. Optional Binding mit if let

let maybeName: String? = "Anna"

if let name = maybeName {
    print("Hallo, \(name)!") // name ist hier ein normaler String
} else {
    print("Kein Name")
}

2. guard let fuer frueh-Ausstiege

Perfekt am Anfang von Funktionen:

func begruessen(maybeName: String?) {
    guard let name = maybeName else {
        print("Kein Name")
        return
    }
    // Ab hier ist `name` garantiert vorhanden
    print("Hallo, \(name)!")
}

3. Nil Coalescing Operator ??

Liefert einen Default, falls nil:

let name = maybeName ?? "Fremder"
print("Hallo, \(name)!")

4. Optional Chaining ?.

Greife auf Member eines Optionals zu - ohne Crash:

let laenge = maybeName?.count  // Int? (nil, wenn maybeName nil ist)

Funktioniert tief verschachtelt:

let erstesZeichen = maybeName?.uppercased().first

5. Forced Unwrapping !

let name = maybeName!  // crasht wenn nil

Vorsicht: Das ist gefaehrlich. Nutze nur, wenn du 100% sicher bist. Meistens gibt es bessere Alternativen.

if let mit mehreren Optionals

Kuerzere Form ab Swift 5.7:

if let name, let alter {
    print("\(name), \(alter)")
}

Oder klassisch:

if let name = maybeName, let alter = maybeAlter {
    print("\(name), \(alter)")
}

Collections (Vorblick)

Array

var namen: [String] = ["Max", "Anna", "Leo"]
namen.append("Tim")
print(namen[0])          // "Max"
print(namen.count)       // 4

Dictionary

var alter: [String: Int] = [
    "Anna": 28,
    "Max": 34
]
alter["Leo"] = 22
print(alter["Anna"])      // Optional(28)

Set

let farben: Set<String> = ["Rot", "Gruen", "Blau"]

Konstanten ausserhalb von Funktionen

Top-Level-Konstanten wie in Python/TypeScript:

let appVersion = "1.0.0"
let maxBenutzer = 100

In Klassen/Structs unterscheidet Swift zwischen static (Typ-Ebene) und Instanz-Properties - dazu spaeter mehr.

Zusammenfassung

• let fuer Konstanten, var fuer Variablen - bevorzuge let
• Typ-Inferenz macht explizite Typen oft unnoetig
• Optionals machen nil-Moeglichkeit im Typ sichtbar
• Unwrap mit if let, guard let, ?? oder ?. - selten mit !
• Strings haben Interpolation mit \(...)

Im naechsten Kapitel: Kontrollstrukturen - inklusive Swifts beruehmten switch.