Protocol a Swift-ben — mi ez, szintaxis és lehetőségek

Mi az a Protocol a Swift-ben?

Protocol — egy absztrakt interfész, amely meghatározza, mit kell tudnia egy típusnak, de nem azt, hogy hogyan csinálja. Swift-ben a protokoll a Java vagy Go interfészeinek megfelelője, de további képességekkel.

A protokoll megkövetelheti:

• Metódusokat példány és típus (statikus) szinten
• Tulajdonságokat { get } vagy { get set } specifikátorral
• Inicializálókat
• Szubskripteket
• Associated types (generikusok protokoll szinten)

A WWDC 2015 szerint az Apple bemutatta a Protocol-Oriented Programming-ot, mint a Swift alkalmazások architektúrájának alapvető megközelítését. Ellentétben az OOP-val, ahol az osztályöröklődés merev hierarchiákat hoz létre, a POP a protokollok kompozícióját kínálja. Ez rugalmasságot ad: egy típus több protokollnak is megfelelhet, és azok követelményeit és implementációit extensions-ökön keresztül kaphatja meg.

A protokollok deklarálásának szintaxisa

Protocol a protocol kulcsszóval deklarálható névvel és törzzsel.

protocol Drawable {
    func draw(context: CGContext)
    var boundingBox: CGRect { get }
}

A típus kettősponttal fogadja el a protokollt a név után:

struct Circle: Drawable {
    let center: CGPoint
    let radius: CGFloat

    func draw(context: CGContext) {
        context.addArc(center: center, radius: radius, ...)
    }

    var boundingBox: CGRect {
        CGRect(x: center.x - radius, y: center.y - radius,
               width: radius * 2, height: radius * 2)
    }
}

Egy típus több protokollt is elfogadhat vesszővel elválasztva: struct MyType: ProtocolA, ProtocolB. A fordító ellenőrzi, hogy minden protokoll összes követelménye teljesül-e.

Metódusok és tulajdonságok követelményei

Property requirements a var kulcsszóval és { get } vagy { get set } hozzáférés-specifikátorokkal adhatók meg.

protocol UserProtocol {
    var name: String { get }
    var age: Int { get set }
    static var maxAge: Int { get }
    mutating func updateName(_ newName: String)
}

A mutating kulcsszó egy protokollban azt jelenti, hogy a metódus módosíthatja a self-et. A struktúráknak ilyen metódust mutating-ként kell implementálniuk, az osztályok elhagyhatják. Method requirements teljes aláírással, beleértve a paramétercímkéket is megadhatók.

Protokollok öröklődése

Protocol örökölhet egy másik protokollt, új követelményeket hozzáadva. Ez a szerződések hierarchiáját hozza létre anélkül, hogy mereven kötődne az osztályokhoz.

protocol Vehicle {
    var speed: Double { get set }
    func move()
}

protocol Flyable: Vehicle {
    var altitude: Double { get set }
    func takeOff()
}

A Flyable-t elfogadó típusnak teljesítenie kell mindkét protokoll követelményeit — mind a Vehicle, mind a Flyable követelményeit. Swift támogatja a protokollok többszörös öröklődését: protocol A: B, C.

Protocol Composition

Protocol Composition — egy mechanizmus, amely lehetővé teszi annak meghatározását, hogy egy típusnak egyszerre több protokollnak kell megfelelnie, anélkül, hogy új kombinációs protokollt hoznánk létre.

func render(_ item: Drawable & Animatable) {
    item.draw(context: ...)
    item.animate(duration: 0.3)
}

Composition (&) függvényparaméterekben, változókban és generikus megszorításokban működik. A fordító ellenőrzi, hogy az átadott típus egyszerre felel-e meg minden protokollnak. Composition gyakran használatos a SwiftUI-ban: some View — ez egy generikus composition-nal.

A Protocol Composition előnyösebb, mint egy öröklődési hierarchia létrehozása: a protocol A: B, C helyett közvetlenül elfogadható a B & C. Ez rugalmasságot ad és csökkenti a kapcsolódást. A Composition különösen kényelmes függvényparaméterekben és generikus megszorításokban, ahol ideiglenesen kell kombinálni követelményeket anélkül, hogy köztes protokollt hoznánk létre. Ez csökkenti a segédtípusok számát a kódban.

Protocol mint típus

Protocol használható változó típusaként, függvényparaméterként vagy gyűjteményelemként. Ezt existential type-nak nevezzük.

var drawableItem: Drawable
let items: [Drawable] = [Circle(...), Rectangle(...)]

func process(drawables: [any Drawable]) {
    for item in drawables {
        item.draw(context: ...)
    }
}

A any (Swift 5.6+) kulcsszó kifejezetten jelzi az existential-t. any nélkül a fordító figyelmeztetést ad. Swift támogatja továbbá a some (opaque types) használatát a konkrét típus protokoll mögé rejtésére — ez a szokásos technika a SwiftUI-ban.

Gyakori hibák a protokollokkal

A protocol használata során a fejlesztők gyakran elkövetnek néhány ismétlődő hibát.

• Elfelejtett mutating — a metódus a protokollban mutating-ként van jelölve, de a struktúra kulcsszó nélkül implementálja
• Protocol as type generikus helyett — Drawable használata <T: Drawable> helyett ott, ahol konkrét típusra van szükség
• Circular protocol reference — protokoll, amely associated type-on keresztül hivatkozik önmagára, helyes feloldás nélkül
• Class-only protocol — AnyObject használata szükségtelenül, ami kizárja a struct-ot és enum-ot