Protocol в Swift — какво е, синтаксис и възможности

Какво е Protocol в Swift?

Protocol — е абстрактен интерфейс, който определя какво трябва да може да прави даден тип, но не и как го прави. В Swift протоколът е аналог на интерфейсите от Java или Go, но с допълнителни възможности.

Протоколът може да изисква:

• Методи на инстанция и тип (статични)
• Свойства със спецификатор { get } или { get set }
• Инициализатори
• Субскрипти
• Associated types (генернци на ниво протокол)

Според WWDC 2015, Apple представи Protocol-Oriented Programming като фундаментален подход към архитектурата на Swift приложения. За разлика от ООП, където наследяването на класове създава твърди йерархии, POP предлага композиция на протоколи. Това дава гъвкавост: един тип може да отговаря на няколко протокола, получавайки техните изисквания и реализации чрез extensions.

Синтаксис за деклариране на протоколи

Protocol се декларира с ключовата дума protocol с име и тяло.

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

Типът приема протокола чрез двоеточие след името:

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

Един тип може да приеме няколко протокола, разделени със запетая: struct MyType: ProtocolA, ProtocolB. Компилаторът проверява дали всички изисквания на всеки протокол са изпълнени.

Изисквания за методи и свойства

Property requirements се задават с ключовата дума var и спецификатори за достъп { get } или { get set }.

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

Ключовата дума mutating в протокола означава, че методът може да променя self. Структурите трябва да имплементират такъв метод като mutating, класовете могат да го пропуснат. Method requirements се задават с пълен подпис, включително етикети на параметрите.

Наследяване на протоколи

Protocol може да наследи друг протокол, добавяйки нови изисквания. Това създава йерархия от договори без твърда обвързаност с класове.

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

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

Типът, който приема Flyable, трябва да изпълни изискванията и на двата протокола — както на Vehicle, така и на Flyable. Swift поддържа множествено наследяване на протоколи: protocol A: B, C.

Protocol Composition

Protocol Composition — механизъм, който позволява да се зададе, че тип трябва да отговаря на няколко протокола едновременно, без да се създава нов комбиниран протокол.

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

Composition (&) работи в параметри на функции, променливи и генерични ограничения. Компилаторът проверява дали предаденият тип едновременно удовлетворява всички протоколи. Composition се използва често в SwiftUI: some View — това е генерик с composition.

Protocol Composition се предпочита пред създаването на йерархия на наследяване: вместо protocol A: B, C може директно да се приеме B & C. Това дава гъвкавост и намалява свързаността. Composition е особено удобен в параметри на функции и генерични ограничения, където трябва временно да се комбинират изисквания без създаване на междинен протокол. Това намалява броя на помощните типове в кода.

Protocol като тип

Protocol може да се използва като тип на променлива, параметър на функция или елемент на колекция. Това се нарича existential type.

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

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

Ключовата дума any (Swift 5.6+) изрично показва existential. Без any компилаторът издава предупреждение. Swift също поддържа some (opaque types) за скриване на конкретния тип зад протокол — това е стандартна техника в SwiftUI.

Типични грешки с протоколи

При работа с protocol разработчиците често допускат няколко повтарящи се грешки.

• Забравено mutating — методът в протокола е маркиран като mutating, а структурата го имплементира без ключова дума
• Protocol as type вместо generic — използване на Drawable вместо <T: Drawable> там, където е необходим конкретен тип
• Circular protocol reference — протокол, който се позовава на себе си чрез associated type, без коректно разрешаване
• Class-only protocol — използване на AnyObject без необходимост, което изключва struct и enum