Swift Academy · Lektion

where-Klauseln für Funktionen

Fügen Sie generischen Funktionen fein abgestufte Einschränkungen hinzu.

where-Klauseln für Funktionen 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.

Über einfache Einschränkungen hinaus

Eine Einschränkung wie <T: Collection> beschreibt T selbst. Manchmal müssen Sie jedoch die assoziierten Typen von T einschränken, beispielsweise sein Element. Dafür gibt es eine where-Klausel.

func sumInts<C: Collection>(_ c: C) -> Int where C.Element == Int {
    c.reduce(0, +)
}
print(sumInts([1, 2, 3]))

Same-Type-Anforderung

where C.Element == Int verlangt, dass die Elemente der Collection genau den Typ Int haben, und ermöglicht dadurch typspezifische Operationen für Ganzzahlen.

func describe<C: Collection>(_ c: C) -> String where C.Element == Int {
    "Sum is " + String(c.reduce(0, +))
}
print(describe(Set([1, 2, 3])))

Protokollanforderung für Element

Sie können verlangen, dass das Element zu einem Protokoll konform ist, statt einen einzigen konkreten Typ vorzugeben. Das ist flexibler.

func joinAll<C: Collection>(_ c: C) -> String
    where C.Element: CustomStringConvertible {
    c.map { $0.description }.joined(separator: ", ")
}
print(joinAll([1, 2, 3]))

where nach der Signatur

Die where-Klausel steht zwischen dem Rückgabetyp und dem Funktionskörper. Einschränkungen innerhalb von <> und die where-Klausel wirken zusammen.

func maxElement<C: Collection>(_ c: C) -> C.Element?
    where C.Element: Comparable {
    c.max()
}
print(maxElement([4, 9, 2])!)

Zwei Typparameter aufeinander beziehen

Eine where-Klausel kann die Elementtypen zweier verschiedener Generics mit == miteinander verknüpfen.

func combine<A: Collection, B: Collection>(_ a: A, _ b: B) -> [A.Element]
    where A.Element == B.Element {
    Array(a) + Array(b)
}
print(combine([1, 2], Set([3])))

Mehrere where-Bedingungen

Führen Sie mehrere durch Kommas getrennte Anforderungen auf, um kombinierte Einschränkungen auszudrücken.

func report<C: Collection>(_ c: C)
    where C.Element: Comparable, C.Element: CustomStringConvertible {
    if let m = c.max() { print("max:", m.description) }
}
report([5, 1, 9])

Verschachtelte assoziierte Typen einschränken

Sie können bei verschachtelten Collections noch tiefer gehen, beispielsweise den Elementtyp eines Elements einschränken.

func flatten<C: Collection>(_ c: C) -> [Int]
    where C.Element: Collection, C.Element.Element == Int {
    c.flatMap { Array($0) }
}
print(flatten([[1, 2], [3]]))

where mit Equatable-Elementen

Wenn Sie Equatable-Elemente voraussetzen, können Sie eine generische Collection durchsuchen.

func indexOf<C: Collection>(_ x: C.Element, in c: C) -> C.Index?
    where C.Element: Equatable {
    c.firstIndex(of: x)
}
if let i = indexOf(2, in: [1, 2, 3]) { print("found") }

Generische Methoden mit where

Auch Methoden innerhalb generischer Typen verwenden where, häufig um Verhalten nur für bestimmte Elementtypen hinzuzufügen.

struct Wrap<T> {
    let items: [T]
    func total() -> Int where T == Int { items.reduce(0, +) }
}
print(Wrap(items: [1, 2, 3]).total())

Vorteil für die Lesbarkeit

Komplexe Einschränkungen sind in einer where-Klausel übersichtlicher als in die spitzen Klammern gedrängt, insbesondere bei mehreren Bedingungen für assoziierte Typen.

func first<C: Collection>(_ c: C) -> String
    where C.Element: CustomStringConvertible {
    c.first.map { $0.description } ?? "empty"
}
print(first([10, 20]))

where in der Standardbibliothek

Methoden wie joined() für Sequenzen von Sequenzen verwenden intern where-Klauseln, um ihre Anforderungen präzise auszudrücken.

let nested = [[1, 2], [3, 4]]
print(Array(nested.joined()))

Kurzer Test

Testen Sie Ihr Verständnis der where-Klauseln für Funktionen.

Zusammenfassung

Mit where-Klauseln können Sie die assoziierten Typen eines Generics einschränken: Sie können verlangen, dass ein Element einen bestimmten Typ hat (== Int), zu einem Protokoll konform ist (: Comparable), die Elemente zweier Parameter aufeinander beziehen oder verschachtelte assoziierte Typen erreichen. Sie stehen nach der Signatur und sorgen dafür, dass komplexe Einschränkungen lesbar bleiben.

Häufig gestellte Fragen

Ist die Lektion „where-Klauseln für Funktionen“ kostenlos?

Ja — der vollständige Text von „where-Klauseln für Funktionen“ 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 „where-Klauseln für Funktionen“?

Fügen Sie generischen Funktionen fein abgestufte Einschränkungen hinzu. 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 „where-Klauseln für Funktionen“?

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