Swift Academy · Lektion

where-satser på funktioner

Lägg till finfördelade begränsningar i generiska funktioner.

Lektion 2 av 413 steg

where-satser på funktioner är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 2 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Swift Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Swift Academy innehåller totalt 4 lektioner.

Mer än enkla begränsningar

En begränsning som <T: Collection> beskriver själva T. Men ibland behöver Ni begränsa associerade typer hos T, till exempel dess Element. Det är vad en where-sats gör.

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

Same-type-krav

where C.Element == Int kräver att samlingens element är exakt Int, vilket möjliggör arbete som är specifikt för heltal.

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

Protokollkrav för elementet

Ni kan kräva att elementet uppfyller ett protokoll i stället för att vara en enda specifik typ, vilket är mer flexibelt.

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

where efter signaturen

where-satsen placeras mellan returtypen och funktionskroppen. Begränsningar inuti <> och where-satsen samverkar.

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

Relatera två typparametrar

En where-sats kan koppla ihop elementtyperna hos två olika generics 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])))

Flera villkor i where

Lista flera krav separerade med kommatecken för att uttrycka sammansatta begränsningar.

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änsa nästlade associerade typer

Ni kan gå djupare, till exempel genom att kräva något av typen hos ett elements element, när Ni arbetar med nästlade samlingar.

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-element

Genom att kräva Equatable-element kan Ni söka 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") }

Generiska metoder med where

Metoder inuti generiska typer använder också where, ofta för att lägga till funktionalitet endast för vissa elementtyper.

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

Fördel för läsbarheten

Komplexa begränsningar blir tydligare i en where-sats än när de packas in i vinkelparenteserna, särskilt när flera villkor för associerade typer används.

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 av sekvenser använder internt where-satser för att uttrycka sina krav exakt.

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

Snabb kontroll

Testa Er förståelse av where-satser för funktioner.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Med where-satser kan Ni begränsa en generisk typs associerade typer: kräva att ett element är en specifik typ (== Int), uppfyller ett protokoll (: Comparable), relatera element hos två parametrar eller nå in i nästlade associerade typer. De placeras efter signaturen och gör komplexa begränsningar lättare att läsa.

Gratis att börja

Lär dig Swift med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 122
Lektioner: 409

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”where-satser på funktioner” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”where-satser på funktioner”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Swift Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”where-satser på funktioner”?

Lägg till finfördelade begränsningar i generiska funktioner. Ni övar på Swift Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Swift Academy?

Du behöver inga förkunskaper. Utbildningen i Swift Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”where-satser på funktioner”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Swift Academy-lektionen?

Ja. Varje Swift Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Swift Academy