Swift Academy · Lektion

APIs für Wertsemantik entwerfen

Wählen Sie beim Entwurf öffentlicher Schnittstellen und Frameworks zwischen Struct und Klasse.

Lektion 4 von 412 Schritte

APIs für Wertsemantik entwerfen ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 4 Lektionen.

Willkommen

Das Entwerfen von APIs auf Grundlage der Wertsemantik führt zu vorhersehbarem, threadsicherem und leicht testbarem Code. Sehen wir uns die Prinzipien und Muster an, die Ihnen bei dieser Entscheidung helfen.

Der Vertrag der Wertsemantik

Ein Typ besitzt Wertsemantik, wenn: • Zwei unabhängige Kopien dauerhaft unabhängig bleiben • Eine Änderung an einer Kopie niemals die andere beeinflusst • Der Typ sich wie `Int` verhält – `a = b; a += 1` lässt `b` unverändert

Öffentliche API: Werttypen zurückgeben

```swift // Reference semantics — caller shares state: func getUser() -> UserClass { ... } // Value semantics — caller gets independent copy: func getUser() -> UserStruct { ... } ``` Rückgabewerte mit Werttyp schützen den internen Zustand vor Änderungen von außen.

Unveränderliche Referenztypen

Wenn eine Klasse immer unveränderlich ist, verhält sie sich wie ein Werttyp: ```swift final class Token { let value: String init(_ v: String) { value = v } // No mutable state — safe to share freely } ```

Checkliste: Struct statt Klasse wählen

Bevorzugen Sie ein Struct, wenn: ✓ der Typ Daten und keine Identität modelliert ✓ keine Vererbung erforderlich ist ✓ Instanzen nicht geteilt oder durch Aliasing gemeinsam verwendet werden sollen ✓ die Gleichheit durch den Vergleich der Feldwerte bestimmt wird ✓ der Typ gut mit Swift Concurrency funktioniert (Sendable)

Sendable und Wertsemantik

Swift 6 Concurrency erfordert, dass Typen, die Actor-Grenzen überschreiten, `Sendable` sind: ```swift struct Message: Sendable { var text: String; var timestamp: Date } // Safe to pass between actors ``` Werttypen mit ausschließlich `Sendable`-Eigenschaften sind automatisch `Sendable`.

Klassen-APIs wertsicher machen

```swift struct Config { // Expose value snapshot instead of the class: func snapshot() -> Config { self } // copy by value semantics } // Or use a value-type DTO: struct UserDTO: Sendable { var id: UUID; var name: String } ```

Builder-Pattern mit Werttypen

```swift struct Request { var url: URL var method: String = "GET" var headers: [String:String] = [:] func adding(header: String, value: String) -> Request { var copy = self copy.headers[header] = value return copy } } let r = Request(url: url).adding(header: "Auth", value: "Bearer x") ```

Signal in der API-Dokumentation

Die Entscheidung für ein Struct statt einer Klasse vermittelt API-Nutzern ein klares Signal: • „Dies sind Daten – Sie können sie frei kopieren.“ • „Änderungen an Ihrer Kopie beeinflussen meine nicht.“ • „Dieser Wert kann threadsicher weitergegeben werden.“ Dadurch wird defensives Kopieren im Code der Nutzer meist überflüssig.

Wann Referenzsemantik sinnvoll ist

Akzeptieren Sie Klassen- bzw. Referenzsemantik, wenn: • die Identität wichtig ist (`===`): Zwei `User`-Objekte können dieselbe Person darstellen • ein gemeinsamer veränderlicher Zustand die eigentliche Funktion ist: `Database`, `Cache`, `AudioEngine` • die Interoperabilität mit ObjC dies erfordert: UIKit- und AppKit-Typen sind Klassen • Lifecycle-Callbacks benötigt werden: `deinit` zur Ressourcenbereinigung

Kurze Überprüfung

Welches Swift-Schlüsselwort kennzeichnet einen Typ als sicher für die Weitergabe über Actor-Grenzen hinweg in Swift Concurrency?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Die wichtigsten Punkte: • Wertsemantik: Änderungen bleiben lokal, kein Aliasing • Bevorzugen Sie Structs für Datenmodelle und Klassen für Identität bzw. Lifecycle • Unveränderliche Klassen verhalten sich wie Werttypen • `Sendable` + Werttypen = sichere Nebenläufigkeit • Das Builder-Pattern mit Struct-Kopien erzeugt saubere unveränderliche APIs Kurs abgeschlossen! Als Nächstes: ARC- und Speicherverwaltungsmuster.

Kostenlos starten

Lerne Swift mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse: 122
Lektionen: 409

Kostenlos lernen Den vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „APIs für Wertsemantik entwerfen“ kostenlos?

Ja — der vollständige Text von „APIs für Wertsemantik entwerfen“ 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 „APIs für Wertsemantik entwerfen“?

Wählen Sie beim Entwurf öffentlicher Schnittstellen und Frameworks zwischen Struct und Klasse. 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 4 von 4.

Wie lange dauert die Lektion „APIs für Wertsemantik entwerfen“?

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.

Alle Lektionen in diesem Kurs

Stack vs. Heap: Wo Werte liegen
Mutation, gemeinsames Nutzen und unerwartete Aliase
Gemischte Wert-/Referenzgraphen
APIs für Wertsemantik entwerfen

← Zurück zu Swift Academy