SwiftUI — asosiy tushunchalar, View, State va Data Flow

SwiftUI nima?

SwiftUI — Apple ning UIKit dan tubdan farq qiladigan deklarativ UI frameworki. Kontrollerlar, ko'rinishlar yaratish va ularning hayot siklini qo'lda boshqarish o'rniga, dasturchi interfeysni deklaratsiyalar shaklida tavsiflaydi: ekranda nima bo'lishi kerak, uni qanday qurish emas. SwiftUI reaktivlik prinsipiga asoslanadi: interfeys holatning funksiyasidir. Holat (State) o'zgarganda SwiftUI avtomatik ravishda barcha bog'liq View larning body sini qayta hisoblaydi va faqat o'zgargan ekran qismlarini yangilaydi. SwiftUI iOS 13+, iPadOS 13+, macOS 10.15+, watchOS 6+, tvOS 13+ va visionOS 1+ da mavjud. SwiftUI kodi platformalararo: bir fayl minimal platforma moslashuvlari bilan iPhone, iPad, Mac va Apple Watch da ishlaydi. Apple WWDC Session 101 (2024) ma'lumotiga ko'ra, SwiftUI App Store ning standart UI namunalarining 90 foizdan ko'prog'ini qamrab oladi.

SwiftUI vs UIKit

UIKit — imperativ framework (2008): dasturchi UIViewController yaratadi, viewDidLoad da subviews ni konfiguratsiya qiladi, UITableView uchun delegate/datasource ni amalga oshiradi va ekranni reloadData yoki setNeedsLayout orqali yangilaydi. SwiftUI kontrollerlarni oddiy View strukturalari bilan, delegatlarni — binding va onChange bilan, Auto Layout ni — HStack/VStack/ZStack va modifierlar (padding, frame, offset) bilan almashtiradi. UIKit ARC orqali qo'lda xotira boshqaruvini talab qiladi; SwiftUI — referans hisoblashni talab qilmaydigan strukturalar. SwiftUI ning ishlash unumdorligi UIKit bilan solishtirish mumkin: framework minimal o'zgarishlar to'plami uchun diffing algoritmidan foydalanadi. IT Sectr da SwiftUI iOS 17+ maqsadli yangi loyihalar uchun ishlatiladi; iOS 14-15 qo'llab-quvvatlanadigan loyihalar SwiftUI ning cheklangan mosligi sababli UIKit ni talab qiladi.

SwiftUI ning deklarativ sintaksisi

SwiftUI da interfeys ViewBuilder orqali tasvirlanadi — View lar to'plamini tuple yoki Group ga aylantiruvchi result builder. Modifierlar (.padding(), .font(), .foregroundColor()) asl obyektni mutatsiya qilmasdan o'zgartirilgan sozlamalar bilan yangi View yaratadi. Har bir modifier yangi View qaytaradi, bu esa zanjirlash imkonini beradi. ViewBuilder if/else, switch, ForEach ni qo'llab-quvvatlaydi — shartli va sikl ko'rinishlarni alohida kontrollerlarsiz. SwiftUI da View value type (struct) dir, bu oldindan bashorat qilinadigan xatti-harakatni kafolatlaydi va race conditions larni bartaraf qiladi.

View protokoli va computed property body

View — yagona talabga ega protokol: some View tipidagi computed property body. View ga mos keladigan har bir struktur o'zining ekran qismini body da tasvirlaydi. Some View — qaytarilgan View ning aniq turini yashiradigan opaque return type (VStack, HStack, ZStack, Text, Image va hokazo kombinatsiyasi). Swift kompilyatori aniq turni kompilyatsiya bosqichida chiqaradi, turni o'chirmasdan to'g'ridan-to'g'ri chaqiruv unumdorligini saqlaydi.

import SwiftUI

struct GreetingView: View {
    var name: String
    
    var body: some View {
        VStack(spacing: 12) {
            Text("Salom, \(name)!")
                .font(.largeTitle)
                .foregroundColor(.primary)
            
            Text("SwiftUI ga xush kelibsiz")
                .font(.body)
                .foregroundColor(.secondary)
        }
        .padding()
        .background(
            RoundedRectangle(cornerRadius: 12)
                .fill(.ultraThinMaterial)
        )
    }
}

GreetingView strukturasi name parametrini qabul qiladi va vertikal stackda ikkita matn blokini ko'rsatadi. .font, .foregroundColor, .padding va .background modifierlari tashqi ko'rinishni konfiguratsiya qiladi. SwiftUI body ni kiritish parametrlari (name) har safar o'zgarganda chaqiradi — qayta chizish faqat o'zgargan qismlar uchun sodir bo'ladi. Misolda RoundedRectangle .ultraThinMaterial bilan ishlatilgan — SwiftUI ga o'rnatilgan mahalliy blur foni.

@State: SwiftUI da lokal holat

@State — bitta View ga tegishli lokal holatni e'lon qiladigan property wrapper. SwiftUI State xotirasini avtomatik boshqaradi: qiymat o'zgarganda body qayta chiziladi, lekin faqat ushbu State dan foydalanadigan View lar uchun. State oddiy turlar (String, Int, Bool, enum) uchun haqiqat manbai (source of truth) dir. Murakkab ma'lumot modellari uchun @State ni ishlatmang — ular uchun @StateObject va @ObservedObject mo'ljallangan. State private bo'lishi va View ning o'zida saqlanishi kerak, komponentlar o'rtasida uzatilmasligi kerak.

import SwiftUI

struct CounterView: View {
    @State private var count = 0
    
    var body: some View {
        VStack(spacing: 20) {
            Text("Sanoq: \(count)")
                .font(.system(size: 48, weight: .bold))
            
            Button(action: { count += 1 }) {
                Label("Oshirish", systemImage: "plus.circle")
            }
            .buttonStyle(.borderedProminent)
        }
        .padding()
    }
}

Boshlang'ich qiymat count = 0. Tugmaning har bir bosilishi count ni oshiradi; SwiftUI avtomatik ravishda CounterView ni to'liq (barcha View larni) qayta chizadi. UIKit da o'xshash stsenariy IBOutlet, IBAction va label.text ni qo'lda yangilashni talab qilgan bo'lardi. @State View faqat aniq State o'zgarganda qayta chizilishini kafolatlaydi — SwiftUI ning diffing algoritmi daraxtda minimal o'zgarishlarni topadi.

@Binding: View lar o'rtasida ikki tomonlama bog'lanish

@Binding — View va u boshqarmaydigan ma'lumotlar o'rtasida ikki tomonlama bog'lanish yaratadigan property wrapper. Binding State ga (yoki boshqa haqiqat manbai ga) havola bo'lib, bola View ga otada saqlangan qiymatni o'qish va o'zgartirish imkonini beradi. Binding $ prefiksi bilan belgilanadi: $count bola View ga Binding<Int> uzatadi. Binding bo'lmasa, bola View ota ma'lumotlarini o'zgartira olmaydi — faqat o'qiy oladi.

import SwiftUI

struct StepperControl: View {
    @Binding var value: Int
    let range: ClosedRange<Int>
    
    var body: some View {
        HStack {
            Button(action: { if value > range.lowerBound { value -= 1 } }) {
                Image(systemName: "minus.circle")
            }
            Text("\(value)")
                .frame(minWidth: 40)
            Button(action: { if value < range.upperBound { value += 1 } }) {
                Image(systemName: "plus.circle")
            }
        }
    }
}

struct ParentView: View {
    @State private var quantity = 5
    
    var body: some View {
        StepperControl(value: $quantity, range: 1...10)
    }
}

ParentView State quantity ga ega va Binding ni $quantity orqali uzatadi. StepperControl value ni o'zgartira oladi va otadagi quantity avtomatik sinxronlashadi. Binding ma'lumotlarning nusxasi emas, balki haqiqat manbai ga ko'prikdir. Otaning ma'lumotlarini o'zgartirishi kerak bo'lgan maxsus boshqaruvlar, muharrirlar va qayta foydalaniladigan komponentlar uchun @Binding dan foydalaning.

@ObservedObject va @StateObject: tashqi ma'lumot modellari

@StateObject — ObservableObject ga mos sinf namunasini yaratish va egalik qilish uchun property wrapper. View obyektni hayot siklida bir marta yaratadi va uning @Published xususiyatlari o'zgarganda qayta chiziladi. @ObservedObject — o'xshash wrapper, lekin View obyektga ega emas — obyekt View dan tashqarida yaratiladi va saqlanadi (initsializator orqali uzatiladi). Apple View iyerarxiyasida haqiqat manbai uchun @StateObject ni va bog'liqliklarni in'ektsiya qilish uchun @ObservedObject ni tavsiya qiladi.

import SwiftUI
import Combine

class UserSettings: ObservableObject {
    @Published var username: String = "Guest"
    @Published var isLoggedIn = false
}

struct ProfileView: View {
    @StateObject private var settings = UserSettings()
    
    var body: some View {
        VStack {
            TextField("Username", text: $settings.username)
                .textFieldStyle(.roundedBorder)
            
            Toggle("Logged In", isOn: $settings.isLoggedIn)
            
            if settings.isLoggedIn {
                Text("Xush kelibsiz, \(settings.username)!")
                    .font(.headline)
            }
        }
        .padding()
    }
}

UserSettings — ikkita @Published xususiyatiga ega ObservableObject. ProfileView @StateObject orqali obyektga egalik qiladi. username yoki isLoggedIn o'zgarishi ProfileView ni avtomatik qayta chizadi. @Published SwiftUI ga o'zgarishlar haqida xabar berish uchun Combine Publisher dan foydalanadi. Settings ni bola View larga uzatish uchun @ObservedObject dan foydalaning:

SwiftUI da Data Flow: to'liq rasm

Apple SwiftUI da to'rt darajali Data Flow ni belgilaydi: @State (lokal, value type), @Binding (ikki tomonlama), @StateObject/@ObservedObject (ObservableObject bilan reference type), @EnvironmentObject (global, muhit orqali in'ektsiya). EnvironmentObject ma'lumotlarni initsializatorda aniq uzatmasdan butun View iyerarxiyasi bo'ylab uzatish imkonini beradi. Qo'shimcha ravishda @AppStorage UserDefaults bilan, @SceneStorage — sahna holati bilan, @FetchRequest — Core Data bilan ishlaydi. Data Flow darajasini tanlash ilova arxitekturasini belgilaydi: oddiy ekranlar State/Binding, modulli — ObservedObject, keng ko'lamli — EnvironmentObject + Redux ga o'xshash yechimlar (TCA, Composable Architecture) dan foydalanadi.