Swift Academy · Lektion

Protokollkomposition

Kombinera flera protokollkrav med &.

Lektion 3 av 413 steg

Protokollkomposition är en gratis lektion i Swift Academy på CoddyKit. Detta är lektion 3 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.

Kombinera protokoll

Ibland måste ett värde uppfylla flera protokoll samtidigt. Swift låter dig komponera protokoll med operatorn &: SomeProtocol & AnotherProtocol.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }

En sammansatt parameter

En parameter med typen Named & Aged accepterar alla värden som följer båda protokollen.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }

struct Person: Named, Aged {
    let name: String
    let age: Int
}

func intro(_ x: Named & Aged) {
    print(x.name + " is " + String(x.age))
}
intro(Person(name: "Sam", age: 28))

Varför inte arv?

Komposition låter dig kräva båda protokollen vid anropsplatsen utan att skapa ett nytt kombinerat protokoll. Det håller protokollen små och återanvändbara.

protocol Drawable { func draw() -> String }
protocol Resizable { func resize(_ f: Double) -> String }

struct Icon: Drawable, Resizable {
    func draw() -> String { "drawing" }
    func resize(_ f: Double) -> String { "x" + String(f) }
}

func render(_ v: Drawable & Resizable) {
    print(v.draw(), v.resize(2))
}
render(Icon())

Tre eller fler

Du kan kedja ihop så många protokoll som behövs med ytterligare &-operatorer.

protocol A { func a() -> String }
protocol B { func b() -> String }
protocol C { func c() -> String }

struct X: A, B, C {
    func a() -> String { "a" }
    func b() -> String { "b" }
    func c() -> String { "c" }
}

func use(_ v: A & B & C) { print(v.a(), v.b(), v.c()) }
use(X())

Komposition med en klass

Du kan kombinera en klasstyp med protokoll: SomeClass & SomeProtocol kräver att värdet är den klassen eller en underklass OCH följer protokollet.

class Vehicle { var speed = 0 }
protocol Electric { var battery: Int { get } }

class Tesla: Vehicle, Electric { var battery = 100 }

func check(_ v: Vehicle & Electric) {
    print(v.speed, v.battery)
}
check(Tesla())

Returnera en komposition

En funktion kan returnera en sammansatt typ och därmed lova anroparen att resultatet följer alla angivna protokoll.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct Person: Named, Aged { let name: String; let age: Int }

func makePerson() -> Named & Aged {
    Person(name: "Eve", age: 22)
}
let p = makePerson()
print(p.name, p.age)

typealias för komposition

Ge en komposition ett lättläst namn med typealias så att du kan återanvända den utan att upprepa kedjan med &.

protocol Codable2 { func encode() -> String }
protocol Loggable { func log() -> String }

typealias Persistable = Codable2 & Loggable

struct Record: Persistable {
    func encode() -> String { "data" }
    func log() -> String { "logged" }
}
func save(_ r: Persistable) { print(r.encode(), r.log()) }
save(Record())

Komposition i samlingar

Du kan lagra värden av sammansatta typer i arrayer och komma åt alla protokollmedlemmar för varje element.

protocol Named { var name: String { get } }
protocol Aged { var age: Int { get } }
struct P: Named, Aged { let name: String; let age: Int }

let group: [Named & Aged] = [P(name: "A", age: 1), P(name: "B", age: 2)]
for g in group { print(g.name, g.age) }

Komposition med standardprotokoll

Komposition är särskilt användbar med biblioteksprotokoll. Du kan till exempel kräva både CustomStringConvertible och Equatable.

func report<T>(_ items: [T]) where T: CustomStringConvertible & Equatable {
    for i in items { print(i.description) }
}
report([1, 2, 3])

Tomma protokoll som markörer

Sammansättning kan kombinera ett markörprotokoll (utan krav) med ett funktionellt protokoll för att uttrycka avsikten i typsystemet.

protocol Secure {}
protocol Sendable2 { func send() -> String }

struct Packet: Secure, Sendable2 {
    func send() -> String { "sent securely" }
}
func transmit(_ p: Secure & Sendable2) { print(p.send()) }
transmit(Packet())

Sammansättning jämfört med generics

Sammansättning (A & B) döljer den konkreta typen, medan generics (<T: A & B>) bevarar den. Använd generics när Ni behöver relatera parameter- och returtyper.

protocol A { func a() -> String }
protocol B { func b() -> String }
struct S: A, B { func a() -> String { "a" }; func b() -> String { "b" } }

func generic<T: A & B>(_ x: T) -> T { print(x.a(), x.b()); return x }
_ = generic(S())

Snabb kontroll

Testa Er förståelse av protokollsammansättning.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Med protokollsammansättning och & kan Ni kräva att en typ uppfyller flera protokoll (och valfritt en klass) samtidigt, utan att definiera ett nytt kombinerat protokoll. Ni kan namnge sammansättningar med typealias, använda dem för parametrar, returvärden och samlingar, och Ni har sett hur sammansättning skiljer sig från generics när det gäller att bevara konkreta typer.

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 ”Protokollkomposition” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Swift Academy, inklusive ”Protokollkomposition”, 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 ”Protokollkomposition”?

Kombinera flera protokollkrav med &. 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 3 av 4.

Hur lång tid tar lektionen ”Protokollkomposition”?

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