Swift Academy · leksjon

Betinget konformitet

La en generisk type konformere bare når begrensningene er oppfylt.

Leksjon 4 av 413 trinn

Betinget konformitet er en gratis leksjon i Swift Academy på CoddyKit. Dette er leksjon 4 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.

Hva er betinget samsvar

Betinget samsvar gjør at en generisk type samsvarer med en protokoll bare når typeparameterne oppfyller bestemte begrensninger. Det klassiske eksempelet er at en Array er Equatable bare når Element er Equatable.

extension Array where Element: Equatable {
    func allEqual(to x: Element) -> Bool {
        allSatisfy { $0 == x }
    }
}

Innebygd eksempel

Standardbiblioteket bruker allerede dette: [Int] er Equatable fordi Int er det. To arrayer sammenlignes element for element.

let a = [1, 2, 3]
let b = [1, 2, 3]
print(a == b)

Deklarere betinget samsvar

Skriv en utvidelse som legger til protokollsamsvar med en where-klausul. Her samsvarer en omslagstype med Equatable bare når verditypen dens gjør det.

struct Pair<T> {
    let first: T
    let second: T
}

extension Pair: Equatable where T: Equatable {
    static func == (l: Pair, r: Pair) -> Bool {
        l.first == r.first && l.second == r.second
    }
}

print(Pair(first: 1, second: 2) == Pair(first: 1, second: 2))

Hvorfor begrensningen er viktig

Uten begrensningen kunne ikke kompilatoren generert ==, fordi sammenligning av den innpakkede verdien krever at selve verdien kan sammenlignes. where-klausulen gir akkurat denne garantien.

struct Box<T> { let value: T }
extension Box: Equatable where T: Equatable {}

print(Box(value: "hi") == Box(value: "hi"))
print(Box(value: 5) == Box(value: 9))

Betinget Codable

Det er mulig å samsvare betinget med Codable. En beholder kan kodes bare når elementet dens kan det.

struct Wrapper<T> { let payload: T }
extension Wrapper: Codable where T: Codable {}

let w = Wrapper(payload: 42)
let data = try! JSONEncoder().encode(w)
print(String(data: data, encoding: .utf8)!)

Flere begrensninger

En where-klausul kan inneholde flere krav, skilt med komma.

struct Stack<T> { var items: [T] = [] }

extension Stack where T: Comparable {
    func maxItem() -> T? { items.max() }
}

var s = Stack<Int>()
s.items = [3, 9, 1]
print(s.maxItem()!)

Betinget CustomStringConvertible

Gjør en type utskrivbar bare når innholdet dens er det, ved å sette sammen beskrivelser fra elementene.

struct Labeled<T> { let label: String; let value: T }

extension Labeled: CustomStringConvertible where T: CustomStringConvertible {
    var description: String { label + ": " + value.description }
}

print(Labeled(label: "Age", value: 30))

Nestet betinget samsvar

Betinget samsvar kan settes sammen: en array med arrayer av Int er Equatable fordi hvert lag viderefører begrensningen.

let grid1 = [[1, 2], [3, 4]]
let grid2 = [[1, 2], [3, 4]]
print(grid1 == grid2)

Begrense til en annen protokoll

where-klausulen kan kreve at elementet samsvarer med en protokoll De har definert, slik at funksjonalitet basert på denne protokollen blir tilgjengelig.

protocol Priced { var price: Double { get } }
struct Item: Priced { let price: Double }

extension Array where Element: Priced {
    var totalPrice: Double { reduce(0) { $0 + $1.price } }
}

print([Item(price: 1.5), Item(price: 2.5)].totalPrice)

Begrensninger av samme type

De kan begrense en assosiert type til en bestemt type ved hjelp av ==. Her gjelder metodene bare for arrayer av String.

extension Array where Element == String {
    func joinedUpper() -> String {
        map { $0.uppercased() }.joined(separator: "-")
    }
}

print(["a", "b", "c"].joinedUpper())

Hvordan kompilatoren bruker dette

Betinget samsvar lar kompilatoren gi fordelene ved en protokoll nøyaktig når de er gyldige, slik at generisk kode forblir både trygg og mest mulig gjenbrukbar.

struct Optional2<T> { let value: T? }
extension Optional2: Equatable where T: Equatable {
    static func == (l: Optional2, r: Optional2) -> Bool { l.value == r.value }
}
print(Optional2(value: 1) == Optional2(value: 1))

Sjekk forståelsen

Test forståelsen av betinget samsvar.

Besvar den i den interaktive leksjonen

Oppsummering

Betinget samsvar bruker extension Type: Protocol where ... for å gi samsvar bare når typeparametere oppfyller begrensninger. De har sett dette brukt med Equatable, Codable og CustomStringConvertible, med protokollbegrensninger, begrensninger av samme type (==) og nøsting. Dette holder generiske typer trygge og gjenbrukbare.

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 «Betinget konformitet» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Swift Academy, inkludert «Betinget konformitet», 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 «Betinget konformitet»?

La en generisk type konformere bare når begrensningene er oppfylt. 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 4 av 4.

Hvor lang tid tar leksjonen «Betinget konformitet»?

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