Protocol sa Swift — ano ito, syntax, at mga kakayahan

Ano ang Protocol sa Swift?

Protocol — ay isang abstract na interface na tumutukoy kung ano ang dapat gawin ng isang uri, ngunit hindi kung paano ito gagawin. Sa Swift, ang protokol ay katulad ng mga interface sa Java o Go, ngunit may mga karagdagang kakayahan.

Ang isang protokol ay maaaring mangailangan ng:

• Mga pamamaraan ng instance at uri (static)
• Mga pag-aari na may specifier na { get } o { get set }
• Mga inisyalisador
• Mga subskripsyon
• Associated types (generics sa antas ng protokol)

Ayon sa WWDC 2015, ipinakilala ng Apple ang Protocol-Oriented Programming bilang isang pangunahing diskarte sa arkitektura ng mga aplikasyon ng Swift. Hindi tulad ng OOP, kung saan ang pamana ng klase ay lumilikha ng mahigpit na hirarkiya, ang POP ay nag-aalok ng komposisyon ng mga protokol. Ito ay nagbibigay ng flexibilidad: isang uri ay maaaring tumugma sa maraming protokol, na natatanggap ang kanilang mga kinakailangan at implementasyon sa pamamagitan ng extensions.

Syntax ng deklarasyon ng protokol

Protocol ay idinedeklara gamit ang keyword na protocol na may pangalan at katawan.

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

Ang uri ay tumatanggap ng protokol sa pamamagitan ng tutuldok pagkatapos ng pangalan:

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)
    }
}

Isang uri ay maaaring tumanggap ng maraming protokol na pinaghihiwalay ng kuwit: struct MyType: ProtocolA, ProtocolB. Sinusuri ng compiler kung ang lahat ng kinakailangan ng bawat protokol ay natugunan.

Mga kinakailangan ng pamamaraan at pag-aari

Property requirements ay tinutukoy gamit ang keyword na var at mga specifier ng access na { get } o { get set }.

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

Ang keyword na mutating sa isang protokol ay nangangahulugan na ang pamamaraan ay maaaring magbago ng self. Ang mga istruktura ay dapat magpatupad ng naturang pamamaraan bilang mutating, ang mga klase ay maaaring alisin ito. Method requirements ay tinutukoy na may kumpletong lagda kasama ang mga label ng parameter.

Pamana ng mga protokol

Protocol ay maaaring magmana ng isa pang protokol, na nagdaragdag ng mga bagong kinakailangan. Ito ay lumilikha ng hirarkiya ng mga kontrata nang walang mahigpit na pagkakatali sa mga klase.

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

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

Ang uri na tumatanggap ng Flyable ay dapat matugunan ang mga kinakailangan ng parehong protokol — parehong Vehicle at Flyable. Swift ay sumusuporta sa maramihang pamana ng mga protokol: protocol A: B, C.

Protocol Composition

Protocol Composition — mekanismo na nagpapahintulot na tukuyin na ang isang uri ay dapat tumugma sa maraming protokol nang sabay-sabay, nang hindi lumilikha ng bagong kombinasyon na protokol.

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

Composition (&) ay gumagana sa mga parameter ng function, variable, at generic na mga hadlang. Sinusuri ng compiler kung ang ipinasa na uri ay sabay-sabay na natutugunan ang lahat ng protokol. Ang Composition ay madalas na ginagamit sa SwiftUI: some View — ay isang generic na may composition.

Ang Protocol Composition ay mas pinipili kaysa sa paglikha ng hirarkiya ng pamana: sa halip na protocol A: B, C ay maaaring direktang tumanggap ng B & C. Ito ay nagbibigay ng flexibilidad at nagbabawas ng coupling. Ang Composition ay lalong maginhawa sa mga parameter ng function at generic na mga hadlang, kung saan kailangang pansamantalang pagsamahin ang mga kinakailangan nang hindi lumilikha ng intermediary na protokol. Ito ay nagbabawas ng bilang ng mga pantulong na uri sa code.

Protocol bilang uri

Protocol ay maaaring gamitin bilang uri ng variable, parameter ng function, o elemento ng koleksyon. Ito ay tinatawag na existential type.

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

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

Ang keyword na any (Swift 5.6+) ay malinaw na nagpapahiwatig ng existential. Kung wala ang any ang compiler ay nagbibigay ng babala. Swift ay sumusuporta rin ng some (opaque types) para itago ang konkretong uri sa likod ng isang protokol — ito ay karaniwang pamamaraan sa SwiftUI.

Mga karaniwang pagkakamali sa mga protokol

Sa pagtatrabaho sa protocol, ang mga developer ay madalas na gumagawa ng ilang paulit-ulit na pagkakamali.

• Nakalimutang mutating — ang pamamaraan sa protokol ay minarkahan bilang mutating, ngunit ang istraktura ay nagpapatupad nito nang walang keyword
• Protocol as type sa halip na generic — paggamit ng Drawable sa halip na <T: Drawable> kung saan kailangan ang konkretong uri
• Circular protocol reference — protokol na tumutukoy sa sarili nito sa pamamagitan ng associated type, nang walang tamang resolusyon
• Class-only protocol — paggamit ng AnyObject nang hindi kailangan, na nagbubukod sa struct at enum