View Protocol — asosiy tushunchalar, SwiftUI-dagi View protokoli

SwiftUI-da View Protocol nima?

View Protocol — SwiftUI-ning markaziy protokoli bo'lib, har bir vizual element o'z mazmunini qanday tasvirlashini belgilaydi. UIKit-dan farqli o'laroq, unda har bir element sinflar orqali UIView-dan meros oladi, SwiftUI protokolga yo'naltirilgan yondashuvdan foydalanadi: View protokoliga mos keladigan har qanday tur ekranda ko'rsatilishi mumkin.

View protokoli faqat bitta hisoblanuvchi body xususiyatini amalga oshirishni talab qiladi. Biroq, bu soddalik ortida kuchli kompozitsiya tizimi yashiringan: body View-ga mos keladigan har qanday turni, jumladan primitivlarni (Text, Image, Button), konteynerlarni (VStack, HStack, ZStack) va maxsus murakkab komponentlarni qaytarishi mumkin.

WWDC 2023 ma'lumotlariga ko'ra, SwiftUI ilovalaridagi barcha ekranlarning 95% dan ortig'i View protokolini amalga oshiradigan tuzilmalar kompozitsiyasi orqali quriladi. Bu View Protocol-ni butun SwiftUI arxitekturasining poydevoriga aylantiradi.

Value type vs reference type

SwiftUI View value type (struktura, struct) bo'lishini talab qiladi, sinf emas. Bu asosiy arxitektura qaroridir: value types bashorat qilinadigan hayot davriga ega, umumiy o'zgaruvchan holatga ega emas va SwiftUI-ga ierarxiyaning qaysi qismlari o'zgarganini va qayta chizishni talab qilishini samarali aniqlashga imkon beradi.

Agar View-ni sinf qilishga harakat qilsangiz, kompilyator xato beradi: View protokoli value semantics talab qiladigan DynamicViewProperty protokolidan meros oladi. Sinflar View-ga mos kelishi mumkin, ammo bu idiomatik yondashuvni buzadi va avtomatik yangilanish afzalliklaridan mahrum qiladi.

body: View protokolining hisoblanuvchi xususiyati

body — View protokolining yagona majburiy talabi. Bu ekranda ko'rsatiladigan kontentni qaytaradigan hisoblanuvchi xususiyatdir. Qaytarilgan qiymat turi — some View, ya'ni "kompilyator tomonidan aniqlanadigan View-ga mos keladigan ma'lum tur".

struct GreetingView: View {
    var name: String

    var body: some View {
        VStack {
            Text("Salom, \(name)!")
                .font(.title)
                .foregroundColor(.blue)
            Button("Boshlash") {
                print("Tugma bosildi")
            }
        }
    }
}

body qanday ishlaydi: SwiftUI ilova holati o'zgarganda va qayta chizish talab qilinganda body-ni chaqiradi. Framework yangi View daraxtini eskisi bilan solishtiradi va faqat kerakli o'zgarishlarni qo'llaydi (diffing). Bu to'liq deklarativ yondashuvdir — siz nima ko'rsatilishi kerakligini tasvirlaysiz, SwiftUI esa buni qanday amalga oshirish haqida qayg'uradi.

Muhim tafsilot: body yon ta'sirlarga ega bo'lmasligi kerak. U ilova hayoti davomida ko'p marta chaqiriladi va agar body ichida tashqi holat o'zgarsa — bu bashorat qilib bo'lmaydigan xatti-harakatga olib keladi. Yon ta'sirlar uchun task, onChange yoki DispatchQueue dan foydalaning.

Elementlar soni cheklovi

SwiftUI cheklov qo'yadi: body faqat bitta ildiz elementini qaytarishi mumkin. Agar bir darajada bir nechta elementni ko'rsatish kerak bo'lsa, ularni konteynerga — VStack, HStack, ZStack yoki Group-ga o'rang. @ViewBuilder paydo bo'lishi bilan bu cheklov kamroq sezilarli bo'ldi, ammo kontseptual jihatdan body har doim bitta View qaytaradi.

some View: protokoldagi shaffof bo'lmagan tur

some View — Swift 5.1 da maxsus SwiftUI uchun kiritilgan shaffof bo'lmagan tur (opaque type) sintaksisi. Bu funksiya yoki xususiyat View protokoliga mos keladigan aniq turni qaytarishini anglatadi, ammo chaqiruvchi kod qaysi aniq tur qaytarilganini bilmaydi va bilmasligi kerak.

Swift kompilyatori har bir body amalga oshirilishi uchun kompilyatsiya bosqichida aniq turni belgilaydi, lekin uni tashqi dunyodan yashiradi. Bu SwiftUI-ga barcha komponentlarning aniq turlarini bilgan holda View ierarxiyasini optimallashtirishga imkon beradi, ammo dasturchiga imzoni o'zgartirmasdan amalga oshirishni o'zgartirish moslashuvchanligini beradi.

struct ContentView: View {
    var body: some View {
        Text("Salom, Dunyo!") // Kompilyator bu Text ekanligini biladi
    }
}

Nega some View, shunchaki View emas? Agar body shunchaki View (protokol sifatida) qaytarsa edi, SwiftUI kompilyatsiya vaqtida aniq turni aniqlay olmas edi. Bu ekzistensial konteynerga (existential container) o'rash uchun qo'shimcha yukga olib keladi. some View optimallashtirish uchun kompilyatorga yetarli ma'lumot beradi, protokolning moslashuvchanligini saqlaydi.

some View cheklovlari

Asosiy cheklov — body bir xil turni qaytarishi kerak. Maxsus o'ramlar (AnyView, Group yoki @ViewBuilder) holda shartning bir tarmog'ida Text va boshqasida Image qaytarib bo'lmaydi. Kompilyator buni kompilyatsiya bosqichida tekshiradi: barcha mumkin bo'lgan qaytarish yo'llari bir xil turga ega bo'lishi kerak.

Ushbu cheklovni chetlab o'tish uchun @ViewBuilder (yagona TupleView turini yaratadi), Group (ham yagona turni qaytaradi) yoki AnyView (turni o'chiradi, ammo yuk qo'shadi) ishlatiladi. AnyView faqat boshqa variantlar mumkin bo'lmaganda ishlatilishi kerak, chunki u SwiftUI optimallashtirishlarini o'chiradi.

@ViewBuilder: bir nechta View-larni yig'ish

@ViewBuilder — bir nechta View-larni ichma-ich konteynerlarsiz bitta kompozitsiyaga yig'ish imkonini beradigan result builder annotatsiyasidir. @ViewBuilder avtomatik ravishda bir nechta ifodalarni kortejga (TupleView) o'raydi yoki to'g'ri qaytarish turi bilan shartli mantiqni (If / else / switch) qo'llaydi.

struct DashboardView: View {
    var isLoggedIn: Bool

    @ViewBuilder
    var body: some View {
        if isLoggedIn {
            Text("Xush kelibsiz!")
                .font(.largeTitle)
            ProfileCard()
        } else {
            LoginButton()
                .padding()
        }
    }
}

@ViewBuilder qanday ishlaydi: kompilyator @ViewBuilder ichidagi har bir kod blokini buildBlock, buildEither, buildOptional va h.k. statik metod chaqiruvlariga aylantiradi. Agar blok bir nechta ifodani o'z ichiga olsa — ular TupleView-ga o'raladi. Agar blok shartli mantiqni o'z ichiga olsa — kompilyator tarmoq turini yashiradigan ConditionalContent yaratadi.

@ViewBuilder cheklov qo'yadi: bitta blokda 10 tagacha element (TupleView cheklovi). Agar o'ndan ortiq elementni yig'ish kerak bo'lsa, Group, ForEach dan foydalaning yoki pastki komponentlarga bo'ling. Bu cheklov Swift har bir arity uchun 1 dan 10 gacha buildBlock-ning alohida overloadini yaratishi sababli mavjud.

View kompozitsiyasi va modifikatorlar

Kompozitsiya — SwiftUI-ning asosiy printsipi: murakkab interfeyslar kichik, qayta ishlatiladigan View komponentlaridan quriladi. Har bir komponent View protokolini amalga oshiradi va ekranning o'z qismi uchun javobgardir. Modifikatorlar (font, padding, foregroundColor) View-ga qo'llaniladi va o'zgartirilgan sozlamalar bilan yangi View qaytaradi.

SwiftUI-dagi modifikatorlar mutatsiya emas, balki asl View atrofida yangi o'ram yaratishdir. Har bir modifikator yangi turni (ModifiedContent) qaytaradi, bu SwiftUI-ga modifikatorlar daraxtini qurish va faqat o'zgargan qismlarni samarali qayta chizish imkonini beradi. Modifikatorlarni qo'llash tartibi muhim: turli tartiblar turli vizual natijalar beradi.

Text("Salom, SwiftUI!")
    .font(.title)        // ModifiedContent
    .padding()           // ModifiedContent<..., PaddingModifier>
    .background(.yellow) // ModifiedContent<..., BackgroundModifier>
    .cornerRadius(8)    // ModifiedContent<..., CornerRadiusModifier>

Ishlash samaradorligini optimallashtirish: SwiftUI aniq View qiymatlarini emas, balki ularning identifikatorini identity mexanizmi (id, ForEach, strukturalarning barqaror identifikatori) orqali solishtiradi. Agar View strukturasi o'zgarmagan bo'lsa — body chaqirilmaydi. Bunga Equatable taqqoslash va ierarxiya bo'ylab ma'lumotlarni yuqoriga uzatish uchun PreferenceKey mexanizmi orqali erishiladi.

Samarali kompozitsiya uchun murakkab ekranlarni mustaqil pastki komponentlarga bo'lish tavsiya etiladi, har biri o'z minimal holati bilan. Bu SwiftUI-ga butun ekran emas, balki faqat ierarxiyaning o'zgargan qismlarini qayta chizish imkonini beradi.