.onAppear: کام کرنے کا اصول، لائف سائیکل اور SwiftUI میں مثالیں

.onAppear کیا ہے؟

.onAppear SwiftUI میں ایک View موڈیفائر ہے جو Void کلوزر لیتا ہے اور اسے اس وقت انجام دیتا ہے جب View اسکرین پر نظر آنے لگتی ہے۔ یہ موڈیفائر .onDisappear اور .task کے ساتھ SwiftUI اجزاء کے لائف سائیکل سسٹم کا حصہ ہے۔ Apple نے onAppear کو UIKit کے viewDidLoad کے متبادل کے طور پر SwiftUI کے iOS 13 اور watchOS 6 کے اجراء کے ساتھ متعارف کرایا۔

نحوی طور پر، .onAppear کسی بھی View کو تبدیل کرتا ہے اور منسلک کارروائی کے ساتھ وہی View لوٹاتا ہے۔ SwiftUI کمپوزر منتقل کردہ کلوزر کو ایک بار کال کرتا ہے جب View درجہ بندی میں شامل ہوتی ہے اور رینڈرنگ مرحلہ عبور کرتی ہے۔ اگر View کو ہٹا دیا جائے اور دوبارہ شامل کیا جائے (مثال کے طور پر، فہرست میں اسکرول کرتے ہوئے)، onAppear دوبارہ کال ہوتا ہے — یہ رویہ اکثر غیر متوقع کیڑے کا ذریعہ بن جاتا ہے۔

onAppear نحو

موڈیفائر کا بنیادی نحو کم سے کم ہے: پیرامیٹرز کے بغیر onAppear۔ SwiftUI میں ترجیح یا اینیمیشن پاس کرنے کا کوئی طریقہ نہیں ہے — کلوزر رینڈرنگ کے فوراً بعد مرکزی دھاگے میں ہم وقت سازی سے انجام پاتا ہے۔

struct ContentView: View {
    var body: some View {
        Text("Hello, SwiftUI!")
            .onAppear {
                print("View appeared on screen")
            }
    }
}

حدود: onAppear براہ راست async/await کو سپورٹ نہیں کرتا۔ کلوزر کے اندر غیر ہم وقت ساز کارروائیوں کے لیے Task {} یا Task.detached کے ذریعے کال کی گئی علیحدہ async/await فنکشن کی ضرورت ہے۔ یہ onAppear کو .task موڈیفائر کے مقابلے میں نیٹ ورک کی درخواستوں کے لیے کم آسان بناتا ہے۔

.onAppear View لائف سائیکل میں کیسے کام کرتا ہے

.onAppear layout+render مرحلے میں SwiftUI رینڈرنگ پائپ لائن میں شامل ہے۔ جب SwiftUI View باڈی کا حساب لگاتا ہے اور درجہ بندی میں تبدیلی کا پتہ لگاتا ہے، تو یہ نئی شامل کردہ تمام Views کے لیے onAppear کال بیک چلاتا ہے۔ کال ترتیب نیسٹنگ کی پیروی کرتی ہے: پہلے والدین کا onAppear، پھر بچوں کے عناصر۔

SwiftUI کی ایک اہم خصوصیت یہ ہے کہ onAppear جسمانی اسکرین پر ظاہر ہونے سے منسلک نہیں ہے۔ موڈیفائر اس وقت کال ہوتا ہے جب View درجہ بندی میں شامل کی جاتی ہے خواہ وہ صارف کو نظر آئے یا نہ (مثال کے طور پر، ScrollView میں اسکرین سے باہر)۔ یہ SwiftUI کو UIKit سے ممتاز کرتا ہے، جہاں viewWillAppear صرف حقیقی ظاہر ہونے پر چلتا ہے۔

onAppear کال ترتیب

کال ترتیب والدین-پہلے اصول کی پیروی کرتی ہے: VStack یا NavigationView پہلے onAppear وصول کرتا ہے، پھر ترتیب میں ہر بچہ عنصر۔ یہ مشترکہ وسائل کی ابتدا کے لیے اہم ہے: اگر بچے عناصر والدین کے لوڈ کردہ ڈیٹا پر منحصر ہیں، تو انہیں Optional کے ذریعے دستیابی چیک کرنی چاہیے۔

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

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

کنسول آؤٹ پٹ ہوگا: Parent onAppear — پہلے، پھر ترتیب میں دو بار Child onAppear۔ یہ رویہ Apple کی طرف سے ضمانت شدہ ہے اور SwiftUI کے تمام ورژنز (iOS 13–18) میں مستحکم ہے۔

.onAppear کب کال ہوتا ہے

.onAppear کے کئی کال منظرنامے ہیں جو کنٹینر اور نیویگیشن پر منحصر ہیں۔ NavigationStack میں، onAppear نئے کنٹرولر کے ہر push پر اور pop پر — روٹ کنٹرولر کے لیے چلتا ہے۔ TabView میں، ٹیب تبدیل کرنا ظاہر کردہ ٹیب کے لیے onAppear اور پوشیدہ ٹیب کے لیے onDisappear کال کرتا ہے۔

List اور ScrollView میں، onAppear ان سیلز کے لیے کال ہوتا ہے جو نظر آنے والے علاقے میں داخل ہوئے ہیں یا پہلے سے رینڈر بفر میں ہیں۔ iOS 18 نے ایک prefetch میکانزم متعارف کرایا ہے جو اسکرول سے 2–3 اسکرین پہلے سیلز کے لیے onAppear کال کر سکتا ہے — یہ ادراک کو تیز کرتا ہے لیکن غیر ضروری نیٹ ورک درخواستیں شروع کر سکتا ہے۔

NavigationStack میں کال رویہ

NavigationStack (iOS 16+) اسکرین اسٹیک کو NavigationView سے مختلف طریقے سے منظم کرتا ہے۔ نئی اسکرین push کرتے وقت، onAppear صرف نئی اسکرین پر چلتا ہے، جبکہ موجودہ اسکرین حقیقی ہٹانے تک onDisappear وصول نہیں کرتی۔ pop پر، الٹ عمل ہوتا ہے: چھوڑی جانے والی اسکرین پر onDisappear، واپس آنے والی اسکرین پر onAppear۔

.onAppear استعمال کی مثالیں

عملی اطلاقات onAppear کی تین اہم اقسام پر محیط ہیں: ڈیٹا لوڈنگ، اینیمیشن شروع کرنا اور تجزیات بھیجنا۔ ہر منظرنامے میں ڈپلیکیٹ کالز اور میموری لیک سے بچنے کے لیے SwiftUI لائف سائیکل خصوصیات پر غور کرنے کی ضرورت ہے۔

API سے ڈیٹا لوڈ کرنا

ڈیٹا لوڈ کرنا onAppear کا سب سے عام استعمال ہے۔ کلوزر کے اندر، async کال کے لیے ایک Task بنایا جاتا ہے اور نتیجہ @State یا @StateObject میں محفوظ کیا جاتا ہے۔ یہ چیک کرنا ضروری ہے کہ ڈیٹا پہلے لوڈ ہو چکا ہے یا نہیں isLoading پرچم یا nil چیک کا استعمال کرتے ہوئے۔

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()
            }
        }
    }
}

دوبارہ fetch سے تحفظ ایک اہم عمل ہے۔ اگر SwiftUI View کو دوبارہ بناتا ہے (مثال کے طور پر، اسکرین گھومنے پر)، onAppear تحفظ کے بغیر دوبارہ چلے گا۔ ایک متبادل .task موڈیفائر ہے، جو خود بخود پچھلی درخواست کو منسوخ کرتا ہے۔

انٹری اینیمیشن شروع کرنا

انٹری اینیمیشن withAnimation یا animation موڈیفائر کے ذریعے اینیمیشن کو متحرک کرنے والے اسٹیٹ متغیرات کو تبدیل کرنے کے لیے onAppear کا استعمال کرتی ہے۔ عام نمونہ: ابتدائی حالت (opacity 0، offset 100)، ظاہر ہونے پر آخری حالت (opacity 1، offset 0) میں منتقلی۔

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
                }
            }
    }
}

0.3 سیکنڈ کی تاخیر ایک ترتیب وار ظاہر ہونے کا اثر پیدا کرتی ہے اگر اسکرین پر متعدد کارڈز ہوں۔ اینیمیٹڈ عناصر کی فہرست کے لیے، عنصر انڈیکس کو تاخیر کے ضارب کے طور پر استعمال کریں۔

.onAppear بمقابلہ .task — فرق

.task iOS 15 میں شامل کردہ ایک SwiftUI موڈیفائر ہے جو onAppear میں غیر ہم وقت ساز کارروائیوں کے مسئلے کو حل کرتا ہے۔ onAppear کے برعکس، .task ایک async کلوزر قبول کرتا ہے، خود بخود اس کے لائف سائیکل کا انتظام کرتا ہے اور View کے غائب ہونے پر اسے منسوخ کرتا ہے۔ جہاں onAppear ہم وقت سازی سے انجام پاتا ہے، .task ایک غیر ہم وقت ساز کارروائی شروع کرتا ہے اور SwiftUI کو onDisappear پر اسے منسوخ کرنے دیتا ہے۔

بنیادی فرق منسوخی کا انتظام ہے۔ جب .task ایک async کارروائی بناتا ہے، SwiftUI Task کا حوالہ محفوظ کرتا ہے اور View کو درجہ بندی سے ہٹانے پر خود بخود cancel() کال کرتا ہے۔ onAppear جس کے اندر Task {} ہو چلتی ہوئی کارروائی کو منسوخ نہیں کرتا — یہ View کے غائب ہونے کے بعد بھی چلتی رہتی ہے، جو دوڑ کی حالت یا ڈی لوکیٹڈ مثال میں تحریر کا سبب بن سکتی ہے۔

مقامی async/await

موڈیفائر کا انتخاب: ہم وقت ساز کارروائیوں (اینیمیشن، تجزیات، لاگنگ) کے لیے onAppear استعمال کریں۔ غیر ہم وقت ساز ڈیٹا لوڈنگ (API، Core Data، فائل سسٹم) کے لیے .task کو ترجیح دیں — یہ زیادہ محفوظ اور صاف ہے۔

.onAppear کے ساتھ عام غلطیاں

غلطی 1: View کی دوبارہ تخلیق کی وجہ سے متعدد کالز۔ جب SwiftUI View باڈی کو دوبارہ بناتا ہے (اسٹیٹ تبدیلی، اسکرین گھومنا)، onAppear دوبارہ کال ہو سکتا ہے۔ حل — لوڈنگ پرچم شامل کریں یا غیر ضروری دوبارہ ڈرائنگ کو روکنے کے لیے .equatable() استعمال کریں۔ SwiftLee (2025) کے مطابق، پروڈکشن میں 40% SwiftUI کیڑے onAppear کے بار بار کال سے متعلق ہیں۔

غلطی 2: مضبوط حوالہ کے ذریعے میموری لیک۔ اگر onAppear کلوزر کمزور حوالہ کے بغیر self کو کیپچر کرتا ہے، تو یہ View کے ساتھ ایک retain cycle بناتا ہے۔ SwiftUI View کے غائب ہونے پر کیپچر شدہ اشیاء کے صفر ہونے کی ضمانت نہیں دیتا۔ ViewModel یا خدمات کے لیے کیپچر لسٹ [weak self] استعمال کریں۔

غلطی 3: پس منظر کے دھاگے میں عملدرآمد۔ onAppear مرکزی دھاگے میں انجام پاتا ہے — یہ UI کارروائیوں کے لیے درست ہے۔ لیکن اگر آپ onAppear کے اندر Task شروع کرتے ہیں، تو یقینی بنائیں کہ @State اپ ڈیٹ MainActor.run کے ذریعے ہو۔ Swift 5.9 اور اس سے اوپر خود بخود MainActor پر واپس آتے ہیں، لیکن @MainActor کو واضح طور پر بتانا بہتر ہے۔

بار بار کال سے کیسے بچیں

لوڈنگ پرچم کے ساتھ نمونہ نقل سے بچاؤ کا سب سے قابل اعتماد طریقہ ہے۔ پرچم کو @State یا @StateObject میں محفوظ کریں اور صرف دستی اپ ڈیٹ پر دوبارہ ترتیب دیں۔ ایک متبادل onAppear کی بجائے .task استعمال کرنا ہے: .task پہلے سے طے شدہ طور پر دوبارہ ڈرائنگ پر دوبارہ شروع نہیں ہوتا اگر async کارروائی پہلے سے چل رہی ہو۔

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()
            }
        }
    }
}