0Pricing
Swift Academy · Lektion

Bedingte Protokollkonformität

Lassen Sie generische Typen mithilfe von where-Klauseln bedingt Protokollen entsprechen.

Bedingte Protokollkonformität ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 2 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

Bedingte Konformität ermöglicht es einem generischen Typ, nur dann einem Protokoll zu entsprechen, wenn seine Typparameter bestimmte Einschränkungen erfüllen. Sie ist ein zentraler Bestandteil der Ausdrucksstärke von Swifts Typsystem.

Grundlegende bedingte Konformität

```swift extension Array: Equatable where Element: Equatable { // Array is Equatable only when Element is Equatable } let a = [1,2,3] let b = [1,2,3] print(a == b) // true — works because Int is Equatable ```

Benutzerdefinierter generischer Typ

```swift struct Box { var value: T } extension Box: Equatable where T: Equatable { static func == (lhs: Box, rhs: Box) -> Bool { lhs.value == rhs.value } } print(Box(value: 42) == Box(value: 42)) // true ```

Bedingte Hashable-Konformität

```swift extension Box: Hashable where T: Hashable { func hash(into hasher: inout Hasher) { hasher.combine(value) } } // Box is Hashable; Box is not ```

Bedingte Codable-Konformität

```swift extension Box: Codable where T: Codable {} let box = Box(value: "hello") let data = try JSONEncoder().encode(box) // works — String is Codable ```

where-Klauseln in Extensions

```swift extension Collection where Element == Int { var sum: Int { reduce(0, +) } } print([1,2,3,4].sum) // 10 // This extension only applies to collections of Int ```

Mehrere Einschränkungen

```swift extension Dictionary where Key: Comparable, Value: Equatable { func sortedByKey() -> [(Key, Value)] { sorted { $0.key < $1.key } } } ```

Bedingte Protokollkonformität

```swift protocol Printable { func prettyPrint() } extension Optional: Printable where Wrapped: Printable { func prettyPrint() { switch self { case .none: print("nil") case .some(let v): v.prettyPrint() } } } ```

Bedingte Konformität verwenden

```swift let opt: Int? = 42 // If Int conformed to Printable: // opt.prettyPrint() // "42" // Standard usage: let nums = Optional([1,2,3]) // [1,2,3]? if let arr = nums, arr == [1,2,3] { ... } // Equatable via conditional ```

Warnung vor nachträglicher Protokollkonformität

Swift 5.7+ gibt Warnungen vor nachträglichen Konformitäten aus, also davor, Typen aus einem anderen Modul eine Konformität hinzuzufügen: ```swift extension String: SomeThirdPartyProtocol {} // ⚠️ retroactive ``` Kennzeichnen Sie dies mit `@retroactive`, wenn es beabsichtigt ist.

Kurze Überprüfung

Welches Schlüsselwort leitet eine Bedingung in einer Erweiterung mit bedingter Konformität ein?

Zusammenfassung

Wichtige Erkenntnisse: • `extension T: Protocol where Param: Constraint` — bedingte Konformität • Arrays, Optional, Result usw. verwenden dies für Equatable, Hashable und Codable • Benutzerdefinierte generische Typen können dasselbe tun • `where Element == Int` beschränkt auf bestimmte konkrete Typen • Nachträgliche Konformitäten erfordern in Swift 5.7+ `@retroactive` Als Nächstes: Self-Anforderungen.

Häufig gestellte Fragen

Ist die Lektion „Bedingte Protokollkonformität“ kostenlos?

Ja — der vollständige Text von „Bedingte Protokollkonformität“ 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 „Bedingte Protokollkonformität“?

Lassen Sie generische Typen mithilfe von where-Klauseln bedingt Protokollen entsprechen. 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 2 von 4.

Wie lange dauert die Lektion „Bedingte Protokollkonformität“?

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