@StateObject: τι είναι, δημιουργία και διαχείριση ObservableObject

Τι είναι το @StateObject στο SwiftUI

@StateObject είναι ένα property wrapper που εισήχθη στο iOS 14 και επιτρέπει σε ένα View να δημιουργεί και να κατέχει ένα στιγμιότυπο μιας κλάσης που συμμορφώνεται με το πρωτόκολλο ObservableObject. Σε αντίθεση με το @State που λειτουργεί με τύπους τιμών (structs), το @StateObject προορίζεται για τύπους αναφοράς — κλάσεις που μπορούν να ειδοποιούν το SwiftUI για αλλαγές στις ιδιότητές τους.

Όταν ένα View χρησιμοποιεί @StateObject var viewModel: MyViewModel, το SwiftUI δημιουργεί αυτόματα το στιγμιότυπο MyViewModel κατά την πρώτη εμφάνιση του View και το αποθηκεύει σε ειδικό χώρο αποθήκευσης του framework. Σε κάθε ενημέρωση του View (για παράδειγμα, κατά την αλλαγή της γονικής κατάστασης), το SwiftUI δεν αναδημιουργεί το αντικείμενο — χρησιμοποιεί το υπάρχον στιγμιότυπο μέχρι να αφαιρεθεί το View από την ιεραρχία.

Σύμφωνα με το Apple WWDC Session 10137 (2024), το @StateObject λύνει το πρόβλημα απώλειας δεδομένων κατά την ανακατασκευή του View που υπήρχε στο iOS 13, όταν οι προγραμματιστές έπρεπε να δημιουργούν το ObservableObject στο γονικό View και να το μεταβιβάζουν μέσω του αρχικοποιητή. Αυτό οδηγούσε σε διπλασιασμό κώδικα και κίνδυνο τυχαίας αναδημιουργίας του αντικειμένου.

import SwiftUI

class CounterViewModel: ObservableObject {
    @Published var count: Int = 0
    
    func increment() {
        count += 1
    }
}

struct CounterView: View {
    @StateObject var viewModel = CounterViewModel()
    
    var body: some View {
        VStack {
            Text("Αριθμός: \(viewModel.count)")
            Button("Αύξηση", action: viewModel.increment)
        }
    }
}

Πώς λειτουργεί το @StateObject

Ο μηχανισμός του @StateObject βασίζεται στην ενσωμάτωση του SwiftUI με το framework Combine. Όταν το ObservableObject επισημαίνει τις ιδιότητές του με το χαρακτηριστικό @Published, το SwiftUI εγγράφεται αυτόματα στις αλλαγές μέσω του publisher που είναι ενσωματωμένος στο πρωτόκολλο ObservableObject. Όταν αλλάζει μια δημοσιευμένη ιδιότητα, το αντικείμενο στέλνει σήμα μέσω του publisher objectWillChange, το οποίο πυροδοτεί την ανασχεδίαση όλων των View που παρατηρούν αυτό το αντικείμενο.

Το SwiftUI αποθηκεύει το στιγμιότυπο ObservableObject σε έναν ειδικό χώρο αποθήκευσης που συνδέεται με ένα συγκεκριμένο στιγμιότυπο View. Αυτός ο χώρος δημιουργείται μία φορά κατά την πρώτη απόδοση και υπάρχει μέχρι την καταστροφή του View. Γι' αυτό ακριβώς το @StateObject εγγυάται τη σταθερότητα της αναφοράς στο αντικείμενο — το SwiftUI διαχειρίζεται αυτόματα τη μνήμη, χωρίς να βασίζεται στον αρχικοποιητή του View.

Σύμφωνα με το objc.io — Thinking in SwiftUI (2025), η εσωτερική υλοποίηση του @StateObject χρησιμοποιεί έναν μηχανισμό παρόμοιο με το @State, αλλά για τύπους αναφοράς: το SwiftUI δημιουργεί ένα περίβλημα boxing γύρω από το αντικείμενο και διαχειρίζεται τον κύκλο ζωής του μέσω του δικού του εκχωρητή, βελτιστοποιημένου για συχνές ανακατασκευές της ιεραρχίας View.

Κύκλος ζωής του @StateObject

• Δημιουργία — κατά την πρώτη εμφάνιση του View στην οθόνη, το SwiftUI καλεί τον αρχικοποιητή του αντικειμένου και αποθηκεύει την αναφορά.
• Ανακατασκευή — κατά την ενημέρωση του γονικού View, το αντικείμενο δεν αναδημιουργείται, χρησιμοποιείται το υπάρχον στιγμιότυπο.
• Καταστροφή — όταν το View εγκαταλείπει την οθόνη και αφαιρείται από την ιεραρχία, το SwiftUI καλεί το deinit του αντικειμένου.

@StateObject vs @ObservedObject: βασικές διαφορές

Η κύρια διαφορά μεταξύ @StateObject και @ObservedObject είναι το ποιος κατέχει το αντικείμενο. Το @StateObject δημιουργεί και αποθηκεύει το αντικείμενο — είναι ο ιδιοκτήτης. Το @ObservedObject απλώς παρατηρεί ένα αντικείμενο που δημιουργήθηκε κάπου αλλού και μεταβιβάστηκε μέσω αρχικοποιητή ή ιδιότητας.

Ο κανόνας είναι απλός: εάν το View δημιουργεί το ObservableObject — χρησιμοποιήστε @StateObject. Εάν το View απλώς λαμβάνει ένα ήδη έτοιμο αντικείμενο από τον γονέα — χρησιμοποιήστε @ObservedObject. Η παραβίαση αυτού του κανόνα οδηγεί είτε σε απώλεια δεδομένων (εάν χρησιμοποιείτε @ObservedObject για ιδιοκτησία), είτε σε υπερβολική δημιουργία αντικειμένων (εάν χρησιμοποιείτε @StateObject για παρατήρηση).

Πότε να χρησιμοποιείτε το @StateObject

Το @StateObject πρέπει να χρησιμοποιείται σε εκείνα τα View που αποτελούν την πηγή αλήθειας για ένα συγκεκριμένο σύνολο δεδομένων. Τυπικά σενάρια περιλαμβάνουν οθόνες με δικό τους view model, ριζικές οθόνες στοίβων πλοήγησης και modal παρουσιάσεις που διαχειρίζονται τη δική τους κατάσταση.

• Οθόνη με view model — κάθε οθόνη που διαχειρίζεται τα δικά της δεδομένα και λογική θα πρέπει να δημιουργεί το view model της μέσω @StateObject.
• Ριζικό View — στην ιεραρχία NavigationStack ή TabView, το ριζικό στοιχείο δημιουργεί δεδομένα και τα θυγατρικά τα λαμβάνουν μέσω @ObservedObject.
• Modal παράθυρα — τα .sheet και .fullScreenCover συχνά απαιτούν δικό τους @StateObject για τη διαχείριση της φόρμας ή της διαδικασίας.
• Λίστα με επεξεργασία — κάθε γραμμή λίστας που περιέχει φόρμα επεξεργασίας θα πρέπει να έχει το δικό της @StateObject.

struct ProfileView: View {
    @StateObject var viewModel = ProfileViewModel()
    
    var body: some View {
        NavigationStack {
            Form {
                TextField("Name", text: $viewModel.name)
                TextField("Email", text: $viewModel.email)
                Button("Αποθήκευση") {
                    viewModel.saveProfile()
                }
            }
            .navigationTitle("Profile")
        }
    }
}

Αρχικοποίηση @StateObject με παραμέτρους

Η αρχικοποίηση του @StateObject με παραμέτρους απαιτεί ειδική σύνταξη, καθώς το SwiftUI διαχειρίζεται ανεξάρτητα τη δημιουργία του αντικειμένου. Δεν μπορείτε απλά να μεταβιβάσετε παραμέτρους στον αρχικοποιητή — πρέπει να χρησιμοποιήσετε escaping closure ή ξεχωριστή μέθοδο δημιουργίας.

Σύμφωνα με το Swift by Sundell (2024), η πιο καθαρή μέθοδος είναι η χρήση μιας μεθόδου εργοστασίου ή closure που το SwiftUI θα καλέσει κατά την πρώτη δημιουργία του αντικειμένου. Μια εναλλακτική προσέγγιση — αρχικοποιήστε το ObservableObject στο γονικό View και μεταβιβάστε το μέσω @StateObject χρησιμοποιώντας τον τυπικό αρχικοποιητή.

class UserViewModel: ObservableObject {
    @Published var user: User
    
    init(user: User) {
        self.user = user
    }
}

struct UserDetailView: View {
    @StateObject var viewModel: UserViewModel
    
    init(user: User) {
        _viewModel = StateObject(wrappedValue: UserViewModel(user: user))
    }
    
    var body: some View {
        Text(viewModel.user.name)
    }
}

Είναι σημαντικό να θυμάστε ότι ο αρχικοποιητής View με @StateObject πρέπει να χρησιμοποιεί υπογράμμιση πριν από το όνομα της ιδιότητας (_viewModel) για πρόσβαση στο ίδιο το property wrapper, όχι στην τιμή του. Αυτό είναι ένα τυπικό μοτίβο Swift για εργασία με property wrappers σε αρχικοποιητές.

Συνήθη λάθη με το @StateObject

Το πιο συνηθισμένο λάθος είναι η χρήση @ObservedObject αντί για @StateObject για ένα View που θα πρέπει να κατέχει το αντικείμενο. Σε αυτήν την περίπτωση, σε κάθε ανακατασκευή του γονέα, το αντικείμενο θα δημιουργείται εκ νέου, οδηγώντας σε απώλεια όλων των συσσωρευμένων δεδομένων. Αυτό το λάθος είναι ιδιαίτερα ύπουλο σε σύνθετες ιεραρχίες με NavigationStack ή TabView.

• Απώλεια δεδομένων κατά την πλοήγηση — εάν μια θυγατρική οθόνη χρησιμοποιεί @ObservedObject για το δικό της view model, κατά την επιστροφή και το εκ νέου άνοιγμα τα δεδομένα θα επαναφερθούν.
• Διαρροή μνήμης — η δημιουργία @StateObject σε ένα γονικό View που δεν αφαιρείται ποτέ μπορεί να οδηγήσει σε συσσώρευση αντικειμένων, εάν κάθε θυγατρική οθόνη δημιουργεί επίσης @StateObject χωρίς έλεγχο.
• Διπλασιασμός αντικειμένων — η μεταβίβαση ενός ObservableObject σε πολλά @StateObject σε διαφορετικά View δημιουργεί πολλαπλές ανεξάρτητες εμφανίσεις που δεν συγχρονίζονται μεταξύ τους.

Για να αποφύγετε αυτά τα προβλήματα, ακολουθήστε τον απλό κανόνα: ένα @StateObject ανά πηγή αλήθειας. Εάν τα δεδομένα πρέπει να είναι κοινά σε πολλές οθόνες — δημιουργήστε το @StateObject μία φορά στο ριζικό View και μεταβιβάστε το μέσω @ObservedObject ή @EnvironmentObject στα θυγατρικά στοιχεία.

// ❌ Λάθος: @ObservedObject για ιδιοκτησία αντικειμένου
struct BadView: View {
    @ObservedObject var vm = ViewModel() // θα αναδημιουργείται σε κάθε ενημέρωση!
}

// ✅ Σωστό: @StateObject για ιδιοκτησία
struct GoodView: View {
    @StateObject var vm = ViewModel() // δημιουργήθηκε μία φορά για τη διάρκεια ζωής του View
}