Swift Academy · leksjon

Begrense assosierte typer

Begrens assosierte typer i generiske kontekster.

Leksjon 3 av 413 trinn

Begrense assosierte typer er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Swift Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Oppsummering av assosierte typer

En protokoll kan deklarere en assosiert type med associatedtype, som er en plassholder den samsvarende typen fyller ut. Element i en beholderprotokoll er det klassiske eksempelet.

protocol Container {
    associatedtype Item
    var count: Int { get }
    func item(at i: Int) -> Item
}

Samsvar med en konkret type

En type som samsvarer med protokollen, fastsetter den assosierte typen, som ofte utledes fra hvordan typen brukes.

protocol Container {
    associatedtype Item
    func item(at i: Int) -> Item
}
struct IntBox: Container {
    let values: [Int]
    func item(at i: Int) -> Int { values[i] }
}
print(IntBox(values: [10, 20]).item(at: 1))

Begrense den assosierte typen

Legg til en begrensning direkte i deklarasjonen: associatedtype Item: Comparable tvinger item-typen til alle samsvarende typer til å støtte sammenligning.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [3, 1, 2]).items.sorted())

Bruke begrensningen

Fordi den assosierte typen er begrenset, kan protokollutvidelser stole på denne funksjonaliteten.

protocol Sorted {
    associatedtype Item: Comparable
    var items: [Item] { get }
}
extension Sorted {
    var smallest: Item? { items.min() }
}
struct Nums: Sorted { let items: [Int] }
print(Nums(items: [5, 2, 8]).smallest!)

where på associatedtype

Swift tillater også en where-klausul på en assosiert type for å knytte den til en annen assosiert type eller en nøstet type.

protocol Sequence2 {
    associatedtype Element
    associatedtype Iterator: IteratorProtocol where Iterator.Element == Element
}

Begrense til en annen protokoll

En assosiert type kan kreves å samsvare med en protokoll De har definert, slik at funksjonalitet kan bygges lagvis.

protocol HasName { var name: String { get } }
protocol Registry {
    associatedtype Entry: HasName
    var entries: [Entry] { get }
}
struct User: HasName { let name: String }
struct Users: Registry { let entries: [User] }
print(Users(entries: [User(name: "Ada")]).entries[0].name)

Flere assosierte typer

En protokoll kan deklarere flere assosierte typer, hver med sine egne begrensninger.

protocol Mapping {
    associatedtype Key: Hashable
    associatedtype Value
    func value(for k: Key) -> Value?
}
struct Phonebook: Mapping {
    let data: [String: Int]
    func value(for k: String) -> Int? { data[k] }
}
print(Phonebook(data: ["x": 1]).value(for: "x")!)

Standardverdi for assosiert type

De kan gi en assosiert type en standardverdi med =, som brukes når en samsvarende type ikke angir noe annet.

protocol Producer {
    associatedtype Output = String
    func make() -> Output
}
struct Hello: Producer {
    func make() -> String { "hi" }
}
print(Hello().make())

Begrensninger muliggjør generiske algoritmer

Med en begrenset assosiert type kan en protokollutvidelse implementere reelle algoritmer som deles av alle samsvarende typer.

protocol Scored {
    associatedtype Score: Comparable
    var scores: [Score] { get }
}
extension Scored {
    var best: Score? { scores.max() }
}
struct Game: Scored { let scores: [Int] }
print(Game(scores: [10, 40, 25]).best!)

Begrensninger av samme type i utvidelser

Utenfor protokollen kan De begrense den assosierte typen ytterligere når De utvider protokollen.

protocol Box2 {
    associatedtype Content
    var content: Content { get }
}
extension Box2 where Content == Int {
    var doubled: Int { content * 2 }
}
struct IB: Box2 { let content: Int }
print(IB(content: 7).doubled)

Hvorfor begrense

Begrensning av assosierte typer er måten protokoller kan være generiske og samtidig kraftige på: Begrensningen er et løfte som utvidelsen og kallere kan stole på.

protocol Listy {
    associatedtype E: Equatable
    var elements: [E] { get }
}
extension Listy {
    func has(_ x: E) -> Bool { elements.contains(x) }
}
struct L: Listy { let elements: [String] }
print(L(elements: ["a", "b"]).has("b"))

Sjekk forståelsen

Test forståelsen av begrensning av assosierte typer.

Besvar den i den interaktive leksjonen

Oppsummering

De kan begrense assosierte typer direkte (associatedtype Item: Comparable), knytte dem sammen med where-klausuler, kreve protokollsamsvar, angi standardverdier med =, deklarere flere assosierte typer og videre begrense dem i utvidelser. Begrensninger lar protokollutvidelser implementere delte, typesikre algoritmer.

Gratis å komme i gang

Lær deg Swift med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 122
Leksjoner: 409

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Begrense assosierte typer» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Begrense assosierte typer», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Swift Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Begrense assosierte typer»?

Begrens assosierte typer i generiske kontekster. Du øver på Swift Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Swift Academy?

Ingen tidligere erfaring er nødvendig. Swift Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Begrense assosierte typer»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Swift Academy-leksjonen?

Ja. Alle Swift Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Swift Academy