Typinferenz und explizite Typen

Swift ist eine *statisch typisierte* Sprache — jeder Wert besitzt einen zur Kompilierungszeit bekannten Typ. Sie müssen den Typ jedoch nur selten selbst angeben, da Swift ihn automatisch ableitet.

Swift untersucht den Wert auf der rechten Seite und leitet den Typ automatisch ab: ```swift let message = "Hello" // inferred as String let count = 42 // inferred as Int let price = 9.99 // inferred as Double ``` Eine Typannotation ist nicht erforderlich — der Compiler ermittelt den Typ selbst.

Sie können den Typ jederzeit mit einem Doppelpunkt explizit angeben: ```swift let message: String = "Hello" let count: Int = 42 let price: Double = 9.99 ``` Das ist hilfreich, wenn der abgeleitete Typ nicht dem gewünschten Typ entspricht.

Gleitkommaliterale werden standardmäßig als `Double` behandelt. Wenn Sie `Float` benötigen, geben Sie den Typ explizit an: ```swift let inferred = 3.14 // Double let explicit: Float = 3.14 // Float ``` Auch Ganzzahlliterale werden standardmäßig als `Int` behandelt — geben Sie für `Int32`, `UInt8` usw. den Typ explizit an.

Sobald ein Typ festgelegt ist, kann er nicht mehr geändert werden: ```swift var score = 0 // Int score = "ten" // ❌ cannot assign String to Int ``` Die Typsicherheit erkennt diese Fehlerklasse zur Kompilierungszeit, lange bevor sie zur Laufzeit auftritt.

Verwenden Sie `type(of:)`, um den Laufzeittyp zu untersuchen: ```swift let value = 42 print(type(of: value)) // Int let name = "Alice" print(type(of: name)) // String ``` Das ist nützlich, um Überraschungen bei der Typinferenz zu untersuchen.

Mit `typealias` geben Sie einem vorhandenen Typ einen neuen Namen, um die Lesbarkeit zu verbessern: ```swift typealias Celsius = Double typealias UserID = Int var temperature: Celsius = 36.6 var userId: UserID = 1001 ``` Typaliase dienen ausschließlich der Lesbarkeit — der zugrunde liegende Typ bleibt unverändert.

Wenn Sie eine Variable ohne Anfangswert deklarieren, *müssen* Sie den Typ angeben: ```swift var name: String // ✓ annotation required name = "Bob" var total: Int total = 0 ``` Ohne vorhandenen Wert kann Swift den Typ nicht ableiten.

Swift erlaubt Unterstriche in numerischen Literalen, um die Lesbarkeit zu verbessern: ```swift let million = 1_000_000 let hex = 0xFF_EC_D3 let binary = 0b1111_0000 ``` Der Compiler ignoriert die Unterstriche — sie dienen ausschließlich der Lesbarkeit.

Swift konvertiert niemals implizit zwischen Typen. Sie müssen die Konvertierung explizit durchführen: ```swift let intVal: Int = 5 let dblVal: Double = Double(intVal) // explicit conversion let sum = Double(intVal) + 2.5 ``` So vermeiden Sie subtile Fehler durch unbeabsichtigte numerische Umwandlungen.

Die wichtigsten Erkenntnisse: • Swift leitet Typen aus Anfangswerten ab — normalerweise ist keine Annotation erforderlich • Explizite Annotationen (`: Type`) überschreiben die Inferenz • Gleitkommazahlen werden standardmäßig zu `Double`, Ganzzahlen zu `Int` • Keine impliziten Konvertierungen — verwenden Sie `Int()`, `Double()` usw. • `type(of:)` zeigt den Laufzeittyp an Als Nächstes: die grundlegenden Typen — Zahlen, Bool und Character.