.onAppear: αρχή λειτουργίας, κύκλος ζωής και παραδείγματα στο SwiftUI

Τι είναι το .onAppear;

.onAppear — ένας τροποποιητής View στο SwiftUI που δέχεται ένα Void κλείσιμο και το εκτελεί τη στιγμή που το View γίνεται ορατό στην οθόνη. Αυτός ο τροποποιητής είναι μέρος του συστήματος κύκλου ζωής των συστατικών SwiftUI μαζί με το .onDisappear και το .task. Η Apple πρόέβαλε το onAppear μαζί με την κυκλοφορία του SwiftUI σε iOS 13 και watchOS 6 ως αντικατάσταση του viewDidLoad από το UIKit.

Συντακτικά, .onAppear τροποποιεί οποιαδήποτε View και επιστρέφει την ίδια View με την συνημμένη ενέργεια. Ο μεταγλωττιστής SwiftUI καλεί το κλείσιμο που δόθηκε μία φορά όταν η προβολή προστίθεται στην ιεραρχία και περνά από τη φάση αποδοτικής απόδοσης. Αν το View διαγραφεί και στη συνέχεια προστεθεί ξανά (π.χ. κατά την κύλιση σε μια λίστα), το onAppear καλείται ξανά — αυτή η συμπεριφορά γίνεται συχνά πηγή απρόβλεπτων σφαλμάτων.

Σύνταξη onAppear

Η βασική σύνταξη του τροποποιητή είναι μινιμαλιστική: onAppear χωρίς παραμέτρους. Στο SwiftUI δεν υπάρχει δυνατότητα μετάβίβασης προτεραιότητας ή κινητοποίησης — το κλείσιμο εκτελείται σύγχρονα στο κύριο νήμα αμέσως μετά την αποδοτική απόδοση.

struct ContentView: View {
    var body: some View {
        Text("Γεια σου SwiftUI!")
            .onAppear {
                print("Το View εμφανίστηκε στην οθόνη")
            }
    }
}

Περιορισμοί: το onAppear δεν υποστηρίζει άμεσα async/await. Για ασύγχρονες λειτουργίες εντός του κλεισίματος χρειάζεται Task {} ή μια ξεχωριστή συνάρτηση async/await που καλείται μέσω Task.detached. Αυτό καθιστά το onAppear λιγότερο βολικό για αιτήματα δικτύου σε σύγκριση με τον τροποποιητή .task.

Πώς λειτουργεί το .onAppear στον κύκλο ζωής View

.onAppear εντάσσεται στον αγωγό αποδοτικής απόδοσης του SwiftUI στη φάση layout+render. Όταν το SwiftUI υπολογίζει το σώμα του View και ανιχνεύει μια αλλαγή στην ιεραρχία, ενεργοποιεί τις επικλήσεις onAppear για όλες τις νέες προστέθεισες προβολές. Η σειρά κλήσης αντιστοιχεί στη σειρά φωλιάσεως: πρώτα onAppear στον γονέα, έπειτα στα θυγατρικά στοιχεία.

Ένα σημαντικό χαρακτηριστικό του SwiftUI — το onAppear δεν συνδέεται με τη φυσική εμφάνιση στην οθόνη. Ο τροποποιητής καλείται όταν το View προστίθεται στην ιεραρχία, ανεξάρτητα από το αν είναι ορατό στον χρήστη (π.χ. εκτός οθόνης σε ScrollView). Αυτό διαφοροποιεί το SwiftUI από το UIKit, όπου το viewWillAppear λειτουργεί μόνο σε πραγματική εμφάνιση.

Σειρά κλήσης onAppear

Η σειρά κλήσης ακολουθεί τον κανόνα parent-first: το VStack ή NavigationView λαμβάνει πρώτο onAppear, έπειτα κάθε θυγατρικό στοιχείο με σειρά. Αυτό είναι κρίσιμο για την αρχικοποίηση κοινών πόρων: εάν τα θυγατρικά στοιχεία εξαρτώνται από δεδομένα που φορτώνονται από τον γονέα, πρέπει να ελέγχουν τη διαθεσιμότητα μέσω Optional.

struct ParentView: View {
    var body: some View {
        VStack {
            ChildView()
            ChildView()
        }
        .onAppear {
            print("Parent onAppear — πρώτο")
        }
    }
}

struct ChildView: View {
    var body: some View {
        Text("Παιδί")
            .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 καλείται για κυψέλες που έχουν εισέλθει στην ορατή περιοχή ή βρίσκονται στο buffer προεπεξεργασίας. Το iOS 18 εισήγαγε έναν μηχανισμό prefetch που μπορεί να καλέσει onAppear για κυψέλες 2–3 οθόνες πριν από κύλιση — αυτό επιταχύνει την αντίληψη, αλλά μπορεί να προκαλέσει περιττά αιτήματα δικτύου.

Χαρακτηριστικά κλήσης στο NavigationStack

NavigationStack (iOS 16+) διαχειρίζεται τη στοίβα οθονών διαφορετικά από το NavigationView. Κατά το push νέας οθόνης το onAppear ενεργοποιείται μόνο στη νέα οθόνη, και η τρέχουσα δεν λαμβάνει onDisappear μέχρι τη πραγματική διαγραφή. Κατά το pop συμβαίνει η αντίστροφη διαδικασία: onDisappear στην εγκαταλειπόμενη οθόνη, onAppear στην επιστρέφουσα.

Παραδείγματα χρήσης .onAppear

Πρακτική εφαρμογή του onAppear καλύπτει τρεις βασικές κατηγορίες: φόρτωση δεδομένων, εκκίνηση κινητοποιήσεων και αποστολή αναλυτικών. Κάθε σενάριο απαιτεί να ληφθούν υπόψη τα χαρακτηριστικά του κύκλου ζωής SwiftUI για να αποφευχθούν οι διπλές κλήσεις και οι διαρροές μνήμης.

Φόρτωση δεδομένων από API

Φόρτωση δεδομένων — το πιο συνηθισμένο σενάριο onAppear. Μέσα στο κλείσιμο δημιουργείται ένα 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()
            }
        }
    }
}

Guard against re-fetch — μια κρίσιμη πρακτική. Εάν το SwiftUI δημιουργήσει ξανά το View (π.χ. κατά την περιστροφή οθόνης), το onAppear θα κληθεί ξανά χωρίς guard. Εναλλακτική είναι η χρήση .task που ακυρώνει αυτόματα το προηγούμενο αίτημα.

Εκκίνηση κινητοποίησης εισόδου

Κινητοποίηση εισόδου χρησιμοποιεί το onAppear για να αλλάξει μεταβλητές state που πυροδοτούν την κινητοποίηση μέσω withAnimation ή του animation τροποποιητή. Τυπικό μοτίβο: αρχική κατάσταση (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 vs .task — ποια η διαφορά

.task — ένας τροποποιητής SwiftUI που προστέθηκε στο iOS 15 και επιλύει το πρόβλημα των ασύγχρονων λειτουργιών στο onAppear. Σε αντίθεση με το onAppear, το .task δέχεται ένα async κλείσιμο, διαχειρίζεται αυτόματα τον κύκλο ζωής του και το ακυρώνει όταν το View εξαφανίζεται. Ενώ το onAppear εκτελείται σύγχρονα, το .task εκκινά μια ασύγχρονη λειτουργία και επιτρέπει στο SwiftUI να την ακυρώσει στο onDisappear.

Η κύρια διαφορά — διαχείριση ακύρωσης. Όταν το .task δημιουργεί μια async λειτουργία, το SwiftUI διατηρεί αναφορά στο Task και καλεί αυτόματα τη cancel() κατά τη διαγραφή του View από την ιεραρχία. Το onAppear με Task {} εσωτερικά δεν ακυρώνει την εκκινηθείσα λειτουργία — αυτή συνεχίζει να εκτελείται ακόμα και αφού το View εξαφανιστεί, πράγμα που μπορεί να προκαλέσει συνθήκη ανταγωνισμού ή εγγραφή σε μια ήδη απελευθερωμένη περίπτωση.

Επιλογή τροποποιητή: για σύγχρονες ενέργειες (κινητοποιήσεις, αναλυτικά, αρχεία καταγραφής) χρησιμοποιήστε το onAppear. Για ασύγχρονη φόρτωση δεδομένων (API, Core Data, σύστημα αρχείων) το .task είναι προτιμότερο — πιο ασφαλές και πιο καθαρό.

Συνηθισμένα λάθη με το .onAppear

Λάθος 1: πολλαπλή κλήση λόγω αναδημιουργίας View. Όταν το SwiftUI αναδημιουργεί το σώμα View (αλλαγή @State, περιστροφή οθόνης), το onAppear μπορεί να κληθεί ξανά. Λύση — προσθήκη σημαίας φόρτωσης ή χρήση .equatable() για την αποφυγή περιττών επανασχεδιασμών. Σύμφωνα με το SwiftLee (2025), το 40% των σφαλμάτων SwiftUI σε παραγωγή σχετίζονται ακριβώς με επαναληπτικές κλήσεις onAppear.

Λάθος 2: διαρροή μνήμης μέσω ισχυρής αναφοράς. Εάν το κλείσιμο onAppear συλλαμβάνει το self χωρίς ασθενή αναφορά, δημιουργείται ένας retain cycle με το View. Το SwiftUI δεν εγγυάται τη μηδένιση των συλληφθέντων αντικειμένων κατά την εξαφάνιση του View. Χρησιμοποιήστε capture list [weak self] για ViewModel ή υπηρεσίες.

Λάθος 3: εκτέλεση σε νήμα υποβάθρου. Το onAppear εκτελείται στο κύριο νήμα — αυτό είναι σωστό για λειτουργίες UI. Αλλά εάν εκκινήσετε ένα Task μέσα στο onAppear, βεβαιωθείτε ότι η ενημέρωση @State γίνεται μέσω MainActor.run. Το Swift 5.9 και νεότερες εκδόσεις επιστρέφουν αυτόματα στο MainActor, αλλά είναι καλύτερο να καθορίζετε ρητά το @MainActor.

Πώς να αποφύγετε τις επαναληπτικές κλήσεις

Μοτίβο με σημαία φόρτωσης είναι ο πιο αξιόπιστος τρόπος προστασίας από τη διπλοτυπία. Αποθηκεύστε τη σημαία σε @State ή @StateObject και την επαναφέρετε μόνο σε χειροκίνητη ενημέρωση. Εναλλακτική — χρήση .task αντί για onAppear: το .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()
            }
        }
    }
}