SwiftUI: какво е, ключови понятия и View Protocol

Какво е SwiftUI?

SwiftUI е декларативна рамка, представена от Apple през 2019 г. за замяна на UIKit в нови проекти. Вместо ръчно създаване на инстанции на UIView и добавянето им в йерархията, разработчикът описва интерфейса чрез структури, имплементиращи протокола View. SwiftUI автоматично изчислява разликата между текущото и новото състояние и прерисува само променените части, използвайки собствен механизъм за рендиране.

Рамката е написана на Swift, използвайки value semantics (структури, а не класове), което прави UI компонентите леки и нишково безопасни. За разлика от UIKit, където UIViewController може да тежи 200+ байта поради Objective-C runtime, SwiftUI View е просто структура с размер от няколко байта. Това е особено важно за watchOS с ограничената му памет.

Крос-платформеност на SwiftUI

Едно и също описание на View работи на iPhone, iPad, Mac, Apple Watch, Apple TV и Apple Vision Pro. SwiftUI адаптира интерфейса към платформата: на iOS — сензорни жестове, на macOS — клавишни комбинации, на watchOS — превъртане с Digital Crown. Това съкращава времето за разработка за компании, които пускат приложения на няколко платформи на Apple, но изисква допълнителна конфигурация за специфични елементи на всяка платформа.

View Protocol и тяло на изгледа

В SwiftUI всеки екран е структура, имплементираща протокола View с единствено изискване: изчисляемо свойство body от тип some View. Ключовата дума some (opaque type) скрива конкретния тип на изгледа, позволявайки на SwiftUI да оптимизира рендирането. Вътре в body разработчикът комбинира готови компоненти — Text, Image, Button, List — чрез ViewBuilder, който събира няколко изгледа в един.

struct GreetingView: View {
    let name: String

    var var body: some View {
        VStack {
            Text("Здравей, \(name)!")
                .font(.title)
                .foregroundColor(.blue)
            Image(systemName: "hand.wave")
                .imageScale(.large)
        }
        .padding()
    }
}

В примера VStack (вертикален стек) съдържа Text и Image. Стойността name се предава чрез инициализатора на структурата — така работи DI (Dependency Injection) в SwiftUI без външни DI контейнери. Всеки модификатор връща нов изглед с приложената промяна, без да мутира оригинала. Това е възможно благодарение на неизменяемостта (immutability) на value-типовете.

ViewBuilder и условни конструкции

ViewBuilder е result builder, анотиран с @resultBuilder, който събира до 10 изгледа в един. Вътре в body могат да се използват if/else, switch и ForEach без допълнителни обвивки. ForEach работи с Identifiable елементи — всеки изглед получава уникален id за коректна анимация при вмъкване/изтриване.

Управление на състоянието: @State, @Binding, @ObservedObject

В SwiftUI състоянието определя какво съдържание се показва на екрана. Когато състоянието се промени, SwiftUI пресъздава body на зависимия изглед и сравнява резултата с предишния, прилагайки diff алгоритъм. За съхранение на състоянието се използват property wrappers — всеки решава своята задача: локално състояние, връзка с дъщерен изглед или външен модел на данни.

struct CounterView: View {
    @State private var count = 0

    var var body: some View {
        VStack {
            Text("Брояч: \(count)")
            Button("Увеличи") {
                count += 1
            }
        }
    }
}

class UserViewModel: ObservableObject {
    @Published var name = ""
    @Published var age = 0
}

@State съхранява локална проста стойност (Int, String, Bool) вътре в структурата View. SwiftUI премества паметта от структурата в отделно хранилище — затова свойството с @State може да се променя (мутира), дори ако View е value-тип. @ObservableObject — за класове с @Published свойства, чиито промени автоматично уведомяват SwiftUI за необходимост от прерисуване.

@Binding и връзка родител-дете

@Binding създава двупосочна връзка с източника на данни, намиращ се в родителския изглед. Родителят предава $variable (projected value), детето чете и записва стойността чрез binding. Това позволява изнасяне на текстовия вход или превключвателя в отделен компонент, като състоянието се запазва в родителя. Без @Binding всяка промяна би изисквала callback затваряне за предаване на новата стойност нагоре.

Навигация в SwiftUI: NavigationStack и NavigationLink

Преди iOS 16 навигацията в SwiftUI се основаваше на NavigationView — остаряло API със сложно поведение на iPad (split view, double column). От iOS 16 нататък Apple препоръчва NavigationStack — опростена алтернатива с тип-безопасни маршрути. Разработчикът дефинира enum от възможни маршрути, а NavigationStack автоматично управлява стека от екрани с поддръжка на дълбоки връзки и връщане към корена.

enum Route: Hashable {
    case detail(id: Int)
    case settings
}

struct ContentView: View {
    var var body: some View {
        NavigationStack {
            List {
                NavigationLink("Екран с детайли",
                               value: Route.detail(id: 42))
                NavigationLink("Настройки",
                               value: Route.settings)
            }
            .navigationDestination(for: Route.self) { route in
                switch route {
                case .detail(let id): DetailView(id: id)
                case .settings: SettingsView()
                }
            }
        }
    }
}

Маршрутите от тип Route: Hashable позволяват използването на всякакъв тип данни за предаване на параметри. navigationDestination(for:destination:) свързва типа на маршрута с целевия изглед. Предимство пред UIKit навигацията — не се изисква прерисуване при добавяне на нов маршрут: достатъчно е да се добави case в enum и handler в switch. Дълбоките връзки се обработват чрез processDeepLink на NavigationStack.

Програмна навигация

За програмен преход (след вход, таймер или отговор от сървър) се използва @State с инициализатор на NavigationLink: NavigationLink(isActive: $isActive). При задаване на isActive = true преходът се извършва без докосване от потребителя. Алтернатива — binding на масив $path в NavigationStack: $path.append(Route.detail(id: 1)).

View Modifier — конфигуриране на външен вид

Modifier е метод, който връща модифицирано копие на изгледа. За разлика от UIKit, където конфигурирането на свойства става чрез мутация на съществуващия изглед, SwiftUI създава нова стойност с приложената промяна. Веригата от модификатори (chaining) изгражда крайния интерфейс от последователни трансформации: шрифт → разстояние → цвят → сянка → жест.

Apple предоставя над 200 вградени модификатора. Най-честите са: .font(), .foregroundColor(), .padding(), .background(), .cornerRadius(), .shadow(), .opacity(), .offset(). Редът на модификаторите е важен: .padding() преди .background() оцветява областта с разстояние, след — само вътрешната област. Потребителски модификатори се създават чрез протокола ViewModifier.

Условни модификатори и анимация

Модификаторите могат да се прилагат условно чрез тернарния оператор: .foregroundColor(isError ? .red : .primary). За анимация се използва .animation(.easeInOut, value: state) — модификаторът за анимация се свързва с конкретно свойство на състоянието. При промяна на това свойство SwiftUI анимира прехода между старата и новата стойност. Анимацията работи с opacity, offset, scale, rotation, размер и цвят — за всяко свойство е дефиниран съответен AnimatableParameter.

За потребителски анимации са достъпни .transition (появяване/изчезване) и .matchedGeometryEffect (плавен преход на елемент между два контейнера). Последният се използва за hero-анимация в списъци: икона в клетка на списък плавно се превръща в голямо изображение на екрана с детайли.

SwiftUI vs UIKit: сравнение на подходите

Изборът между SwiftUI и UIKit е една от първите дилеми на iOS разработчика. И двете рамки се поддържат от Apple, но решават задачата за изграждане на интерфейс по коренно различни начини: SwiftUI декларативно, UIKit императивно. Разликата се проявява в управлението на състоянието, навигацията, производителността и съвместимостта.

За нови проекти с минимална версия iOS 17 Apple препоръчва SwiftUI като основна рамка. UIKit остава необходим за интерфейси, изискващи фин контрол върху рендирането (потребителски UICollectionViewLayout, сложни CAAnimation сцени) или поддръжка на iOS 12–14. Много проекти използват хибриден подход: SwiftUI чрез UIHostingController се вгражда в UIKit приложение, а UIViewRepresentable позволява използването на UIKit компоненти в SwiftUI йерархията.