.onAppear: ishlash prinsipi, hayot sikli va SwiftUI da misollar

.onAppear nima?

.onAppear — SwiftUI da View modifikatori bo'lib, Void yopilishini qabul qiladi va View ekranda ko'rinadigan bo'lganda uni bajaradi. Bu modifikator .onDisappear va .task bilan birga SwiftUI komponentlarining hayot sikl tizimining bir qismidir. Apple onAppear ni SwiftUI bilan birga iOS 13 va watchOS 6 da UIKit dagi viewDidLoad o'rnini bosuvchi sifatida taqdim etdi.

.onAppear har qanday View ni modifikatsiya qiladi va biriktirilgan harakat bilan bir xil View ni qaytaradi. SwiftUI kompilyatori uzatilgan yopilishni bir marta, ko'rinish ierarxiyaga qo'shilganda va render bosqichidan o'tganda chaqiradi. Agar View o'chirilsa va keyin yana qo'shilsa (masalan, ro'yxatda aylantirishda), onAppear qayta chaqiriladi — bu xatti-harakat ko'pincha kutilmagan bug'larning manbaiga aylanadi.

onAppear sintaksisi

Asosiy sintaksis modifikator minimaldir: parametrsiz onAppear. SwiftUI da prioritet yoki animatsiyani uzatish imkoniyati yo'q — yopilish renderdan so'ng darhol asosiy oqimda sinxron bajariladi.

struct ContentView: View {
    var body: some View {
        Text("Salom, SwiftUI!")
            .onAppear {
                print("View ekranda paydo bo'ldi")
            }
    }
}

Cheklovlar: onAppear to'g'ridan-to'g'ri async/await ni qo'llab-quvvatlamaydi. Yopilish ichidagi asinxron operatsiyalar uchun Task {} yoki Task.detached orqali chaqiriladigan alohida async/await funksiyasi kerak. Bu onAppear ni .task modifikatoriga nisbatan tarmoq so'rovlari uchun kamroq qulay qiladi.

.onAppear View hayot siklida qanday ishlaydi

.onAppear SwiftUI render quvuriga layout+render bosqichida ulanadi. SwiftUI View tanasini hisoblab, ierarxiya o'zgarishini aniqlaganda, barcha yangi qo'shilgan ko'rinishlar uchun onAppear callbacklarini ishga tushiradi. Chaqiruv tartibi joylashish tartibiga mos keladi: avval ota-onada onAppear, keyin bola elementlarda.

SwiftUI ning muhim xususiyati — onAppear fizik ekranda paydo bo'lish bilan bog'liq emas. Modifikator View ierarxiyaga qo'shilganda chaqiriladi, foydalanuvchiga ko'rinadigan bo'lishidan qat'iy nazar (masalan, ScrollView da ekrandan tashqarida). Bu SwiftUI ni UIKit dan farqlaydi, bu yerda viewWillAppear faqat haqiqiy paydo bo'lganda ishlaydi.

onAppear chaqiruv tartibi

Chaqiruv tartibi parent-first qoidasiga bo'ysunadi: VStack yoki NavigationView avval onAppear oladi, keyin har bir bola element navbat bilan. Bu umumiy resurslarni ishga tushirish uchun muhim: agar bola elementlar ota-ona tomonidan yuklanadigan ma'lumotlarga bog'liq bo'lsa, ular mavjudlikni Optional orqali tekshirishlari kerak.

struct ParentView: View {
    var body: some View {
        VStack {
            ChildView()
            ChildView()
        }
        .onAppear {
            print("Parent onAppear — birinchi")
        }
    }
}

struct ChildView: View {
    var body: some View {
        Text("Bola")
            .onAppear {
                print("Child onAppear")
            }
    }
}

Konsol chiqishi quyidagicha bo'ladi: Parent onAppear — birinchi, so'ngra ikki marta Child onAppear joylashish tartibida. Bu xatti-harakat Apple tomonidan kafolatlangan va SwiftUI ning barcha versiyalarida (iOS 13–18) barqarordir.

.onAppear qachon chaqiriladi

.onAppear bir nechta chaqiruv stsenariylariga ega, ular konteyner va navigatsiyaga bog'liq. NavigationStack da onAppear har bir yangi kontroller pushida va pop da — ildiz kontrolleri uchun ishlaydi. TabView da varaq almashtirish ko'rsatilgan varaq uchun onAppear va yashirin varaq uchun onDisappear ni chaqiradi.

List va ScrollView da onAppear ko'rinish maydoniga tushgan yoki oldindan render buferidagi hujayralar uchun chaqiriladi. iOS 18 prefetch mexanizmini taqdim etdi, u aylantirishdan 2–3 ekran oldin hujayralar uchun onAppear ni chaqirishi mumkin — bu idrokni tezlashtiradi, ammo keraksiz tarmoq so'rovlariga sabab bo'lishi mumkin.

NavigationStack da chaqiruv xususiyatlari

NavigationStack (iOS 16+) ekranlar to'plamini NavigationView dan farqli boshqaradi. Yangi ekran push qilinganda onAppear faqat yangi ekranda ishlaydi, joriy ekran esa haqiqiy o'chirilgunga qadar onDisappear olmaydi. Pop da teskari jarayon sodir bo'ladi: tark etilgan ekranda onDisappear, qaytarilgan ekranda onAppear.

.onAppear dan foydalanish misollari

Amaliy qo'llanish onAppear uch asosiy kategoriyani qamrab oladi: ma'lumot yuklash, animatsiyalarni ishga tushirish va analitika jo'natish. Har bir stsenariy SwiftUI hayot sikli xususiyatlarini hisobga olishni talab qiladi, takrorlanuvchi chaqiruvlar va xotira oqishlarining oldini olish uchun.

API dan ma'lumot yuklash

Ma'lumot yuklash — onAppear ning eng keng tarqalgan stsenariysi. Yopilish ichida async chaqiruv uchun Task yaratiladi va natija @State yoki @StateObject da saqlanadi. Ma'lumotlarning qayta yuklanmasligini tekshirish muhim, isLoading flagi yoki nil tekshiruvi yordamida.

struct ProfileView: View {
    @StateObject private var viewModel = ProfileViewModel()
    
    var body: some View {
        VStack {
            if viewModel.isLoading {
                ProgressView()
            } else {
                Text(viewModel.userName)
            }
        }
        .onAppear {
            guard viewModel.userName == nil else { return }
            Task {
                await viewModel.loadProfile()
            }
        }
    }
}

Guard against re-fetch — muhim amaliyot. Agar SwiftUI View ni qayta yaratsa (masalan, ekran aylantirilganda), onAppear guardsiz qayta chaqiriladi. Alternativ — avvalgi so'rovni avtomatik bekor qiladigan .task modifikatori.

Kirish animatsiyasini ishga tushirish

Kirish animatsiyasi withAnimation yoki animation modifikatori orqali animatsiyani tetiklovchi state o'zgaruvchilarini o'zgartirish uchun onAppear dan foydalanadi. Oddiy namuna: boshlang'ich holat (opacity 0, offset 100), paydo bo'lganda yakuniy holatga (opacity 1, offset 0) o'tish.

struct AnimatedCard: View {
    @State private var isVisible = false
    
    var body: some View {
        RoundedRectangle(cornerRadius: 12)
            .fill(Color.blue)
            .opacity(isVisible ? 1 : 0)
            .offset(y: isVisible ? 0 : 50)
            .animation(.spring(), value: isVisible)
            .onAppear {
                withAnimation(.spring().delay(0.3)) {
                    isVisible = true
                }
            }
    }
}

Kechikish 0.3 soniya ekranda bir nechta bunday kartochkalar bo'lsa, ketma-ket paydo bo'lish effektini yaratadi. Animatsiyalangan elementlar ro'yxati uchun element indeksini kechikish multiplikatori sifatida ishlating.

.onAppear vs .task — farqi nimada

.task — iOS 15 da qo'shilgan SwiftUI modifikatori bo'lib, onAppear dagi asinxron operatsiyalar muammosini hal qiladi. onAppear dan farqli o'laroq, .task async yopilishini qabul qiladi, uning hayot siklini avtomatik boshqaradi va View yo'qolganda uni bekor qiladi. onAppear sinxron bajariladi, .task esa asinxron operatsiyani boshlaydi va SwiftUI ga onDisappear da uni bekor qilish imkonini beradi.

Asosiy farq — bekor qilishni boshqarish. .task async operatsiyani yaratganda, SwiftUI Task ga havolani saqlaydi va View ierarxiyadan o'chirilganda avtomatik cancel() ni chaqiradi. Ichida Task {} bo'lgan onAppear boshlangan operatsiyani bekor qilmaydi — u View yo'qolganidan keyin ham bajarilishda davom etadi, bu esa poyga holatiga yoki allaqachon bo'shatilgan nusxaga yozishga sabab bo'lishi mumkin.

Modifikatorni tanlash: sinxron harakatlar (animatsiyalar, analitika, loglar) uchun onAppear dan foydalaning. Asinxron ma'lumot yuklash (API, Core Data, fayl tizimi) uchun .task afzal — xavfsizroq va tozaroq.

.onAppear bilan odatiy xatolar

Xato 1: View ning qayta yaratilishi tufayli ko'p marta chaqirish. SwiftUI View tanasini qayta yaratganda (@State o'zgarishi, ekran aylantirilishi), onAppear qayta chaqirilishi mumkin. Yechim — yuklash flagi qo'shish yoki keraksiz qayta chizishlarning oldini olish uchun .equatable() dan foydalanish. SwiftLee (2025) ma'lumotlariga ko'ra, ishlab chiqarishdagi SwiftUI bug'larining 40% i aynan onAppear ning takroriy chaqiruvlari bilan bog'liq.

Xato 2: Kuchli havola orqali xotira oqishi. Agar onAppear yopilishi self ni zaif havolasiz tutsa, View bilan retain cycle hosil bo'ladi. SwiftUI View yo'qolganda tutilgan ob'ektlarning nolga tushirilishini kafolatlamaydi. ViewModel yoki xizmatlar uchun capture list [weak self] dan foydalaning.

Xato 3: Fon oqimida bajarish. onAppear asosiy oqimda bajariladi — bu UI operatsiyalari uchun to'g'ri. Ammo onAppear ichida Task ishga tushirilsa, @State yangilanishi MainActor.run orqali amalga oshishiga ishonch hosil qiling. Swift 5.9 va undan yuqori versiyalar avtomatik ravishda MainActor ga qaytadi, lekin @MainActor ni ochiq ko'rsatish yaxshiroq.

Takroriy chaqiruvlardan qanday qochish kerak

Namuna yuklash flagi bilan takrorlashdan himoyalanishning eng ishonchli usulidir. Flag ni @State yoki @StateObject da saqlang va uni faqat qo'lda yangilashda nolga tushiring. Alternativ — onAppear o'rniga .task dan foydalanish: .task odatiy bo'yicha qayta chizishda qayta boshlanmaydi, agar async operatsiya allaqachon bajarilayotgan bo'lsa.

struct SafeView: View {
    @State private var hasAppeared = false
    @State private var items: [Item] = []
    
    var body: some View {
        List(items, id: \.id) { item in
            Text(item.name)
        }
        .onAppear {
            guard !hasAppeared else { return }
            hasAppeared = true
            Task {
                items = await DataService.shared.fetchItems()
            }
        }
    }
}