Специфика на Swift в мобилната разработка: какво е, ключови възможности и как работи

Struct vs Class в Swift: типове стойности и референтни типове

В Swift, struct е тип стойност, докато class е референтен тип. Тази фундаментална разлика определя поведението при присвояване, предаване на функции и управление на паметта. Struct се копира изцяло при всяко присвояване, class се предава по референция — копира се само указателят към обекта в heap.

Семантика на стойността на Struct

Struct автоматично имплементира семантика на стойността — всеки екземпляр е независим. Мутация на свойство на struct е възможна само чрез var, а методите, които променят свойства, трябва да бъдат маркирани като mutating. Struct не поддържа наследяване, но може да се съобразява с протоколи. Стандартната библиотека на Swift използва struct за String, Array, Dictionary, Int, Bool — всички фундаментални типове са типове стойности.

struct User {
    let id: Int
    var name: String

    mutating func updateName(_ newName: String) {
        name = newName
    }
}

var user1 = User(id: 1, name: "Alice")
var user2 = user1
user2.updateName("Bob")
// user1.name === "Alice", user2.name === "Bob"
// Пълно копие — независими екземпляри

Референтна семантика на Class

Class се съхранява в heap и поддържа референтно равенство. Няколко променливи могат да реферират един и същ обект, промените чрез една референция се виждат чрез всички останали. Class поддържа наследяване, позволява override на методи (override), има deinit за почистване на ресурси. В Swift, class се използва по-рядко от struct — Apple препоръчва да започнете с struct и да преминете към class само когато са необходими наследяване или референтна семантика.

class Car {
    let model: String
    var speed: Int

    init(model: String, speed: Int) {
        self.model = model
        self.speed = speed
    }

    func accelerate(_ amount: Int) {
        speed += amount
    }
}

let car1 = Car(model: "Tesla", speed: 0)
let car2 = car1
car2.accelerate(50)
// car1.speed === 50, car2.speed === 50
// Същата референция — промените се виждат навсякъде

Изборът между struct и class зависи от семантиката на данните. За конфигурации, модели на данни и състояния използвайте struct — копирането е по-безопасно и предвидимо. За обекти с идентичност (потребителска сесия, връзка с база данни) и когато е необходимо наследяване, използвайте class.

Actor — нишкова безопасност в Swift

Actor е референтен тип, който защитава променливото си състояние от едновременен достъп. Компилаторът на Swift гарантира, че променливите на actor са достъпни само от същия actor контекст — всеки външен достъп причинява грешка при компилация. Това предотвратява състезания на данни на ниво език, без ръчни заключвания.

Изолация на Actor

Всички свойства и методи на actor са изолирани по подразбиране. Извикването на метод на actor отвън изисква await — Swift превключва изпълнението към actor и обратно. Actor синхронизира достъпа последователно: заявките от различни задачи се подреждат на опашка. Това гарантира консистентно състояние вътре в actor. Неизолираните методи (nonisolated) могат да се извикват без await, но нямат достъп до променливи свойства.

actor BankAccount {
    private var balance: Double

    init(initialBalance: Double) {
        balance = initialBalance
    }

    func deposit(amount: Double) {
        balance += amount
    }

    func withdraw(amount: Double) throws {
        guard balance >= amount else {
            throw BankError.insufficientFunds
        }
        balance -= amount
    }

    nonisolated func accountInfo() -> String {
        return "Банкова сметка"
    }
}

let account = BankAccount(initialBalance: 1000)
await account.deposit(amount: 500)
// balance = 1500 — атомарно, без състезателно условие

Actor е полезен за мениджъри на състояние, кешове и мрежови услуги, където множество задачи едновременно четат и пишат данни. За разлика от ръчната синхронизация чрез NSLock или DispatchQueue, actor се проверява по време на компилация — невъзможно е да се направи грешка. Грешките при изолация се появяват по време на компилация, а не по време на изпълнение.

Property Wrappers: @Published, @State, @Binding

Property Wrapper е анотация, която добавя поведение към свойство, без да променя декларацията му. SwiftUI и Combine предоставят вградени обвивки за управление на състоянието на изгледите. Компилаторът генерира код, който обвива достъпа до свойството, добавяйки логика за наблюдение, синхронизация или трансформация.

@Published и @State

@Published се използва в класове, съобразяващи се с ObservableObject, за автоматично публикуване на промени. Абонатите на Combine получават известия при всяка актуализация. @State е локалното състояние на изглед в SwiftUI. SwiftUI автоматично прерисува изгледа, когато @State се промени. @Binding създава двупосочна връзка между родителски и дъщерен изглед, без да притежава данните.

import SwiftUI
import Combine

@main
struct CounterApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

class CounterViewModel: ObservableObject {
    @Published var count: Int = 0

    func increment() {
        count += 1
    }
}

struct ContentView: View {
    @State private var greeting: String = "Здравей"
    @StateObject private var viewModel = CounterViewModel()

    var body: some View {
        VStack {
            CounterDisplay(count: $viewModel.count)
            Text(greeting)
            Button("Увеличи", action: viewModel.increment)
        }
    }
}

struct CounterDisplay: View {
    @Binding var count: Int

    var body: some View {
        Text("Брояч: \(count)")
    }
}

Персонализирани Property Wrappers се създават чрез @propertyWrapper и структура с поле wrappedValue. Това позволява повторно използване на логика: валидация, нормализация, съхранение в UserDefaults. Property Wrappers значително намаляват boilerplate кода и правят намерението на разработчика изрично чрез анотация.

@propertyWrapper
struct Clamped<T: Comparable> {
    private var value: T
    let range: ClosedRange<T>

    init(wrappedValue: T, range: ClosedRange<T>) {
        self.range = range
        self.value = min(max(wrappedValue, range.lowerBound), range.upperBound)
    }

    var wrappedValue: T {
        get { value }
        set { value = min(max(newValue, range.lowerBound), range.upperBound) }
    }
}

struct Settings {
    @Clamped(range: 0...100) var volume: Int = 50
}

var s = Settings()
s.volume = 150
// s.volume === 100 — стойността автоматично ограничена

Generics и Протоколно-ориентирано програмиране

Generics е мощен механизъм на Swift за писане на гъвкав код без загуба на типова безопасност. Общите функции и типове работят с всеки тип, който удовлетворява ограниченията. Протоколно-ориентираното програмиране (POP) е парадигма на Swift, при която protocol + extension заменят класическото наследяване на класове, осигурявайки композиция на поведение.

Общи ограничения и асоциирани типове

Swift позволява ограничаване на общи параметри с протоколи (where клаузи). Протокол с асоцииран тип е общият еквивалент за протоколи: конкретният тип се определя в момента на съобразяване. Това е основата за типобезопасни колекции и алгоритми. Стандартната библиотека на Swift активно използва Generics: Array, Dictionary, Optional — всички са общи типове.

protocol Cacheable {
    associatedtype Key: Hashable
    associatedtype Value

    func get(_ key: Key) -> Value?
    mutating func set(_ value: Value, for key: Key)
}

struct MemoryCache<K: Hashable, V>: Cacheable {
    private var storage: [K: V] = [:]

    typealias Key = K
    typealias Value = V

    func get(_ key: K) -> V? {
        return storage[key]
    }

    mutating func set(_ value: V, for key: K) {
        storage[key] = value
    }
}

func firstMatch<T: Equatable>(in array: [T], target: T) -> Int? {
    for (index, item) in array.enumerated() {
        if item == target {
            return index
        }
    }
    return nil
}

let numbers = [10, 20, 30, 40]
let index = firstMatch(in: numbers, target: 30)
// index === 2 — един общ метод за всички Equatable типове

Разширение на протокол и имплементации по подразбиране

Разширението на протокол е ключов механизъм на POP. В разширение може да се предостави имплементация по подразбиране на методите на протокола. Типовете, съобразяващи се с протокола, получават тази имплементация безплатно и могат да я override-нат при необходимост. Това позволява изграждане на йерархия на поведение без наследяване на класове — алтернатива на множественото наследяване, което не съществува в Swift.

protocol Drivable {
    var speed: Double { get set }
    func drive()
}

extension Drivable {
    func drive() {
        if speed > 0 {
            print("Шофиране с \(speed) км/ч")
        }
    }
}

struct Bicycle: Drivable {
    var speed: Double = 15
}

struct Plane: Drivable {
    var speed: Double = 900

    func drive() {
        print("Летене с \(speed) км/ч")
    }
}

let bike = Bicycle()
bike.drive() // "Шофиране с 15.0 км/ч" — по подразбиране

let plane = Plane()
plane.drive() // "Летене с 900.0 км/ч" — override

POP с разширение позволява композиция чрез множество протоколи — тип може да се съобразява с няколко протокола, получавайки техните имплементации. Това е по-гъвкаво от единичното наследяване на класове, където цялата йерархия е фиксирана. Стандартната библиотека на Swift е изградена върху POP: CustomStringConvertible, Equatable, Hashable, Codable — всички са протоколи с разширения.

Enum с асоциирани стойности и Extension

Enum в Swift е значително по-мощна конструкция, отколкото в други езици. Всеки случай може да има асоциирани стойности — произволен набор от данни от всякакъв тип. В комбинация с extension и съпоставяне на шаблони, enum става основа за моделиране на състояния, резултати от операции и крайни автомати.

Асоциирани стойности и съпоставяне на шаблони

Асоциираните стойности позволяват на всеки случай да съхранява уникални данни. Например, случаят loading не съдържа данни, success съдържа резултата, failure съдържа грешка. Съпоставянето на шаблони чрез switch извлича асоциираните стойности и обработва всеки случай. Компилаторът проверява изчерпателността (exhaustive switch) — това елиминира забравените състояния.

enum NetworkResult<T> {
    case loading
    case success(T)
    case failure(Error)
}

enum MediaFile {
    case image(url: URL, width: Int, height: Int)
    case video(url: URL, duration: Double)
    case audio(url: URL, bitrate: Int)
}

func handle(_ result: NetworkResult<String>) {
    switch result {
    case .loading:
        print("Зареждане...")
    case .success(let data):
        print("Получено: \(data)")
    case .failure(let error):
        print("Грешка: \(error.localizedDescription)")
    }
}

let file = MediaFile.video(url: URL(string: "https://example.com/video.mp4")!, duration: 120)

if case .video(let url, let duration) = file {
    print("Видео \(url) продължителност \(duration)с")
}

Extension за Enum

Swift позволява добавяне на методи, изчислявани свойства и съобразяване с протоколи чрез extension за enum. Това не изисква промяна на оригиналната декларация — кодът остава чист и модулен. Методите в extension могат да работят с асоциирани стойности, да изчисляват производни данни и да имплементират бизнес логика.

extension MediaFile {
    var fileName: String {
        switch self {
        case .image(let url, _, _),
             .video(let url, _),
             .audio(let url, _):
            return url.lastPathComponent
        }
    }

    var description: String {
        switch self {
        case .image(_, let w, let h):
            return "Изображение \(w)x\(h)"
        case .video(_, let d):
            return "Видео \(d)с"
        case .audio(_, let b):
            return "Аудио \(b) kbps"
        }
    }
}

extension MediaFile: Equatable {
    static func == (lhs: MediaFile, rhs: MediaFile) -> Bool {
        return lhs.fileName == rhs.fileName
    }
}

let files: [MediaFile] = [file]
files.forEach { print($0.description) }
// "Видео 120.0s"

Enum с асоциирани стойности + extension е заместител на запечатаните класове от Kotlin или дискриминираните обединения от други езици. Swift използва тази комбинация за Result (стандартен тип в стандартната библиотека), Optional (Optional е enum с .none и .some) и обработка на състояния в SwiftUI. Съпоставянето на шаблони гарантира, че всички състояния са обработени — грешките по време на изпълнение са невъзможни.