Swift Academy · Lektion

Standardimplementierungen in Extensions

Stellen Sie gemeinsames Verhalten über Protocol-Extensions bereit.

Standardimplementierungen in Extensions 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.

Das Problem

Protokolle deklarieren Anforderungen, stellen aber kein Verhalten bereit. Wenn jeder konforme Typ dieselbe Logik wiederholen müsste, würde Code dupliziert. Protokollerweiterungen lösen dieses Problem, indem sie Standardimplementierungen bereitstellen.

protocol Greeter {
    func greet() -> String
}

Einen Standard hinzufügen

Eine Erweiterung des Protokolls kann eine Anforderung implementieren. Konforme Typen erhalten dieses Verhalten automatisch, sofern sie es nicht überschreiben.

protocol Greeter { func greet() -> String }

extension Greeter {
    func greet() -> String { "Hello!" }
}

struct Robot: Greeter {}
print(Robot().greet())

Den Standard überschreiben

Ein konformer Typ kann eine eigene Implementierung bereitstellen, die Vorrang vor dem Standard der Erweiterung hat.

protocol Greeter { func greet() -> String }
extension Greeter { func greet() -> String { "Hello!" } }

struct French: Greeter {
    func greet() -> String { "Bonjour!" }
}
print(French().greet())

Zusätzliche Methoden hinzufügen

Erweiterungen können völlig neue Methoden hinzufügen, die im Protokoll überhaupt nicht enthalten sind. Jeder konforme Typ erhält sie automatisch.

protocol Named { var name: String { get } }

extension Named {
    func loudName() -> String { name.uppercased() }
}

struct City: Named { let name: String }
print(City(name: "paris").loudName())

Standardmäßige berechnete Eigenschaften

Erweiterungen können auch berechnete Eigenschaften als Standard bereitstellen.

protocol Sized {
    var width: Double { get }
    var height: Double { get }
}

extension Sized {
    var area: Double { width * height }
}

struct Rect: Sized { let width: Double; let height: Double }
print(Rect(width: 2, height: 5).area)

Auf Anforderungen aufbauen

Eine Standardimplementierung kann die eigenen Anforderungen des Protokolls aufrufen und so aus dem minimalen Vertrag, den jeder Typ bereitstellen muss, ein umfangreicheres Verhalten zusammensetzen.

protocol Summable {
    var values: [Int] { get }
}

extension Summable {
    var total: Int { values.reduce(0, +) }
}

struct Cart: Summable { let values: [Int] }
print(Cart(values: [10, 20, 30]).total)

Eingeschränkte Erweiterungen

Verwenden Sie eine where-Klausel, damit ein Standard nur gilt, wenn zusätzliche Bedingungen erfüllt sind. Hier ist der Standard nur vorhanden, wenn Self auch Equatable ist.

protocol Container {
    associatedtype Item
    var items: [Item] { get }
}

extension Container where Item: Equatable {
    func contains(_ x: Item) -> Bool { items.contains(x) }
}

struct Bag: Container { let items: [Int] }
print(Bag(items: [1, 2, 3]).contains(2))

Standard und Anforderung gemeinsam

Sie können eine Methode im Protokoll deklarieren UND einen Standard bereitstellen. Wenn Sie sie im Protokoll aufführen, wird dynamischer Dispatch über den Protokolltyp ermöglicht.

protocol Logger {
    func log() -> String
}
extension Logger {
    func log() -> String { "default log" }
}

struct A: Logger {}
struct B: Logger { func log() -> String { "B log" } }

let loggers: [Logger] = [A(), B()]
for l in loggers { print(l.log()) }

Fallstrick beim statischen Dispatch

Wenn eine Methode NUR in der Erweiterung enthalten ist, nicht aber im Protokoll, verwenden Aufrufe über einen Wert mit Protokolltyp die Version der Erweiterung, selbst wenn der konkrete Typ eine eigene Version definiert hat. Für dynamischen Dispatch müssen Sie die Methode im Protokoll deklarieren.

protocol P {}
extension P { func who() -> String { "P-default" } }
struct Q: P { func who() -> String { "Q" } }

let direct = Q()
let asP: P = Q()
print(direct.who())
print(asP.who())

Boilerplate reduzieren

Die Kombination aus einer kleinen erforderlichen Oberfläche und umfangreichen Standards bildet den Kern des protokollorientierten Entwurfs: Konforme Typen implementieren das Minimum, während gemeinsames Verhalten an einer Stelle liegt.

protocol Identifiable { var id: Int { get } }
extension Identifiable {
    var tag: String { "ID-" + String(id) }
}
struct Order: Identifiable { let id: Int }
print(Order(id: 7).tag)

Mehrere Erweiterungen kombinieren

Sie können Standards zur besseren Organisation auf mehrere Erweiterungen aufteilen; sie alle tragen zum konformen Typ bei.

protocol Money { var cents: Int { get } }
extension Money { var dollars: Double { Double(cents) / 100 } }
extension Money { var label: String { "$" + String(format: "%.2f", dollars) } }

struct Price: Money { let cents: Int }
print(Price(cents: 1299).label)

Kurztest

Testen Sie Ihr Verständnis der Standards von Protokollerweiterungen.

Zusammenfassung

Protokollerweiterungen stellen Standardimplementierungen bereit, sodass konforme Typen gemeinsames Verhalten übernehmen und bei Bedarf überschreiben können. Sie können zusätzliche Methoden und berechnete Eigenschaften hinzufügen, Standards mit where einschränken, und Sie haben die Regel für statischen und dynamischen Dispatch kennengelernt: Deklarieren Sie eine Methode für dynamischen Dispatch im Protokoll.

Häufig gestellte Fragen

Ist die Lektion „Standardimplementierungen in Extensions“ kostenlos?

Ja — der vollständige Text von „Standardimplementierungen in Extensions“ 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 „Standardimplementierungen in Extensions“?

Stellen Sie gemeinsames Verhalten über Protocol-Extensions bereit. 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 „Standardimplementierungen in Extensions“?

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

← Zurück zu Swift Academy