Swift Academy · Lektion

where-clauses på funktioner

Tilføj detaljerede begrænsninger til generiske funktioner.

Lektion 2 af 413 trin

where-clauses på funktioner er en gratis Swift Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Swift Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Swift Academy-kurset indeholder 4 lektioner i alt.

Ud over simple begrænsninger

En begrænsning som <T: Collection> beskriver selve T. Men nogle gange skal du begrænse associerede typer for T, f.eks. dens Element. Det er det, en where-klausul gør.

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

Krav om samme type

where C.Element == Int kræver, at samlingens elementer præcis er Int, så du kan udføre arbejde, der er specifikt for heltal.

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

Protokolkrav til elementet

Du kan kræve, at elementet overholder en protokol, i stedet for at det skal være én bestemt type, hvilket er mere fleksibelt.

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

where kommer efter signaturen

where-klausulen står mellem returtypen og funktionskroppen. Begrænsninger i <> og where-klausulen fungerer sammen.

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

Sammenkædning af to typeparametre

En where-klausul kan knytte elementtyperne for to forskellige generiske typer sammen med ==.

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])))

Flere where-betingelser

Angiv flere krav adskilt af kommaer for at udtrykke sammensatte begrænsninger.

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])

Begrænsning af indlejrede associerede typer

Du kan gå længere ned, f.eks. ved at kræve typen for et elements element, når du arbejder med indlejrede samlinger.

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 med Equatable-elementer

Hvis du kræver Equatable-elementer, kan du søge i en generisk samling.

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") }

Generiske metoder med where

Metoder inde i generiske typer bruger også where, ofte til kun at tilføje funktionalitet for bestemte elementtyper.

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

Fordel for læsbarheden

Komplekse begrænsninger er nemmere at læse i en where-klausul end klemt ind i vinkelparenteserne, især når der er flere betingelser for associerede typer.

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

where i standardbiblioteket

Metoder som joined() på sekvenser af sekvenser bruger internt where-klausuler til at udtrykke deres krav præcist.

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

Hurtigt tjek

Test din forståelse af where-klausuler på funktioner.

Besvar den i den interaktive lektion

Opsamling

where-klausuler lader dig begrænse en generisk types associerede typer: kræve, at et element er en bestemt type (== Int), overholder en protokol (: Comparable), knytte to parametres elementer sammen eller gå ned i indlejrede associerede typer. De står efter signaturen og gør komplekse begrænsninger nemmere at læse.

Gratis at komme i gang

Lær Swift med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 122
Lektioner: 409

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “where-clauses på funktioner” gratis?

Ja — alle 3 lektioner i læringssporet Swift Academy, inklusive “where-clauses på funktioner”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Swift Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “where-clauses på funktioner”?

Tilføj detaljerede begrænsninger til generiske funktioner. Du øver dig i Swift Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Swift Academy?

Der kræves ingen tidligere erfaring. Swift Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “where-clauses på funktioner”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Swift Academy-lektion?

Ja. Alle Swift Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Swift Academy