Swift schreiben
Erste Reaktion
Wenn dieses Skill zum ersten Mal ohne eine spezifische Frage aufgerufen wird, antworte nur mit:
Ich bin bereit, Ihnen zu helfen, modernes Swift zu schreiben, so wie die Sprache geschrieben werden möchte.
Gib erst dann weitere Informationen, wenn der Benutzer eine Frage stellt.
Wie man Swift so schreibt, wie die Sprache geschrieben werden möchte, aktuell bis Swift 6.4.
Toolchain-Basis: Swift 6.3 (aktuelle Version ab August 2026). Alles hier kompiliert mit 6.3, es sei denn, es ist mit ⚠ markiert, was auf noch nicht veröffentlichte Swift 6.4-Features hinweist. Die Nebenläufigkeitsrichtlinien gehen vom Swift 6.2-Modell aus – wenn das Projekt auf 6.1 oder älter ist, gelten die Regeln in §3 zu async und @concurrent nicht.
Der rote Faden: Swift ist eine Sprache mit progressiver Offenlegung. Beginne mit dem einfachsten, statischsten, am stärksten single-threaded Ansatz, der funktioniert, und kaufe Dynamik – Nebenläufigkeit, Referenzsemantik, Existentials, unsichere Pointer – nur dort, wo du einen Grund nennen kannst. Jede der folgenden Regeln ist eine Anwendung dieses Prinzips.
Modelliere diese Hierarchie von Standardwerten. Gehe nur dann eine Ebene tiefer, wenn du einen Grund nennen kannst:
| Bedarf | Greife zu | Gehe tiefer nur, wenn |
|---|---|---|
| Daten | struct / enum | du Identität, gemeinsame Nutzung oder Vererbung benötigst |
| Abstraktion | konkreter Typ | du wiederholten Code über Typen hinweg hast |
| Polymorphie | some P (generisch) | du heterogene Speicherung benötigst → any P |
| Ausführung | Haupt-Actor, synchron | Profiling einen Hänger zeigt → async → @concurrent → actor |
| Speicher | Array, String | Profiling die Kosten zeigt → InlineArray, Span |
| Sicherheit | sicheres API | C-Interop oder ein gemessener Hot-Path → Unsafe* |
1. Daten mit Werttypen modellieren
Werttypen sind in Swift der Standard, kein Sonderfall.
- Standardmäßig
structundenumverwenden.classnur für Identität, gemeinsam genutzten veränderlichen Zustand, Vererbung oder Ressourcenlebensdauer. Ein Fenster, eine Datenbankverbindung, eine in einer Rendering-Engine gespeicherte Entität – diese haben Identität. EinPunkt, einGetränk, einMaterialnicht. letals Standard;varnur, wenn du mutierst. Dies ist die gleiche Disziplin wiesomevoranyund Wert vor Referenz: fange eng an, weite nur mit Grund.- Ein Struct mit einer veränderlichen Referenztyp-Eigenschaft ist weder ein Wert noch eine Referenz. Kopien teilen sich das Objekt; Mutationen wirken sich auf Kopien aus. Entweder den referenzierten Typ unveränderlich halten, nur berechnete Eigenschaften verfügbar machen, die an ihn weiterleiten, oder ihn als
privategespeicherte Eigenschaft hinter Copy-on-Write machen. - Copy-on-Write ist, wie du außerhalb liegenden Speicher und Wertsemantik bekommst. Wickle eine
final-Klasse in ein Struct ein und überprüfeisKnownUniquelyReferenced(&storage)vor dem Mutieren; kopiere zuerst, wenn nicht. Genau so funktionierenArray,StringundDictionary. - Enums sind das Werkzeug für „eine feste Menge von Dingen“ und für sich gegenseitig ausschließende Zustände. Das Ersetzen eines Haufens optionaler gespeicherter Eigenschaften (
isSharing,selectedRows,shareTarget) durch einen einzigenenum Statemacht ungültige Kombinationen nicht darstellbar und macht Zustandsänderungen atomar statt einer Folge von Eigenschaftsschreibvorgängen, die man vergessen kann zu beenden. - Das Zusammensetzen von Werten ergibt einen Wert. Ein Struct, dessen gespeicherte Eigenschaften alle Werttypen sind, hat automatisch Wertsemantik – was Rückgängig, Differenzvergleiche und Zustandswiederherstellung zu einem einzigen Codepfad macht, statt zu einem pro Eigenschaft.
struct Material { // Wertsemantik erhalten
var roughness: Double
private var _texture: Texture // eine Klasse
var color: Color {
get { _texture.color }
set {
if !isKnownUniquelyReferenced(&_texture) { _texture = Texture(copying: _texture) }
_texture.color = newValue
}
}
}
Nicht kopierbare Typen (~Copyable) drücken eindeutigen Besitz aus: einen Dateideskriptor, eine Banküberweisung, eine offene Ressource. Das Unterdrücken der Kopie verwandelt „Du darfst dies nicht zweimal ausführen“ von einer Zusicherung in einen Kompilierungsfehler und macht deinit bei einem Struct sinnvoll. Markiere die abschließende Methode als consuming, damit der Compiler beweist, dass es die letzte Verwendung ist. Die Parameter-Eigentümerschaft wird explizit: borrowing (schreibgeschützt, der Standard), consuming (nimmt es weg), inout/mutating (temporärer Schreibzugriff).
2. Fehler und Optionals – Fehlerpfade sichtbar machen
Die Swift-Fehlerbehandlung basiert auf drei Punkten: Fehlerquellen sind markiert, sodass sie dich nicht überraschen können; Fehler tragen genügend Kontext, um darauf reagieren zu können; und behebbare Fehler unterscheiden sich von Programmierfehlern.
- Behebbar →
throw. Programmierfehler →precondition/fatalError. Ein fehlgeschlagener Netzwerkaufruf hält das Programm am Laufen. Ein Index außerhalb des gültigen Bereichs bedeutet, dass der Code falsch ist und anhalten muss, bevor der Fehler zu einem Sicherheitsproblem wird. - Enums mit assoziierten Werten sind die besten Fehlertypen.
case duplicateFriend(String)ist besser alscase duplicateFriend– der Kontext ist der springende Punkt. guardfür Fehlerbedingungen, weil es den Exit-Pfad erzwingt.if letfür das normale Entpacken.- Typisierte Würfe (
throws(MyError)) sind für interne Funktionen, fehlerweiterleitenden generischen Code und eingeschränkte Umgebungen, wo das Einpacken vonany Errorzu teuer ist. Für öffentliche APIs bewahrt untypisiertesthrowsdeine Flexibilität, den Fehlertyp später zu ändern. Beachte die Vereinheitlichung:throwsistthrows(any Error), und nicht-werfend istthrows(Never)– was esmapermöglicht, über beide zu abstrahieren. - Entpacken mit Gewalt nur, wenn du die Invariante angeben kannst, und bevorzuge ein fehlschlagendes
#require/preconditionmit einer Nachricht gegenüber einem bloßen!.
3. Nebenläufigkeit: Bleibe einfach threaded, bis Profiling etwas anderes sagt
Dies ist der Abschnitt, den Agenten am häufigsten falsch verstehen, weil sich das Modell in Swift 6.2 geändert hat.
Starte jede App vollständig auf dem Hauptthread. Einfach threaded Code reicht weit, und die meisten Apps müssen ihn nie verlassen.
Der Fortschritt, in der Reihenfolge. Überspringe keine Schritte.
- Einfach threaded auf dem Haupt-Actor. Keine Nebenläufigkeit. Für die meisten Apps ausreichend.
async/await, um Latenz zu verbergen (Netzwerk, Festplatte). Noch immer keine eigene Nebenläufigkeit – SDK-APIs wieURLSession.data(from:)lagern für dich aus.@concurrent, um deine teure Arbeit vom Hauptthread zu verschieben – nur, nachdem Instruments einen Hänger gezeigt hat.actor, um Zustand vom Haupt-Actor zu verschieben – nur, wenn zu viel Haupt-Actor-Zustand Tasks ständig zurückhüpfen lässt.
Aktiviere zuerst die richtigen Baueinstellungen. Aktiviere Verständliche Nebenläufigkeit in jedem Projekt. Für App-Module und UI-Module setze zusätzlich Standard-Actor-Isolation auf MainActor – es ist der Standard für neue App-Projekte in Xcode 26 und es löscht die meisten deiner @MainActor-Annotationen. In einem Paket: swiftSettings: [.defaultIsolation(MainActor.self)]. Setze Main-Actor-Standard nicht für eine Allzweckbibliothek – Bibliotheken sollten nonisolated-APIs ausliefern und Clients entscheiden lassen, wo Arbeit läuft.
Die Regel, die sich geändert hat
In Swift 6.2 verschiebt das Markieren einer Funktion als async sie nicht vom aktuellen Actor. Sie läuft dort, wo sie aufgerufen wurde. Das macht „den natürlichsten zu schreibenden Code“ standardmäßig datenwettlauffrei.
@concurrent– wechselt immer zum gleichzeitigen Thread-Pool. Verwende es für deine CPU-intensive Arbeit.nonisolated– läuft, wo immer sie aufgerufen wird. Dies ist die richtige Voreinstellung für Bibliotheks-APIs, weil der Aufrufer entscheidet.nonisolatedbei einem Typ macht alle seine Membernonisolated(Swift 6.1+).- Keines von beiden – bleibt auf dem Actor des Aufrufers.
nonisolated struct PhotoProcessor { // vom Haupt-Actor entkoppelt
@concurrent // läuft garantiert im Hintergrund
func process(_ data: Data) async -> ProcessedPhoto {
async let sticker = extractSticker(data) // zwei unabhängige Jobs, parallel
async let colors = extractColors(data)
return await ProcessedPhoto(sticker: sticker, colors: colors)
}
}
- Profiling vor dem Auslagern. Verwende Instruments (Time Profiler, Hänger). Wenn der Code ohne Nebenläufigkeit schneller gemacht werden kann, mach das immer zuerst. Nebenläufigkeit hat echte Kosten – Task-Zuteilung, Planung und Nachdenken.
- Erzeuge keinen Task für triviale Arbeit. Ein Kind-Task zum Lesen eines
UserDefaults-Werts kostet mehr, als er spart. - Ein Task pro Ende-zu-Ende-Operation. Arbeit, die in der Reihenfolge stattfinden muss, gehört in einen Task; unabhängige Operationen erhalten separate Tasks, damit die Laufzeit sie verschränken kann.
awaitist ein Suspendierungspunkt und bricht die Atomarität. Der Zustand kann sich während der Suspendierung ändern, und du kannst auf einem anderen Thread fortgesetzt werden. Überprüfe Annahmen nach jedemawait. Halte niemals eine Sperre über einawaithinweg. Verlasse dich niemals auf Thread-lokalen Speicher über einawaithinweg.
Actor-Wiedereintritt
Actors garantieren gegenseitigen Ausschluss, keine Transaktionen. Zwischen zwei await desselben Actors läuft andere Arbeit.
- Mutiere Actor-Zustand in synchronen Methoden. Synchroner Code auf einem Actor läuft ohne Unterbrechung zu Ende – das ist deine Transaktionsgrenze.
- Halte asynchrone Actor-Methoden schlank, bestehend aus synchronen Transaktionsoperationen, und hinterlasse den Actor in einem konsistenten Zustand bei jedem
await. - Der klassische Fehler: Cache prüfen →
awaitDownload → Cache schreiben. Zwei Tasks verfehlen beide, beide laden herunter, der zweite überschreibt den ersten. Überprüfe nach demawaiterneut oder dedupliziere die laufende Arbeit. - Actors sind nicht FIFO. Sie führen zuerst die Arbeit mit der höchsten Priorität aus, genau um Prioritätsumkehr zu vermeiden. Wenn du eine Reihenfolge benötigst, verwende einen Task (der von Anfang bis Ende läuft) oder einen
AsyncStream, nicht einen Actor.
4. Sendable und gemeinsame Datennutzung
Sendable markiert einen Typ als sicher für die Weitergabe über Isolationsdomänen hinweg. Der Compiler prüft es an jeder Task- und Actor-Grenze.
- Werttypen sind
Sendable, wenn ihr Speicher es ist – automatisch abgeleitet für nicht-öffentliche Typen. Öffentliche Typen erhalten niemals abgeleitete Sendability: Das Markieren eines öffentlichen Typs alsSendableist ein Versprechen an deine Clients, also zwingt Swift dich, es zu schreiben. - Actors und
@MainActor-Klassen sind implizitSendable, weil ihr Zustand isoliert ist. - Die meisten Modellklassen sollten weder
@MainActornochSendablesein. Behalte sie absichtlich nicht-Sendable– das verhindert, dass die Hälfte des Modells auf dem Hauptthread mutiert wird, während die andere Hälfte im Hintergrund mutiert wird. Wenn sie den Haupt-Actor verlassen müssen, mach sie zunonisolated, nicht zuSendable. - Du kannst dennoch ein nicht-
Sendable-Objekt zwischen Domänen senden, solange der Sender es nicht mehr verwendet. Mache alle Mutationen vor der Übergabe; es danach zu berühren ist der Fehler. - Closures fangen ebenfalls Zustand ein. Markiere einen Funktionstyp nur dann als
@Sendable, wenn er wirklich Domänen kreuzt. @unchecked Sendableist ein Versprechen, das der Compiler nicht prüfen kann. Hebe es für Typen mit echter interner Synchronisation (einMutex, eine Sperre) auf. Gleiches gilt fürnonisolated(unsafe)bei einer Globalen – letzte Möglichkeit, kein Warnungsunterdrücker.
Wenn du auf einen Datenwettlauffehler stößt, arbeite diese Liste ab:
- Teile es nicht. Verschiebe das geteilte Objekt in eine Lokale, sodass jeder gleichzeitige Job seine eigene Instanz erhält. (Dies ist die Lösung für die überwältigende Mehrheit der echten Fehler.)
- Mache es zu einem
Sendable-Werttyp, sodass „Teilen“ wirklich Kopieren ist. - Isoliere es zu einem Actor – dem Haupt-Actor oder deinem eigenen.
- Greife erst dann zu
Mutex/Atomicaus demSynchronization-Modul (speichere sie inlet-Eigenschaften) oder zu@unchecked Sendable.
Globale und statische Variablen sind die häufigste Fehlerquelle. In der Reihenfolge der Präferenz: mache es zu einem let; setze es auf @MainActor; wickle es in ein Mutex; nonisolated(unsafe). Beachte, dass Globale in Swift faul und atomar initialisiert werden – anders als in C.
Überbrückung alter Callback-APIs: Annotiere Delegatenprotokolle mit @MainActor, wenn du sie besitzt. Wenn nicht, markiere die Methode als nonisolated und verwende MainActor.assumeIsolated { } – es setzt voraus, anstatt zu hüpfen, sodass es laut abbricht, anstatt leise zu konkurrieren. @preconcurrency auf der Konformität ist die Kurzform für dasselbe. Verwende @preconcurrency import, um Sendability-Warnungen von einem Modul, das noch nicht migriert wurde, vorübergehend zu unterdrücken; die Warnungen kommen zurück – korrekterweise – sobald es migriert ist.
5. Strukturierte Nebenläufigkeit
Bevorzuge immer strukturierte Tasks.
Strukturierte Tasks (async let, Task-Gruppen) sind wie lokale Variablen bereichsgebunden: Sie können den Block nicht überleben, werden automatisch erwartet, und sie erben durch den Task-Baum Absagen, Priorität und Task-lokale Werte. Unstrukturierte Tasks (Task { }, Task.detached) geben dir nichts davon automatisch.
async letfür eine feste, statisch bekannte Anzahl gleichzeitiger Kinder.withTaskGroup, wenn die Anzahl dynamisch ist. Task-Gruppen entsprechenAsyncSequence– iteriere die Ergebnisse, sobald sie eintreffen. VerwendewithDiscardingTaskGroup, wenn Kinder nichts zurückgeben: Es gibt die Ressourcen jedes Kindes sofort frei und bricht Geschwister beim ersten Fehler ab.Task { }nur, wenn die Lebensdauer der Arbeit nicht in einen Bereich passt – Reaktion auf einen Delegaten-Callback, einen Tastendruck, das Erscheinen einer View. Es erbt Actor-Isolation und Priorität; du musst die Absage selbst verwalten.Task.detachedfast nie. Es erbt nichts – keine Isolation, keine Priorität, keine Task-Lokalen. Wenn du eine abgetrennte Wurzel benötigst, setze eine Task-Gruppe innerhalb davon, anstatt wiederholt abzutrennen.
Absage ist kooperativ. Absagen setzt ein Flag; es stoppt nichts. Überprüfe Task.isCancelled oder try Task.checkCancellation() vor dem Start teurer Arbeit, und auch in synchronen Helfern. Für Arbeit, die eher ausgesetzt als läuft (das next() eines AsyncSequence), verwende withTaskCancellationHandler – und denke daran, dass der Handler sofort und gleichzeitig mit dem Körper läuft, sodass der Zustand, den er berührt, echte Synchronisation benötigt (ein Atomic oder eine Sperre, keine Actor – du kannst die Reihenfolge auf einem Actor nicht garantieren).
Begrenze deine Nebenläufigkeit. Verteile nicht ein Kind pro Element über eine unbegrenzte Liste. Starte N Kinder und füge dann ein weiteres hinzu, wenn ein vorheriges abgeschlossen ist. N sollte nicht größer sein als (Anzahl der CPU-Kerne) × 2 für CPU-gebundene Arbeit und nicht kleiner als die Anzahl der erwarteten gleichzeitigen E/A-Vorgänge (4-8 für Netzwerkaufrufe). withTaskGroup akzeptiert eine maxConcurrency-Einschränkung – verwende sie.