Protocol în Swift — ce este, sintaxa și posibilități

Ce este Protocol în Swift?

Protocol — este o interfață abstractă care definește ce trebuie să poată face un tip, dar nu cum o face. În Swift, protocolul este analogul interfețelor din Java sau Go, dar cu capacități suplimentare.

Protocolul poate cere:

• Metode de instanță și de tip (statice)
• Proprietăți cu specificatorul { get } sau { get set }
• Inițializatori
• Subscriptori
• Associated types (generice la nivel de protocol)

Conform WWDC 2015, Apple a prezentat Protocol-Oriented Programming ca o abordare fundamentală pentru arhitectura aplicațiilor Swift. Spre deosebire de OOP, unde moștenirea claselor creează ierarhii rigide, POP propune compoziția protocoalelor. Aceasta oferă flexibilitate: un tip poate corespunde mai multor protocoale, primind cerințele și implementările lor prin extensions.

Sintaxa declarării protocoalelor

Protocol se declară cu cuvântul cheie protocol cu nume și corp.

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

Tipul adoptă protocolul prin două puncte după nume:

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

Un tip poate adopta mai multe protocoale separate prin virgulă: struct MyType: ProtocolA, ProtocolB. Compilatorul verifică dacă toate cerințele fiecărui protocol sunt îndeplinite.

Cerințe de metode și proprietăți

Property requirements se specifică cu cuvântul cheie var și specificatorii de acces { get } sau { get set }.

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

Cuvântul cheie mutating în protocol înseamnă că metoda poate modifica self. Structurile trebuie să implementeze o astfel de metodă ca mutating, clasele pot omite. Method requirements se specifică cu semnătura completă, inclusiv etichetele parametrilor.

Moștenirea protocoalelor

Protocol poate moșteni un alt protocol, adăugând noi cerințe. Aceasta creează o ierarhie de contracte fără legătură rigidă cu clasele.

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

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

Tipul care adoptă Flyable trebuie să îndeplinească cerințele ambelor protocoale — atât Vehicle, cât și Flyable. Swift suportă moștenirea multiplă a protocoalelor: protocol A: B, C.

Protocol Composition

Protocol Composition — mecanism care permite specificarea că un tip trebuie să corespundă mai multor protocoale simultan, fără a crea un protocol de combinație nou.

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

Composition (&) funcționează în parametrii funcțiilor, variabilelor și constrângerilor generice. Compilatorul verifică dacă tipul transmis simultan satisface toate protocoalele. Composition este des folosit în SwiftUI: some View — este un generic cu composition.

Protocol Composition este preferabil creării unei ierarhii de moștenire: în loc de protocol A: B, C se poate adopta direct B & C. Aceasta oferă flexibilitate și reduce cuplarea. Composition este deosebit de convenabil în parametrii funcțiilor și constrângerile generice, unde trebuie să combini temporar cerințe fără a crea un protocol intermediar. Aceasta reduce numărul de tipuri auxiliare în cod.

Protocol ca tip

Protocol poate fi folosit ca tip de variabilă, parametru de funcție sau element de colecție. Acesta se numește existential type.

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

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

Cuvântul cheie any (Swift 5.6+) indică explicit existential. Fără any compilatorul emite un avertisment. Swift suportă de asemenea some (opaque types) pentru ascunderea tipului concret în spatele unui protocol — aceasta este tehnica standard în SwiftUI.

Greșeli tipice cu protocoale

La lucrul cu protocol, dezvoltatorii fac adesea câteva greșeli recurente.

• Mutating uitat — metoda în protocol este marcată ca mutating, iar structura o implementează fără cuvântul cheie
• Protocol as type în loc de generic — utilizarea Drawable în loc de <T: Drawable> acolo unde este nevoie de un tip concret
• Circular protocol reference — protocol care se referă la sine prin associated type, fără o rezolvare corectă
• Class-only protocol — utilizarea AnyObject fără necesitate, ceea ce exclude struct și enum