Willkommen
Swift bietet eine umfangreiche Auswahl integrierter numerischer Typen, einen booleschen Typ und den Typ Character zur Darstellung einzelner Unicode-Skalare. Sehen wir uns die einzelnen Typen an.
Ganzzahltypen
Swift stellt vorzeichenbehaftete und vorzeichenlose Ganzzahlen mit verschiedenen Bitbreiten bereit:
```swift
let a: Int = -42 // platform width (64-bit)
let b: Int8 = 127
let c: UInt = 255
let d: UInt8 = 200
```
Verwenden Sie `Int` für allgemeine Ganzzahlen und Typen mit fester Breite, wenn das Speicherlayout eine Rolle spielt.
Int.min und Int.max
Jeder Ganzzahltyp stellt seine Grenzwerte bereit:
```swift
print(Int.min) // -9223372036854775808 on 64-bit
print(Int.max) // 9223372036854775807
print(UInt8.max) // 255
```
Das Überschreiten dieser Grenzwerte führt zu einem Laufzeitfehler (verwenden Sie für absichtlichen Überlauf die Überlaufoperatoren &+, &-).
Gleitkommazahlen: Double und Float
```swift
let pi: Double = 3.14159265358979 // 64-bit, ~15 decimal digits
let e: Float = 2.71828 // 32-bit, ~6 decimal digits
```
Verwenden Sie für die meisten Aufgaben `Double`. Setzen Sie `Float` nur ein, wenn der Speicherbedarf entscheidend ist, zum Beispiel bei großen Arrays mit Werten.
Arithmetische Operatoren
Swift unterstützt die üblichen arithmetischen Operatoren:
```swift
let sum = 10 + 3 // 13
let diff = 10 - 3 // 7
let prod = 10 * 3 // 30
let quot = 10 / 3 // 3 (integer division)
let rem = 10 % 3 // 1
```
Beachten Sie: Die Division zweier `Int`-Werte wird gegen null abgeschnitten.
Boolescher Typ: true und false
```swift
var isLoggedIn: Bool = false
isLoggedIn = true
if isLoggedIn {
print("Welcome back!")
}
```
Boolesche Werte sind in Swift strikt typisiert – ganze Zahlen können nicht wie in C als Wahrheits- oder Falschwerte verwendet werden.
Boolesche Operatoren
Die drei grundlegenden booleschen Operatoren:
```swift
let a = true && false // AND → false
let b = true || false // OR → true
let c = !true // NOT → false
```
Auswertung mit Kurzschluss: Bei `&&` wird die rechte Seite nur ausgewertet, wenn die linke Seite `true` ist.
Character-Typ
Ein `Character` enthält einen einzelnen erweiterten Graphem-Cluster, also ein für Menschen lesbares Zeichen:
```swift
let letter: Character = "A"
let emoji: Character = "🚀"
let accented: Character = "é"
```
Character-Literale werden wie bei `String` in doppelte Anführungszeichen gesetzt.
Characters und Strings
Ein `String` ist eine Folge von `Character`-Werten:
```swift
let str = "Hello"
for ch in str {
print(ch) // H, e, l, l, o
}
```
Sie können mit `String(character)` oder durch Anhängen an einen `var`-String aus Characters einen String erstellen.
Operatoren für numerischen Überlauf
Wenn Sie absichtlichen Überlauf benötigen, etwa bei der Bitmanipulation von Hardware, verwenden Sie Überlaufoperatoren:
```swift
var x: UInt8 = 255
x = x &+ 1 // wraps to 0 instead of crashing
```
Die Operatoren `&+`, `&-` und `&*` lösen bei einem Überlauf niemals einen Laufzeitfehler aus.
Kurze Überprüfung
Welcher boolesche Swift-Operator gibt nur dann `true` zurück, wenn **beide** Operanden `true` sind?
Zusammenfassung
Wichtige Erkenntnisse:
• Ganzzahlen: `Int` für die allgemeine Verwendung, größenabhängige Typen (`Int8`, `UInt8` …) bei Bedarf
• Gleitkommazahlen: `Double` (64 Bit) wird bevorzugt; `Float` (32 Bit) für Arrays, bei denen der Speicherbedarf wichtig ist
• `Bool` ist strikt – nur `true`/`false`, keine implizite Umwandlung von Ganzzahlen
• `Character` enthält einen Unicode-Graphem-Cluster
• Verwenden Sie `&+`, `&-` und `&*` für absichtlichen Überlauf
Als Nächstes: Strings und Interpolation.
Häufig gestellte Fragen
Ist die Lektion „Zahlen, Boolesche Werte und Zeichen“ kostenlos?
Ja — der vollständige Text von „Zahlen, Boolesche Werte und Zeichen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Zahlen, Boolesche Werte und Zeichen“?
Arbeiten Sie mit den Typen Int, Double, Float, Bool und Character. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Swift Academy zu starten?
Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Zahlen, Boolesche Werte und Zeichen“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?
Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.