Swift Academy · Lektion

Self-krav och Equatable-design

Utforska protokoll som använder Self och hur Equatable/Comparable utnyttjar dem.

Lektion 3 av 412 steg

Self-krav och Equatable-design ä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.

Välkommen

`Self` i ett protokoll syftar på den konkreta typ som konformerar med protokollet. Det gör att protokoll som `Equatable` och `Comparable` kan fungera säkert med heterogena typer.

Self som parametertyp

```swift protocol Equatable { static func == (lhs: Self, rhs: Self) -> Bool } ``` `Self` betyder att båda parametrarna måste ha samma konkreta typ. Det går inte att jämföra en `Int` med en `String` via detta protokoll.

Konformans med Equatable

```swift struct Point: Equatable { var x: Double var y: Double // Auto-synthesised: // static func == (lhs: Point, rhs: Point) -> Bool // { lhs.x == rhs.x && lhs.y == rhs.y } } print(Point(x:1,y:2) == Point(x:1,y:2)) // true ```

Comparable med Self

```swift struct Version: Comparable { let major, minor, patch: Int static func < (lhs: Version, rhs: Version) -> Bool { (lhs.major, lhs.minor, lhs.patch) < (rhs.major, rhs.minor, rhs.patch) } } let v1 = Version(major:1,minor:2,patch:0) let v2 = Version(major:2,minor:0,patch:0) print(v1 < v2) // true ```

Self som returtyp

```swift protocol Clonable { func clone() -> Self } class Animal: Clonable { var name: String = "" required init() {} func clone() -> Self { type(of: self).init() } } ``` `Self` i returtypen betyder att subklasser returnerar sin egen typ, inte `Animal`.

Protokoll med Self-krav (PAT)

```swift protocol Scalable { func scaled(by factor: Double) -> Self } struct Size: Scalable { var w, h: Double func scaled(by f: Double) -> Size { Size(w: w*f, h: h*f) } } ```

Hashable: Self + Equatable

```swift struct Color: Hashable { var r, g, b: UInt8 // Auto-synthesised: func hash(into:) and == } var palette: Set = [] palette.insert(Color(r:255,g:0,b:0)) ``` `Hashable` kräver `Equatable` — båda syntetiseras automatiskt för enkla strukturer.

Protokoll med Self kan inte användas direkt som existential

```swift // Before Swift 5.7: var shapes: [Equatable] = [] // ❌ Equatable has Self requirement // After Swift 5.7 with 'any': var boxes: [any Equatable] = [] // ⚠️ limited API ``` Nyckelordet `any` aktiverar uttryckligen existential boxing.

Förutsättningar för automatisk syntes

Automatisk syntes av `Equatable`/`Hashable`/`Comparable` kräver: • Alla lagrade egenskaper konformerar med samma protokoll • Enum-fall, inklusive associerade värden, konformerar ```swift struct Pair: Equatable { var a, b: T } // Equatable synthesised automatically ```

Anpassad åsidosättning av Equatable

```swift struct Person: Equatable { var id: UUID var name: String // Only compare by id, ignore name: static func == (lhs: Person, rhs: Person) -> Bool { lhs.id == rhs.id } } ```

Snabbkontroll

Vad syftar `Self` på i ett protokoll?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Viktiga punkter: • `Self` = den konkreta typ som konformerar med protokollet • `Equatable`, `Comparable` och `Hashable` använder alla `Self` • Swift syntetiserar automatiskt dessa för enkla strukturer och enum-typer • `Self` i returtyper ger API:er som bevarar typen • Protokoll med Self-krav behöver `any` för existentials (Swift 5.7+) Nästa avsnitt: principer för protokollorienterad design.

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 ”Self-krav och Equatable-design” gratis?

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

Utforska protokoll som använder Self och hur Equatable/Comparable utnyttjar dem. 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 ”Self-krav och Equatable-design”?

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

Protokollkomposition med &
Villkorad protokollkonformans
Self-krav och Equatable-design
Principer för protokollorienterad design

← Tillbaka till Swift Academy