0Pricing
Swift Academy · Lektion

Self-Anforderungen und Equatable-Entwurf

Protokolle, die Self verwenden, und wie Equatable/Comparable davon profitieren.

Self-Anforderungen und Equatable-Entwurf ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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

`Self` bezeichnet in einem Protokoll den konkreten Typ, der die Konformität bereitstellt. Dadurch können Protokolle wie `Equatable` und `Comparable` sicher mit heterogenen Typen arbeiten.

Self als Parametertyp

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self` bedeutet, dass beide Parameter denselben konkreten Typ haben müssen. Über dieses Protokoll können Sie einen `Int` nicht mit einem `String` vergleichen.

Equatable implementieren

```swift struct Point: Equatable { var x: Double var y: Double // Auto-synthesised: // static func == (lhs: Point, rhs: Point) -> Bool // { lhs.x == rhs.x && lhs.y == rhs.y } } print(Point(x:1,y:2) == Point(x:1,y:2)) // true ```

Comparable mit Self

```swift struct Version: Comparable { let major, minor, patch: Int static func < (lhs: Version, rhs: Version) -> Bool { (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch) } } let v1 = Version(major:1,minor:2,patch:0) let v2 = Version(major:2,minor:0,patch:0) print(v1 < v2) // true ```

Self als Rückgabetyp

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` `Self` im Rückgabetyp bedeutet, dass Unterklassen ihren eigenen Typ und nicht `Animal` zurückgeben.

Protokoll mit Self-Anforderung (PAT)

```swift protocol Scalable { func scaled(by factor: Double) -> Self } struct Size: Scalable { var w, h: Double func scaled(by f: Double) -> Size { Size(w: w*f, h: h*f) } } ```

Hashable: Self + Equatable

```swift struct Color: Hashable { var r, g, b: UInt8 // Auto-synthesised: func hash(into:) and == } var palette: Set = [] palette.insert(Color(r:255,g:0,b:0)) ``` `Hashable` erfordert `Equatable` – für einfache Structs werden beide automatisch synthetisiert.

Protokolle mit Self können nicht direkt als Existentials verwendet werden

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` Mit dem Schlüsselwort `any` wird das Boxing als Existential explizit aktiviert.

Voraussetzungen für die Synthese

Die automatische Synthese von `Equatable`/`Hashable`/`Comparable` erfordert: • Alle gespeicherten Eigenschaften sind konform zum selben Protokoll • Enum-Fälle, einschließlich zugehöriger Werte, sind konform ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Benutzerdefinierte Equatable-Implementierung

```swift struct Person: Equatable { var id: UUID var name: String // Only compare by id, ignore name: static func == (lhs: Person, rhs: Person) -> Bool { lhs.id == rhs.id } } ```

Kurze Überprüfung

Worauf verweist `Self` in einem Protokoll?

Zusammenfassung

Wichtige Erkenntnisse: • `Self` = der konkrete Typ, der die Konformität bereitstellt • `Equatable`, `Comparable` und `Hashable` verwenden alle `Self` • Swift synthetisiert diese Protokollkonformitäten automatisch für einfache Structs und Enums • `Self` in Rückgabetypen ermöglicht typerhaltende APIs • Protokolle mit Self-Anforderungen benötigen `any` für Existentials (Swift 5.7+) Als Nächstes: Prinzipien des protocol-orientierten Designs.

Häufig gestellte Fragen

Ist die Lektion „Self-Anforderungen und Equatable-Entwurf“ kostenlos?

Ja — der vollständige Text von „Self-Anforderungen und Equatable-Entwurf“ 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 „Self-Anforderungen und Equatable-Entwurf“?

Protokolle, die Self verwenden, und wie Equatable/Comparable davon profitieren. 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 „Self-Anforderungen und Equatable-Entwurf“?

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

  1. Protokollkomposition mit &
  2. Bedingte Protokollkonformität
  3. Self-Anforderungen und Equatable-Entwurf
  4. Prinzipien des protokollorientierten Entwurfs
← Zurück zu Swift Academy