Swift Spickzettel
Zuletzt aktualisiert
Hello World & Grundlagen
Swift braucht auf oberster Ebene keine Boilerplate - eine einzige Zeile läuft.
| Operation | Syntax |
|---|---|
| Eine Zeile ausgeben | print("Hello, World!") |
| Ohne Zeilenumbruch ausgeben | print("Hi", terminator: "") |
| String-Interpolation | print("Hi \(name)") |
| Kommentar | // this is a comment |
| Mehrzeiliger Kommentar | /* ... */ |
| Ein Modul importieren | import Foundation |
| Eine Datei ausführen | swift run oder swift main.swift |
Variablen (let / var) & Typen
Verwende let für Konstanten und var für veränderliche Werte; Typen werden meist abgeleitet.
| Operation | Syntax |
|---|---|
| Konstante | let age = 30 |
| Variable | var count = 0 |
| Expliziter Typ | let name: String = "Ada" |
| Basistypen | Int, Double, String, Bool, Character |
| Typumwandlung | Double(i), String(n), Int("42") |
| Tupel | let pair = (1, "a") |
| Typalias | typealias ID = Int |
| Typ prüfen | value is String, value as? String |
Optionals
Optionals modellieren das mögliche Fehlen eines Werts; vor der Verwendung auspacken.
| Operation | Syntax |
|---|---|
| Optional deklarieren | var name: String? = nil |
| Optional Binding | if let n = name { ... } |
| Guard-Auspacken | guard let n = name else { return } |
| Nil-Coalescing | let n = name ?? "default" |
| Optional Chaining | user?.address?.city |
| Erzwungenes Auspacken (unsicher) | name! |
| Implizit ausgepackt | var name: String! |
| Über ein Optional mappen | name.map { $0.count } |
Strings
Strings sind Werttypen mit voller Unicode-Unterstützung.
| Operation | Syntax |
|---|---|
| Länge | s.count |
| Groß-/Kleinschreibung | s.uppercased(), s.lowercased() |
| Verketten | "foo" + "bar" |
| Interpolation | "Total: \(price)" |
| Enthält | s.contains("ell") |
| Hat Präfix / Suffix | s.hasPrefix("he") |
| Aufteilen | s.split(separator: ",") |
| Ersetzen | s.replacingOccurrences(of: "a", with: "b") |
| Mehrzeiliger String | """ ... """ |
Collections (Array, Dictionary, Set)
Drei zentrale Collection-Typen, allesamt Werttypen.
| Operation | Syntax |
|---|---|
| Array-Literal | var nums = [1, 2, 3] |
| Anhängen | nums.append(4) |
| Zugriff / Anzahl | nums[0], nums.count |
| Map / filter | nums.map { $0 * 2 }, nums.filter { $0 > 1 } |
| Dictionary-Literal | var ages = ["Ada": 30] |
| Dictionary-Zugriff | ages["Ada"] gibt ein Optional zurück |
| Set-Literal | var ids: Set = [1, 2, 3] |
| In ein Set einfügen | ids.insert(4) |
| Dictionary durchlaufen | for (k, v) in ages { ... } |
Kontrollfluss
Bedingungen brauchen keine Klammern; switch muss erschöpfend sein.
| Operation | Syntax |
|---|---|
| If / else | if x > 0 { ... } else { ... } |
| Ternär | let r = x > 0 ? "pos" : "neg" |
| Switch | switch n { case 1: ...; default: ... } |
| Switch mit Bereich | case 1...5: ... |
| For-in-Schleife | for i in 0..<10 { ... } |
| For-in über Array | for item in items { ... } |
| While-Schleife | while x < 100 { ... } |
| Repeat-while | repeat { ... } while x < 100 |
| Break / continue | break, continue |
Funktionen & Closures
Funktionen haben benannte Parameter; Closures sind in sich geschlossene Codeblöcke.
| Operation | Syntax |
|---|---|
| Eine Funktion definieren | func add(a: Int, b: Int) -> Int { a + b } |
| Externes Label | func greet(to name: String) { ... } |
| Standardparameter | func greet(name: String = "World") { ... } |
| Variadischer Parameter | func sum(_ nums: Int...) -> Int { ... } |
| Mehrere Rückgaben (Tupel) | func bounds() -> (min: Int, max: Int) { ... } |
| Closure-Ausdruck | let f = { (x: Int) -> Int in x * x } |
| Trailing Closure | nums.map { $0 * 2 } |
| Kurzform-Argumente | { $0 + $1 } |
Structs vs. Klassen
Structs sind Werttypen (kopiert); Klassen sind Referenztypen (geteilt).
| Operation | Syntax |
|---|---|
| Ein Struct definieren | struct Point { var x: Int; var y: Int } |
| Eine Klasse definieren | class Person { var name: String } |
| Klassen-Initialisierer | init(name: String) { self.name = name } |
| Instanz erstellen | let p = Point(x: 1, y: 2) |
| Mutating-Struct-Methode | mutating func move() { x += 1 } |
| Klassenmethode | func greet() { ... } |
| Vererbung (nur Klassen) | class Student: Person { ... } |
| Berechnete Property | var area: Int { width * height } |
| Statischer Member | static let shared = Manager() |
Enums
Enums gruppieren zusammengehörige Werte und können assoziierte Daten tragen.
| Operation | Syntax |
|---|---|
| Ein Enum definieren | enum Direction { case north, south } |
| Einen Case verwenden | let d = Direction.north |
| Auf Enum switchen | switch d { case .north: ... } |
| Rohwerte | enum Status: Int { case ok = 200 } |
| Auf Rohwert zugreifen | Status.ok.rawValue |
| Aus Rohwert initialisieren | Status(rawValue: 200) |
| Assoziierte Werte | case result(Int, String) |
| Methoden an Enums | func label() -> String { ... } |
Die Swift-Syntax, die du am häufigsten brauchst, auf einer Seite. Dieser Swift-Spickzettel ist eine Schnellreferenz für die Kernsprache - Konstanten und Variablen, Optionals, Strings, Collections, Kontrollfluss, Funktionen und Closures sowie die Structs, Klassen und Enums, mit denen du iOS- und macOS-Apps baust.
Alles hier ist Standard-Swift und kompiliert mit der offiziellen Toolchain. Kopiere, was du brauchst, oder probiere jeden Codeschnipsel live im Swift-Playground aus - kein Xcode nötig.
Swift-Spickzettel FAQ
Ist dieser Swift-Spickzettel kostenlos?
Ja. Dieser Swift-Spickzettel ist völlig kostenlos, ohne erforderliche Anmeldung. Setze ein Lesezeichen und komm jederzeit wieder, wenn du ein Optional-Muster, eine Closure-Syntax oder eine Collection-Methode nachschlagen möchtest.
Wie packe ich ein Optional in Swift aus?
Ein Optional kann einen Wert oder
nil halten, daher packst du es vor der Verwendung aus. Die sicheren Wege sind Optional Binding (if let n = name { ... }), ein guard let am Anfang einer Funktion, der Nil-Coalescing-Operator (name ?? "default") und Optional Chaining (user?.name). Erzwungenes Auspacken mit name! funktioniert, stürzt aber ab, wenn der Wert nil ist, also greife nur dann dazu, wenn du sicher bist.Was ist der Unterschied zwischen einem Struct und einer Klasse in Swift?
Ein
struct ist ein Werttyp: Beim Zuweisen oder Übergeben wird eine Kopie erstellt, sodass Änderungen das Original nicht betreffen. Eine class ist ein Referenztyp: Kopien teilen sich dieselbe Instanz, und nur Klassen unterstützen Vererbung. Apples Empfehlung ist, standardmäßig Structs zu bevorzugen und eine Klasse zu verwenden, wenn du gemeinsamen veränderlichen Zustand oder Vererbung brauchst.Kann ich Swift online üben?
Ja. Öffne den Swift-Playground, um jeden Codeschnipsel aus diesem Spickzettel in deinem Browser auszuführen - kein Xcode zu installieren. Wenn du Struktur möchtest, führt dich Coddys kostenloser interaktiver Swift-Kurs Schritt für Schritt von Optionals und Collections zu Structs, Klassen und Enums.
Ist dieser Spickzettel für Anfänger geeignet?
Ja. Er ist von den häufigsten Themen (Variablen, Optionals, Kontrollfluss) hin zu den fortgeschrittenen (Closures, Structs vs. Klassen, Enums) gegliedert, sodass du die oberen Abschnitte schon am ersten Tag nutzen und in den Rest hineinwachsen kannst.
Verwandte Ressourcen
Weitere Spickzettel
